Subversion-Projekte lars-tiefland.php_share

<?php

/**

 * Getargs.php

 *

 * @category  Extension

 * @package   Console_Getargs

 * @author    Bertrand Mansion <bmansion@mamasam.com>

 * @copyright 2004 Bertrand Mansion

 * @license   http://www.php.net/license/3_0.txt PHP License 3.0

 * @version   1.3.5

 * @link      http://pear.php.net/package/Console_Getargs

 */

/* vim: set expandtab tabstop=4 shiftwidth=4: */

// +----------------------------------------------------------------------+

// | PHP Version 4                                                        |

// +----------------------------------------------------------------------+

// | Copyright (c) 2004 The PHP Group                                     |

// +----------------------------------------------------------------------+

// | This source file is subject to version 3.0 of the PHP license,       |

// | that is bundled with this package in the file LICENSE, and is        |

// | available through the world-wide-web at the following url:           |

// | http://www.php.net/license/3_0.txt.                                  |

// | If you did not receive a copy of the PHP license and are unable to   |

// | obtain it through the world-wide-web, please send a note to          |

// | license@php.net so we can mail you a copy immediately.               |

// +----------------------------------------------------------------------+

// | Author: Bertrand Mansion <bmansion@mamasam.com>                      |

// +----------------------------------------------------------------------+

//

// $Id: Getargs.php 304313 2010-10-11 14:37:56Z jespino $

require_once 'PEAR.php';

/**#@+

 * Error Constants

*/

/**

 * Wrong configuration

 *

 * This error will be TRIGGERed when a configuration error is found,

 * it will also issue a WARNING.

 */

define('CONSOLE_GETARGS_ERROR_CONFIG', -1);

/**

 * User made an error

 *

 * This error will be RETURNed when a bad parameter

 * is found in the command line, for example an unknown parameter

 * or a parameter with an invalid number of options.

 */

define('CONSOLE_GETARGS_ERROR_USER', -2);

/**

 * Help text wanted

 *

 * This error will be RETURNed when the user asked to

 * see the help by using <kbd>-h</kbd> or <kbd>--help</kbd> in the command line, you can then print

 * the help ascii art text by using the {@link Console_Getargs::getHelp()} method

 */

define('CONSOLE_GETARGS_HELP', -3);

/**

 * Option name for application "parameters"

 *

 * Parameters are the options an application needs to function.

 * The two files passed to the diff command would be considered

 * the parameters. These are different from other options in that

 * they do not need an option name passed on the command line.

 */

define('CONSOLE_GETARGS_PARAMS', 'parameters');

/**#@-*/

/**

 * Command-line arguments parsing class

 *

 * This implementation was freely inspired by a python module called

 * getargs by Vinod Vijayarajan and a perl CPAN module called

 * Getopt::Simple by Ron Savage

 *

 * This class implements a Command Line Parser that your cli applications

 * can use to parse command line arguments found in $_SERVER['argv'] or a

 * user defined array.

 *

 * It gives more flexibility and error checking than Console_Getopt. It also

 * performs some arguments validation and is capable to return a formatted

 * help text to the user, based on the configuration it is given.

 *

 * The class provides the following capabilities:

 * - Each command line option can take an arbitrary number of arguments.

 * - Makes the distinction between switches (options without arguments)

 *   and options that require arguments.

 * - Recognizes 'single-argument-options' and 'default-if-set' options.

 * - Switches and options with arguments can be interleaved in the command

 *   line.

 * - You can specify the maximum and minimum number of arguments an option

 *   can take. Use -1 if you don't want to specify an upper bound.

 * - Specify the default arguments to an option

 * - Short options can be more than one letter in length.

 * - A given option may be invoked by multiple names (aliases).

 * - Understands by default the --help, -h options

 * - Can return a formatted help text

 * - Arguments may be specified using the '=' syntax also.

 * - Short option names may be concatenated (-dvw 100 == -d -v -w 100)

 * - Can define a default option that will take any arguments added without

 *   an option name

 * - Can pass in a user defined array of arguments instead of using

 *   $_SERVER['argv']

 *

 * @todo      Implement the parsing of comma delimited arguments

 * @todo      Implement method for turning assocative arrays into command

 *            line arguments (ex. array('d' => true, 'v' => 2) -->

 *            array('-d', '-v', 2))

 *

 * @category  Extension

 * @package   Console_Getargs

 * @author    Bertrand Mansion <bmansion@mamasam.com>

 * @copyright 2004 Bertrand Mansion

 * @license   http://www.php.net/license/3_0.txt PHP License 3.0

 * @version   1.3.5

 * @link      http://pear.php.net/package/Console_Getargs

 */

class Console_Getargs

{

    /**

     * Factory creates a new {@link Console_Getargs_Options} object

     *

     * This method will return a new {@link Console_Getargs_Options}

     * built using the given configuration options. If the configuration

     * or the command line options contain errors, the returned object will

     * in fact be a PEAR_Error explaining the cause of the error.

     *

     * Factory expects an array as parameter.

     * The format for this array is:

     * <pre>

     * array(

     *  longname => array('short'   => Short option name,

     *                    'max'     => Maximum arguments for option,

     *                    'min'     => Minimum arguments for option,

     *                    'default' => Default option argument,

     *                    'desc'    => Option description)

     * )

     * </pre>

     *

     * If an option can be invoked by more than one name, they have to be defined

     * by using | as a separator. For example: name1|name2

     * This works both in long and short names.

     *

     * max/min are the most/least number of arguments an option accepts.

     *

     * The 'defaults' field is optional and is used to specify default

     * arguments to an option. These will be assigned to the option if

     * it is *not* used in the command line.

     * Default arguments can be:

     * - a single value for options that require a single argument,

     * - an array of values for options with more than one possible arguments.

     * Default argument(s) are mandatory for 'default-if-set' options.

     *

     * If max is 0 (option is just a switch), min is ignored.

     * If max is -1, then the option can have an unlimited number of arguments

     * greater or equal to min.

     *

     * If max == min == 1, the option is treated as a single argument option.

     *

     * If max >= 1 and min == 0, the option is treated as a

     * 'default-if-set' option. This implies that it will get the default argument

     * only if the option is used in the command line without any value.

     * (Note: defaults *must* be specified for 'default-if-set' options)

     *

     * If the option is not in the command line, the defaults are

     * *not* applied. If an argument for the option is specified on the command

     * line, then the given argument is assigned to the option.

     * Thus:

     * - a --debug in the command line would cause debug = 'default argument'

     * - a --debug 2 in the command line would result in debug = 2

     *  if not used in the command line, debug will not be defined.

     *

     * Example 1.

     * <code>

     * require_once 'Console/Getargs.php';

     *

     * $args =& Console_Getargs::factory($config);

     *

     * if (PEAR::isError($args)) {

     *  if ($args->getCode() === CONSOLE_GETARGS_ERROR_USER) {

     *    echo Console_Getargs::getHelp($config, null, $args->getMessage())."\n";

     *  } else if ($args->getCode() === CONSOLE_GETARGS_HELP) {

     *    echo Console_Getargs::getHelp($config)."\n";

     *  }

     *  exit;

     * }

     *

     * echo 'Verbose: '.$args->getValue('verbose')."\n";

     * if ($args->isDefined('bs')) {

     *  echo 'Block-size: '.(is_array($args->getValue('bs')) ? implode(', ', $args->getValue('bs'))."\n" : $args->getValue('bs')."\n");

     * } else {

     *  echo "Block-size: undefined\n";

     * }

     * echo 'Files: '.($args->isDefined('file') ? implode(', ', $args->getValue('file'))."\n" : "undefined\n");

     * if ($args->isDefined('n')) {

     *  echo 'Nodes: '.(is_array($args->getValue('n')) ? implode(', ', $args->getValue('n'))."\n" : $args->getValue('n')."\n");

     * } else {

     *  echo "Nodes: undefined\n";

     * }

     * echo 'Log: '.$args->getValue('log')."\n";

     * echo 'Debug: '.($args->isDefined('d') ? "YES\n" : "NO\n");

     *

     * </code>

     *

     * If you don't want to require any option name for a set of arguments,

     * or if you would like any "leftover" arguments assigned by default,

     * you can create an option named CONSOLE_GETARGS_PARAMS that will

     * grab any arguments that cannot be assigned to another option. The

     * rules for CONSOLE_GETARGS_PARAMS are still the same. If you specify

     * that two values must be passed then two values must be passed. See

     * the example script for a complete example.

     *

     * @param array $config    associative array with keys being the

     * @param array $arguments numeric array of command line arguments

     *

     * @access public

     * @return object|PEAR_Error a newly created Console_Getargs_Options

     *                           object or a PEAR_Error object on error

     */

    function &factory($config = array(), $arguments = null)

    {

        // Create the options object.

        $obj = & new Console_Getargs_Options();

        // Try to set up the arguments.

        $err = $obj->init($config, $arguments);

        if ($err !== true) {

            return $err;

        }

        // Try to set up the options.

        $err = $obj->buildMaps();

        if ($err !== true) {

            return $err;

        }

        // Get the options and arguments from the command line.

        $err = $obj->parseArgs();

        if ($err !== true) {

            return $err;

        }

        // Set arguments for options that have defaults.

        $err = $obj->setDefaults();

        if ($err !== true) {

            return $err;

        }

        // Double check that all required options have been passed.

        $err = $obj->checkRequired();

        if ($err !== true) {

            return $err;

        }

        // All is good.

        return $obj;

    }

    /**

     * Returns an ascii art version of the help

     *

     * This method uses the given configuration and parameters

     * to create and format an help text for the options you defined

     * in your config parameter. You can supply a header and a footer

     * as well as the maximum length of a line. If you supplied

     * descriptions for your options, they will be used as well.

     *

     * By default, it returns something like this:

     * <pre>

     * Usage: myscript.php [-dv --formats] <-fw --filters>

     *

     * -f --files values(2)          Set the source and destination image files.

     * -w --width=<value>      Set the new width of the image.

     * -d --debug                    Switch to debug mode.

     * --formats values(1-3)         Set the image destination format. (jpegbig,

     *                               jpegsmall)

     * -fi --filters values(1-...)   Set the filters to be applied to the image upon

     *                               conversion. The filters will be used in the order

     *                               they are set.

     * -v --verbose (optional)value  Set the verbose level. (3)

     * </pre>

     *

     * @param array  $config     your args configuration

     * @param string $helpHeader the header for the help. If it is left null,

     *                           a default header will be used, starting by Usage:

     * @param string $helpFooter the footer for the help. This could be used

     *                           to supply a description of the error the user made

     * @param int    $maxlength  help lines max length

     * @param int    $indent     the indent for the options

     *

     * @access public

     * @return string the formatted help text

     */

    function getHelp($config, $helpHeader = null, $helpFooter = '', $maxlength = 78, $indent = 0)

    {

        // Start with an empty help message and build it piece by piece

        $help = '';

        // If no user defined header, build the default header.

        if (!isset($helpHeader)) {

            // Get the optional, required and "paramter" names for this config.

            list($optional, $required, $params) = Console_Getargs::getOptionalRequired($config);

            // Start with the file name.

            if (isset($_SERVER['SCRIPT_NAME'])) {

                $filename = basename($_SERVER['SCRIPT_NAME']);

            } else {

                $filename = $argv[0];

            }

            $helpHeader = 'Usage: ' . $filename . ' ';

            // Add the optional arguments and required arguments.

            $helpHeader.= $optional . ' ' . $required . ' ';

            // Add any parameters that are needed.

            $helpHeader.= $params . "\n\n";

        }

        // Create an indent string to be prepended to each option row.

        $indentStr = str_repeat(' ', (int)$indent);

        // Go through all of the short options to get a padding value.

        $v = array_values($config);

        $shortlen = 0;

        foreach ($v as $item) {

            if (isset($item['short'])) {

                $shortArr = explode('|', $item['short']);

                if (strlen($shortArr[0]) > $shortlen) {

                    $shortlen = strlen($shortArr[0]);

                }

            }

        }

        // Add two to account for the extra characters we add automatically.

        $shortlen+= 2;

        // Build the list of options and definitions.

        $i = 0;

        foreach ($config as $long => $def) {

            // Break the names up if there is more than one for an option.

            $shortArr = array();

            if (isset($def['short'])) {

                $shortArr = explode('|', $def['short']);

            }

            $longArr = explode('|', $long);

            // Column one is the option name displayed as "-short, --long [additional info]"

            // Start with the indent string.

            $col1[$i] = $indentStr;

            // Add the short option name.

            $col1[$i].= str_pad(!empty($shortArr) ? '-' . $shortArr[0] . ' ' : '', $shortlen);

            // Add the long option name.

            $col1[$i].= '--' . $longArr[0];

            // Get the min and max to show needed/optional values.

            // Cast to int to avoid complications elsewhere.

            $max = (int)$def['max'];

            $min = isset($def['min']) ? (int)$def['min'] : $max;

            if ($max === 1 && $min === 1) {

                // One value required.

                $col1[$i].= '=<value>';

            } else if ($max > 1) {

                if ($min === $max) {

                    // More than one value needed.

                    $col1[$i].= ' values(' . $max . ')';

                } else if ($min === 0) {

                    // Argument takes optional value(s).

                    $col1[$i].= ' values(optional)';

                } else {

                    // Argument takes a range of values.

                    $col1[$i].= ' values(' . $min . '-' . $max . ')';

                }

            } else if ($max === 1 && $min === 0) {

                // Argument can take at most one value.

                $col1[$i].= ' (optional)value';

            } else if ($max === - 1) {

                // Argument can take unlimited values.

                if ($min > 0) {

                    $col1[$i].= ' values(' . $min . '-...)';

                } else {

                    $col1[$i].= ' (optional)values';

                }

            }

            // Column two is the description if available.

            if (isset($def['desc'])) {

                $col2[$i] = $def['desc'];

            } else {

                $col2[$i] = '';

            }

            // Add the default value(s) if there are any/

            if (isset($def['default'])) {

                if (is_array($def['default'])) {

                    $col2[$i].= ' (' . implode(', ', $def['default']) . ')';

                } else {

                    $col2[$i].= ' (' . $def['default'] . ')';

                }

            }

            $i++;

        }

        // Figure out the maximum length for column one.

        $arglen = 0;

        foreach ($col1 as $txt) {

            $length = strlen($txt);

            if ($length > $arglen) {

                $arglen = $length;

            }

        }

        // The maximum length for each description line.

        $desclen = $maxlength - $arglen;

        $padding = str_repeat(' ', $arglen);

        foreach ($col1 as $k => $txt) {

            // Wrap the descriptions.

            if (strlen($col2[$k]) > $desclen) {

                $desc = wordwrap($col2[$k], $desclen, "\n  " . $padding);

            } else {

                $desc = $col2[$k];

            }

            // Push everything together.

            $help.= str_pad($txt, $arglen) . '  ' . $desc . "\n";

        }

        // Put it all together.

        return $helpHeader . $help . $helpFooter;

    }

    /**

     * Parse the config array to determine which flags are

     * optional and which are required.

     *

     * To make the help header more descriptive, the options

     * are shown seperated into optional and required flags.

     * When possible the short flag is used for readability.

     * Optional items (including "parameters") are surrounded

     * in square braces ([-vd]). Required flags are surrounded

     * in angle brackets (<-wf>).

     *

     * This method may be called statically.

     *

     * @param array &$config The config array.

     *

     * @access  public

     * @return  array

     * @author  Scott Mattocks

     * @package Console_Getargs

     */

    function getOptionalRequired(&$config)

    {

        // Parse the config array and look for optional/required

        // tags.

        $optional = '';

        $optionalHasShort = false;

        $required = '';

        $requiredHasShort = false;

        ksort($config);

        foreach ($config as $long => $def) {

            // We only really care about the first option name.

            $long = explode('|', $long);

            $long = reset($long);

            // Treat the "parameters" specially.

            if ($long == CONSOLE_GETARGS_PARAMS) {

                continue;

            }

            if (isset($def['short'])) {

                // We only really care about the first option name.

                $def['short'] = explode('|', $def['short']);

                $def['short'] = reset($def['short']);

            }

            if (!isset($def['min']) || $def['min'] == 0 || isset($def['default'])) {

                // This argument is optional.

                if (isset($def['short']) && strlen($def['short']) == 1) {

                    $optional = $def['short'] . $optional;

                    $optionalHasShort = true;

                } else {

                    $optional.= ' --' . $long;

                }

            } else {

                // This argument is required.

                if (isset($def['short']) && strlen($def['short']) == 1) {

                    $required = $def['short'] . $required;

                    $requiredHasShort = true;

                } else {

                    $required.= ' --' . $long;

                }

            }

        }

        // Check for "parameters" option.

        $params = '';

        if (isset($config[CONSOLE_GETARGS_PARAMS])) {

            for ($i = 1; $i <= max($config[CONSOLE_GETARGS_PARAMS]['max'], $config[CONSOLE_GETARGS_PARAMS]['min']); ++$i) {

                if ($config[CONSOLE_GETARGS_PARAMS]['max'] == - 1 || ($i > $config[CONSOLE_GETARGS_PARAMS]['min'] && $i <= $config[CONSOLE_GETARGS_PARAMS]['max']) || isset($config[CONSOLE_GETARGS_PARAMS]['default'])) {

                    // Parameter is optional.

                    $params.= '[param' . $i . '] ';

                } else {

                    // Parameter is required.

                    $params.= 'param' . $i . ' ';

                }

            }

        }

        // Add a leading - if needed.

        if ($optionalHasShort) {

            $optional = '-' . $optional;

        }

        if ($requiredHasShort) {

            $required = '-' . $required;

        }

        // Add the extra characters if needed.

        if (!empty($optional)) {

            $optional = '[' . $optional . ']';

        }

        if (!empty($required)) {

            $required = '<' . $required . '>';

        }

        return array($optional, $required, $params);

    }

} // end class Console_Getargs

/**

 * This class implements a wrapper to the command line options and arguments.

 *

 * @category Extension

 * @package  Console_Getargs

 * @author   Bertrand Mansion <bmansion@mamasam.com>

 * @license  http://www.php.net/license/3_0.txt PHP License 3.0

 * @link     http://pear.php.net/package/Console_Getargs

 */

class Console_Getargs_Options

{

    /**

     * Lookup to match short options name with long ones

     * @var    array

     * @access private

     */

    var $_shortLong = array();

    /**

     * Lookup to match alias options name with long ones

     * @var    array

     * @access private

     */

    var $_aliasLong = array();

    /**

     * Arguments set for the options

     * @var    array

     * @access private

     */

    var $_longLong = array();

    /**

     * If arguments have been defined on cmdline

     * @var    array

     * @access private

     */

    var $_defined = array();

    /**

     * Configuration set at initialization time

     * @var    array

     * @access private

     */

    var $_config = array();

    /**

     * A read/write copy of argv

     * @var    array

     * @access private

     */

    var $args = array();

    /**

     * Initializes the Console_Getargs_Options object

     *

     * @param array $config    configuration options

     * @param array $arguments arguments

     *

     * @access private

     * @throws CONSOLE_GETARGS_ERROR_CONFIG

     * @return true|PEAR_Error

     */

    function init($config, $arguments = null)

    {

        if (is_array($arguments)) {

            // Use the user defined argument list.

            $this->args = $arguments;

        } else {

            // Command line arguments must be available.

            if (!isset($_SERVER['argv']) || !is_array($_SERVER['argv'])) {

                return PEAR::raiseError("Could not read argv", CONSOLE_GETARGS_ERROR_CONFIG, PEAR_ERROR_TRIGGER, E_USER_WARNING, 'Console_Getargs_Options::init()');

            }

            $this->args = $_SERVER['argv'];

        }

        // Drop the first argument if it doesn't begin with a '-'.

        if (isset($this->args[0] { 0 })

            && $this->args[0] { 0 } != '-'

        ) {

            array_shift($this->args);

        }

        $this->_config = $config;

        return true;

    }

    /**

     * Makes the lookup arrays for alias and short name mapping with long names

     *

     * @access private

     * @throws CONSOLE_GETARGS_ERROR_CONFIG

     * @return true|PEAR_Error

     */

    function buildMaps()

    {

        foreach ($this->_config as $long => $def) {

            $longArr = explode('|', $long);

            $longname = $longArr[0];

            if (count($longArr) > 1) {

                // The fisrt item in the list is "the option".

                // The rest are aliases.

                array_shift($longArr);

                foreach ($longArr as $alias) {

                    // Watch out for duplicate aliases.

                    if (isset($this->_aliasLong[$alias])) {

                        return PEAR::raiseError('Duplicate alias for long option ' . $alias, CONSOLE_GETARGS_ERROR_CONFIG, PEAR_ERROR_TRIGGER, E_USER_WARNING, 'Console_Getargs_Options::buildMaps()');

                    }

                    $this->_aliasLong[$alias] = $longname;

                }

                // Add the real option name and defintion.

                $this->_config[$longname] = $def;

                // Get rid of the old version (name|alias1|...)

                unset($this->_config[$long]);

            }

            // Add the (optional) short option names.

            if (!empty($def['short'])) {

                // Short names

                $shortArr = explode('|', $def['short']);

                $short = $shortArr[0];

                if (count($shortArr) > 1) {

                    // The first item is "the option".

                    // The rest are aliases.

                    array_shift($shortArr);

                    foreach ($shortArr as $alias) {

                        // Watch out for duplicate aliases.

                        if (isset($this->_shortLong[$alias])) {

                            return PEAR::raiseError('Duplicate alias for short option ' . $alias, CONSOLE_GETARGS_ERROR_CONFIG, PEAR_ERROR_TRIGGER, E_USER_WARNING, 'Console_Getargs_Options::buildMaps()');

                        }

                        $this->_shortLong[$alias] = $longname;

                    }

                }

                // Add the real short option name.

                $this->_shortLong[$short] = $longname;

            }

        }

        return true;

    }

    /**

     * Parses the given options/arguments one by one

     *

     * @access private

     * @throws CONSOLE_GETARGS_HELP

     * @throws CONSOLE_GETARGS_ERROR_USER

     * @return true|PEAR_Error

     */

    function parseArgs()

    {

        // Go through the options and parse the arguments for each.

        for ($i = 0, $count = count($this->args); $i < $count; $i++) {

            $arg = $this->args[$i];

            if ($arg === '--help' || $arg === '-h') {

                // Asking for help breaks the loop.

                return PEAR::raiseError(null, CONSOLE_GETARGS_HELP, PEAR_ERROR_RETURN);

            }

            if ($arg === '--') {

                // '--' alone signals the start of "parameters"

                $err = $this->parseArg(CONSOLE_GETARGS_PARAMS, true, ++$i);

            } elseif (strlen($arg) > 1 && $arg{0} == '-' && $arg{1} == '-') {

                // Long name used (--option)

                $err = $this->parseArg(substr($arg, 2), true, $i);

            } else if (strlen($arg) > 1 && $arg{0} == '-') {

                // Short name used (-o)

                $err = $this->parseArg(substr($arg, 1), false, $i);

                if ($err === - 1) {

                    break;

                }

            } elseif (isset($this->_config[CONSOLE_GETARGS_PARAMS])) {

                // No flags at all. Try the parameters option.

                $tempI = & $i - 1;

                $err = $this->parseArg(CONSOLE_GETARGS_PARAMS, true, $tempI);

            } else {

                $err = PEAR::raiseError('Unknown argument ' . $arg, CONSOLE_GETARGS_ERROR_USER, PEAR_ERROR_RETURN, null, 'Console_Getargs_Options::parseArgs()');

            }

            if ($err !== true) {

                return $err;

            }

        }

        // Check to see if we need to reload the arguments

        // due to concatenated short names.

        if (isset($err) && $err === - 1) {

            return $this->parseArgs();

        }

        return true;

    }

    /**

     * Parses one option/argument

     *

     * @access private

     * @throws CONSOLE_GETARGS_ERROR_USER

     * @return true|PEAR_Error

     */

    function parseArg($arg, $isLong, &$pos)

    {

        // If the whole short option isn't in the shortLong array

        // then break it into a bunch of switches.

        if (!$isLong && !isset($this->_shortLong[$arg]) && strlen($arg) > 1) {

            $newArgs = array();

            for ($i = 0; $i < strlen($arg); $i++) {

                if (array_key_exists($arg{$i}, $this->_shortLong)) {

                    $newArgs[] = '-' . $arg{$i};

                } else {

                    $newArgs[] = $arg{$i};

                }

            }

            // Add the new args to the array.

            array_splice($this->args, $pos, 1, $newArgs);

            // Reset the option values.

            $this->_longLong = array();

            $this->_defined = array();

            // Then reparse the arguments.

            return -1;

        }

        $opt = '';

        for ($i = 0; $i < strlen($arg); $i++) {

            // Build the option name one char at a time looking for a match.

            $opt.= $arg{$i};

            if ($isLong === false && isset($this->_shortLong[$opt])) {

                // Found a match in the short option names.

                $cmp = $opt;

                $long = $this->_shortLong[$opt];

            } elseif ($isLong === true && isset($this->_config[$opt])) {

                // Found a match in the long option names.

                $long = $cmp = $opt;

            } elseif ($isLong === true && isset($this->_aliasLong[$opt])) {

                // Found a match in the long option names.

                $long = $this->_aliasLong[$opt];

                $cmp = $opt;

            }

            if ($arg{$i} === '=') {

                // End of the option name when '=' is found.

                break;

            }

        }

        // If no option name is found, assume -- was passed.

        if ($opt == '') {

            $long = CONSOLE_GETARGS_PARAMS;

        }

        if (isset($long)) {

            // A match was found.

            if (strlen($arg) > strlen($cmp)) {

                // Seperate the argument from the option.

                // Ex: php test.php -f=image.png

                //     $cmp = 'f'

                //     $arg = 'f=image.png'

                $arg = substr($arg, strlen($cmp));

                // Now $arg = '=image.png'

                if ($arg{0} === '=') {

                    $arg = substr($arg, 1);

                    // Now $arg = 'image.png'

                }

            } else {

                // No argument passed for option.

                $arg = '';

            }

            // Set the options value.

            return $this->setValue($long, $arg, $pos);

        }

        return PEAR::raiseError('Unknown argument ' . $opt, CONSOLE_GETARGS_ERROR_USER, PEAR_ERROR_RETURN, null, 'Console_Getargs_Options::parseArg()');

    }

    /**

     * Set the option arguments

     *

     * @access private

     * @throws CONSOLE_GETARGS_ERROR_CONFIG

     * @throws CONSOLE_GETARGS_ERROR_USER

     * @return true|PEAR_Error

     */

    function setValue($optname, $value, &$pos)

    {

        if (!isset($this->_config[$optname]['max'])) {

            // Max must be set for every option even if it is zero or -1.

            return PEAR::raiseError('No max parameter set for ' . $optname, CONSOLE_GETARGS_ERROR_CONFIG, PEAR_ERROR_TRIGGER, E_USER_WARNING, 'Console_Getargs_Options::setValue()');

        }

        $max = (int)$this->_config[$optname]['max'];

        $min = isset($this->_config[$optname]['min']) ? (int)$this->_config[$optname]['min'] : $max;

        // A value was passed after the option.

        if ($value !== '') {

            // Argument is like -v5

            if ($min == 1 && $max > 0) {

                // At least one argument is required for option.

                $this->updateValue($optname, $value);

                return true;

            }

            if ($max === 0) {

                // Argument passed but not expected.

                return PEAR::raiseError('Argument ' . $optname . ' does not take any value', CONSOLE_GETARGS_ERROR_USER, PEAR_ERROR_RETURN, null, 'Console_Getargs_Options::setValue()');

            }

            // Not enough arguments passed for this option.

            return PEAR::raiseError('Argument ' . $optname . ' expects more than one value', CONSOLE_GETARGS_ERROR_USER, PEAR_ERROR_RETURN, null, 'Console_Getargs_Options::setValue()');

        }

        if ($min === 1 && $max === 1) {

            // Argument requires 1 value

            // If optname is "parameters" take a step back.

            if ($optname == CONSOLE_GETARGS_PARAMS) {

                $pos--;

            }

            if (isset($this->args[$pos + 1]) && $this->isValue($this->args[$pos + 1])) {

                // Set the option value and increment the position.

                $this->updateValue($optname, $this->args[$pos + 1]);

                $pos++;

                return true;

            }

            // What we thought was the argument was really the next option.

            return PEAR::raiseError('Argument ' . $optname . ' expects one value', CONSOLE_GETARGS_ERROR_USER, PEAR_ERROR_RETURN, null, 'Console_Getargs_Options::setValue()');

        } else if ($max === 0) {

            // Argument is a switch

            if (isset($this->args[$pos + 1]) && $this->isValue($this->args[$pos + 1])) {

                // What we thought was the next option was really an argument for this option.

                // First update the value

                $this->updateValue($optname, true);

                // Then try to assign values to parameters.

                if (isset($this->_config[CONSOLE_GETARGS_PARAMS])) {

                    return $this->setValue(CONSOLE_GETARGS_PARAMS, '', ++$pos);

                } else {

                    return PEAR::raiseError('Argument ' . $optname . ' does not take any value', CONSOLE_GETARGS_ERROR_USER, PEAR_ERROR_RETURN, null, 'Console_Getargs_Options::setValue()');

                }

            }

            // Set the switch to on.

            $this->updateValue($optname, true);

            return true;

        } else if ($max >= 1 && $min === 0) {

            // Argument has a default-if-set value

            if (!isset($this->_config[$optname]['default'])) {

                // A default value MUST be assigned when config is loaded.

                return PEAR::raiseError('No default value defined for ' . $optname, CONSOLE_GETARGS_ERROR_CONFIG, PEAR_ERROR_TRIGGER, E_USER_WARNING, 'Console_Getargs_Options::setValue()');

            }

            if (is_array($this->_config[$optname]['default'])) {

                // Default value cannot be an array.

                return PEAR::raiseError('Default value for ' . $optname . ' must be scalar', CONSOLE_GETARGS_ERROR_CONFIG, PEAR_ERROR_TRIGGER, E_USER_WARNING, 'Console_Getargs_Options::setValue()');

            }

            // If optname is "parameters" take a step back.

            if ($optname == CONSOLE_GETARGS_PARAMS) {

                $pos--;

            }

            if (isset($this->args[$pos + 1]) && $this->isValue($this->args[$pos + 1])) {

                // Assign the option the value from the command line if there is one.

                $this->updateValue($optname, $this->args[$pos + 1]);

                $pos++;

                return true;

            }

            // Otherwise use the default value.

            $this->updateValue($optname, $this->_config[$optname]['default']);

            return true;

        }

        // Argument takes one or more values

        $added = 0;

        // If trying to assign values to parameters, must go back one position.

        if ($optname == CONSOLE_GETARGS_PARAMS) {

            $pos = max($pos - 1, -1);

        }

        for ($i = $pos + 1; $i <= count($this->args); $i++) {

            $paramFull = $max <= count($this->getValue($optname)) && $max != - 1;

            if (isset($this->args[$i]) && $this->isValue($this->args[$i]) && !$paramFull) {

                // Add the argument value until the next option is hit.

                $this->updateValue($optname, $this->args[$i]);

                $added++;

                $pos++;

                // Only keep trying if we haven't filled up yet.

                // or there is no limit

                if (($added < $max || $max < 0) && ($max < 0 || !$paramFull)) {

                    continue;

                }

            }

            if ($min > $added && !$paramFull) {

                // There aren't enough arguments for this option.

                return PEAR::raiseError('Argument ' . $optname . ' expects at least ' . $min . (($min > 1) ? ' values' : ' value'), CONSOLE_GETARGS_ERROR_USER, PEAR_ERROR_RETURN, null, 'Console_Getargs_Options::setValue()');

            } elseif ($max !== - 1 && $paramFull) {

                // Too many arguments for this option.

                // Try to add the extra options to parameters.

                if (isset($this->_config[CONSOLE_GETARGS_PARAMS]) && $optname != CONSOLE_GETARGS_PARAMS) {

                    return $this->setValue(CONSOLE_GETARGS_PARAMS, '', ++$pos);

                } elseif ($optname == CONSOLE_GETARGS_PARAMS && empty($this->args[$i])) {

                    $pos+= $added;

                    break;

                } else {

                    return PEAR::raiseError('Argument ' . $optname . ' expects maximum ' . $max . ' values', CONSOLE_GETARGS_ERROR_USER, PEAR_ERROR_RETURN, null, 'Console_Getargs_Options::setValue()');

                }

            }

            break;

        }

        // Everything went well.

        return true;

    }

    /**

     * Checks whether the given parameter is an argument or an option

     *

     * @access private

     * @return boolean

     */

    function isValue($arg)

    {

        if ((strlen($arg) > 1 && $arg{0} == '-' && $arg{1} == '-') || (strlen($arg) > 1 && $arg{0} == '-')) {

            // The next argument is really an option.

            return false;

        }

        return true;

    }

    /**

     * Adds the argument to the option

     *

     * If the argument for the option is already set,

     * the option arguments will be changed to an array

     *

     * @access private

     * @return void

     */

    function updateValue($optname, $value)

    {

        if (isset($this->_longLong[$optname])) {

            if (is_array($this->_longLong[$optname])) {

                // Add this value to the list of values for this option.

                $this->_longLong[$optname][] = $value;

            } else {

                // There is already one value set. Turn everything into a list of values.

                $prevValue = $this->_longLong[$optname];

                $this->_longLong[$optname] = array($prevValue);

                $this->_longLong[$optname][] = $value;

            }

        } else {

            // This is the first value for this option.

            $this->_longLong[$optname] = $value;

        }

        $this->_defined[$optname] = true;

    }

    /**

     * Sets the option default arguments when necessary

     *

     * @access private

     * @return true

     */

    function setDefaults()

    {

        foreach ($this->_config as $longname => $def) {

            // Add the default value only if the default is defined

            // and the option requires at least one argument.

            if (isset($def['default']) && ((isset($def['min']) && $def['min'] !== 0) || (!isset($def['min']) & isset($def['max']) && $def['max'] !== 0)) && !isset($this->_longLong[$longname])) {

                $this->_longLong[$longname] = $def['default'];

                $this->_defined[$longname] = false;

            }