File indexing completed on 2024-05-12 06:02:21

 <?php
 /**
  * Zend_Console_Getopt is a class to parse options for command-line
  * applications.
  *
  * LICENSE
  *
  * This source file is subject to the new BSD license that is bundled
  * with this package in the file LICENSE.txt.
  * It is also available through the world-wide-web at this URL:
  * http://framework.zend.com/license/new-bsd
  * If you did not receive a copy of the license and are unable to
  * obtain it through the world-wide-web, please send an email
  * to license@zend.com so we can send you a copy immediately.
  *
  * @category   Zend
  * @package    Zend_Console_Getopt
  * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  * @version    $Id$
  */
 
 /**
  * Zend_Console_Getopt is a class to parse options for command-line
  * applications.
  *
  * Terminology:
  * Argument: an element of the argv array.  This may be part of an option,
  *   or it may be a non-option command-line argument.
  * Flag: the letter or word set off by a '-' or '--'.  Example: in '--output filename',
  *   '--output' is the flag.
  * Parameter: the additional argument that is associated with the option.
  *   Example: in '--output filename', the 'filename' is the parameter.
  * Option: the combination of a flag and its parameter, if any.
  *   Example: in '--output filename', the whole thing is the option.
  *
  * The following features are supported:
  *
  * - Short flags like '-a'.  Short flags are preceded by a single
  *   dash.  Short flags may be clustered e.g. '-abc', which is the
  *   same as '-a' '-b' '-c'.
  * - Long flags like '--verbose'.  Long flags are preceded by a
  *   double dash.  Long flags may not be clustered.
  * - Options may have a parameter, e.g. '--output filename'.
  * - Parameters for long flags may also be set off with an equals sign,
  *   e.g. '--output=filename'.
  * - Parameters for long flags may be checked as string, word, or integer.
  * - Automatic generation of a helpful usage message.
  * - Signal end of options with '--'; subsequent arguments are treated
  *   as non-option arguments, even if they begin with '-'.
  * - Raise exception Zend_Console_Getopt_Exception in several cases
  *   when invalid flags or parameters are given.  Usage message is
  *   returned in the exception object.
  *
  * The format for specifying options uses a PHP associative array.
  * The key is has the format of a list of pipe-separated flag names,
  * followed by an optional '=' to indicate a required parameter or
  * '-' to indicate an optional parameter.  Following that, the type
  * of parameter may be specified as 's' for string, 'w' for word,
  * or 'i' for integer.
  *
  * Examples:
  * - 'user|username|u=s'  this means '--user' or '--username' or '-u'
  *   are synonyms, and the option requires a string parameter.
  * - 'p=i'  this means '-p' requires an integer parameter.  No synonyms.
  * - 'verbose|v-i'  this means '--verbose' or '-v' are synonyms, and
  *   they take an optional integer parameter.
  * - 'help|h'  this means '--help' or '-h' are synonyms, and
  *   they take no parameter.
  *
  * The values in the associative array are strings that are used as
  * brief descriptions of the options when printing a usage message.
  *
  * The simpler format for specifying options used by PHP's getopt()
  * function is also supported.  This is similar to GNU getopt and shell
  * getopt format.
  *
  * Example:  'abc:' means options '-a', '-b', and '-c'
  * are legal, and the latter requires a string parameter.
  *
  * @category   Zend
  * @package    Zend_Console_Getopt
  * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  * @version    Release: @package_version@
  * @since      Class available since Release 0.6.0
  *
  * @todo  Handle params with multiple values, e.g. --colors=red,green,blue
  *        Set value of parameter to the array of values.  Allow user to specify
  *        the separator with Zend_Console_Getopt::CONFIG_PARAMETER_SEPARATOR.
  *        If this config value is null or empty string, do not split values
  *        into arrays.  Default separator is comma (',').
  *
  * @todo  Handle params with multiple values specified with separate options
  *        e.g. --colors red --colors green --colors blue should give one
  *        option with an array(red, green, blue).
  *        Enable with Zend_Console_Getopt::CONFIG_CUMULATIVE_PARAMETERS.
  *        Default is that subsequent options overwrite the parameter value.
  *
  * @todo  Handle flags occurring multiple times, e.g. -v -v -v
  *        Set value of the option's parameter to the integer count of instances
  *        instead of a boolean.
  *        Enable with Zend_Console_Getopt::CONFIG_CUMULATIVE_FLAGS.
  *        Default is that the value is simply boolean true regardless of
  *        how many instances of the flag appear.
  *
  * @todo  Handle flags that implicitly print usage message, e.g. --help
  *
  * @todo  Handle freeform options, e.g. --set-variable
  *        Enable with Zend_Console_Getopt::CONFIG_FREEFORM_FLAGS
  *        All flag-like syntax is recognized, no flag generates an exception.
  *
  * @todo  Handle numeric options, e.g. -1, -2, -3, -1000
  *        Enable with Zend_Console_Getopt::CONFIG_NUMERIC_FLAGS
  *        The rule must specify a named flag and the '#' symbol as the
  *        parameter type. e.g.,  'lines=#'
  *
  * @todo  Enable user to specify header and footer content in the help message.
  *
  * @todo  Feature request to handle option interdependencies.
  *        e.g. if -b is specified, -a must be specified or else the
  *        usage is invalid.
  *
  * @todo  Feature request to implement callbacks.
  *        e.g. if -a is specified, run function 'handleOptionA'().
  */
 class Zend_Console_Getopt
 {
 
     /**
      * The options for a given application can be in multiple formats.
      * modeGnu is for traditional 'ab:c:' style getopt format.
      * modeZend is for a more structured format.
      */
     const MODE_ZEND                         = 'zend';
     const MODE_GNU                          = 'gnu';
 
     /**
      * Constant tokens for various symbols used in the mode_zend
      * rule format.
      */
     const PARAM_REQUIRED                    = '=';
     const PARAM_OPTIONAL                    = '-';
     const TYPE_STRING                       = 's';
     const TYPE_WORD                         = 'w';
     const TYPE_INTEGER                      = 'i';
 
     /**
      * These are constants for optional behavior of this class.
      * ruleMode is either 'zend' or 'gnu' or a user-defined mode.
      * dashDash is true if '--' signifies the end of command-line options.
      * ignoreCase is true if '--opt' and '--OPT' are implicitly synonyms.
      * parseAll is true if all options on the command line should be parsed, regardless of
      * whether an argument appears before them.
      */
     const CONFIG_RULEMODE                   = 'ruleMode';
     const CONFIG_DASHDASH                   = 'dashDash';
     const CONFIG_IGNORECASE                 = 'ignoreCase';
     const CONFIG_PARSEALL                   = 'parseAll';
 
     /**
      * Defaults for getopt configuration are:
      * ruleMode is 'zend' format,
      * dashDash (--) token is enabled,
      * ignoreCase is not enabled,
      * parseAll is enabled.
      */
     protected $_getoptConfig = array(
         self::CONFIG_RULEMODE   => self::MODE_ZEND,
         self::CONFIG_DASHDASH   => true,
         self::CONFIG_IGNORECASE => false,
         self::CONFIG_PARSEALL   => true,
     );
 
     /**
      * Stores the command-line arguments for the calling application.
      *
      * @var array
      */
     protected $_argv = array();
 
     /**
      * Stores the name of the calling application.
      *
      * @var string
      */
     protected $_progname = '';
 
     /**
      * Stores the list of legal options for this application.
      *
      * @var array
      */
     protected $_rules = array();
 
     /**
      * Stores alternate spellings of legal options.
      *
      * @var array
      */
     protected $_ruleMap = array();
 
     /**
      * Stores options given by the user in the current invocation
      * of the application, as well as parameters given in options.
      *
      * @var array
      */
     protected $_options = array();
 
     /**
      * Stores the command-line arguments other than options.
      *
      * @var array
      */
     protected $_remainingArgs = array();
 
     /**
      * State of the options: parsed or not yet parsed?
      *
      * @var boolean
      */
     protected $_parsed = false;
 
     /**
      * The constructor takes one to three parameters.
      *
      * The first parameter is $rules, which may be a string for
      * gnu-style format, or a structured array for Zend-style format.
      *
      * The second parameter is $argv, and it is optional.  If not
      * specified, $argv is inferred from the global argv.
      *
      * The third parameter is an array of configuration parameters
      * to control the behavior of this instance of Getopt; it is optional.
      *
      * @param  array $rules
      * @param  array $argv
      * @param  array $getoptConfig
      * @return void
      */
     public function __construct($rules, $argv = null, $getoptConfig = array())
     {
         if (!isset($_SERVER['argv'])) {
             // require_once 'Zend/Console/Getopt/Exception.php';
             if (ini_get('register_argc_argv') == false) {
                 throw new Zend_Console_Getopt_Exception(
                     "argv is not available, because ini option 'register_argc_argv' is set Off"
                 );
             } else {
                 throw new Zend_Console_Getopt_Exception(
                     '$_SERVER["argv"] is not set, but Zend_Console_Getopt cannot work without this information.'
                 );
             }
         }
 
         $this->_progname = $_SERVER['argv'][0];
         $this->setOptions($getoptConfig);
         $this->addRules($rules);
         if (!is_array($argv)) {
             $argv = array_slice($_SERVER['argv'], 1);
         }
         if (isset($argv)) {
             $this->addArguments((array)$argv);
         }
     }
 
     /**
      * Return the state of the option seen on the command line of the
      * current application invocation.  This function returns true, or the
      * parameter to the option, if any.  If the option was not given,
      * this function returns null.
      *
      * The magic __get method works in the context of naming the option
      * as a virtual member of this class.
      *
      * @param  string $key
      * @return string
      */
     public function __get($key)
     {
         return $this->getOption($key);
     }
 
     /**
      * Test whether a given option has been seen.
      *
      * @param  string $key
      * @return boolean
      */
     public function __isset($key)
     {
         $this->parse();
         if (isset($this->_ruleMap[$key])) {
             $key = $this->_ruleMap[$key];
             return isset($this->_options[$key]);
         }
         return false;
     }
 
     /**
      * Set the value for a given option.
      *
      * @param  string $key
      * @param  string $value
      * @return void
      */
     public function __set($key, $value)
     {
         $this->parse();
         if (isset($this->_ruleMap[$key])) {
             $key = $this->_ruleMap[$key];
             $this->_options[$key] = $value;
         }
     }
 
     /**
      * Return the current set of options and parameters seen as a string.
      *
      * @return string
      */
     public function __toString()
     {
         return $this->toString();
     }
 
     /**
      * Unset an option.
      *
      * @param  string $key
      * @return void
      */
     public function __unset($key)
     {
         $this->parse();
         if (isset($this->_ruleMap[$key])) {
             $key = $this->_ruleMap[$key];
             unset($this->_options[$key]);
         }
     }
 
     /**
      * Define additional command-line arguments.
      * These are appended to those defined when the constructor was called.
      *
      * @param  array $argv
      * @throws Zend_Console_Getopt_Exception When not given an array as parameter
      * @return Zend_Console_Getopt Provides a fluent interface
      */
     public function addArguments($argv)
     {
         if(!is_array($argv)) {
             // require_once 'Zend/Console/Getopt/Exception.php';
             throw new Zend_Console_Getopt_Exception(
                 "Parameter #1 to addArguments should be an array");
         }
         $this->_argv = array_merge($this->_argv, $argv);
         $this->_parsed = false;
         return $this;
     }
 
     /**
      * Define full set of command-line arguments.
      * These replace any currently defined.
      *
      * @param  array $argv
      * @throws Zend_Console_Getopt_Exception When not given an array as parameter
      * @return Zend_Console_Getopt Provides a fluent interface
      */
     public function setArguments($argv)
     {
         if(!is_array($argv)) {
             // require_once 'Zend/Console/Getopt/Exception.php';
             throw new Zend_Console_Getopt_Exception(
                 "Parameter #1 to setArguments should be an array");
         }
         $this->_argv = $argv;
         $this->_parsed = false;
         return $this;
     }
 
     /**
      * Define multiple configuration options from an associative array.
      * These are not program options, but properties to configure
      * the behavior of Zend_Console_Getopt.
      *
      * @param  array $getoptConfig
      * @return Zend_Console_Getopt Provides a fluent interface
      */
     public function setOptions($getoptConfig)
     {
         if (isset($getoptConfig)) {
             foreach ($getoptConfig as $key => $value) {
                 $this->setOption($key, $value);
             }
         }
         return $this;
     }
 
     /**
      * Define one configuration option as a key/value pair.
      * These are not program options, but properties to configure
      * the behavior of Zend_Console_Getopt.
      *
      * @param  string $configKey
      * @param  string $configValue
      * @return Zend_Console_Getopt Provides a fluent interface
      */
     public function setOption($configKey, $configValue)
     {
         if ($configKey !== null) {
             $this->_getoptConfig[$configKey] = $configValue;
         }
         return $this;
     }
 
     /**
      * Define additional option rules.
      * These are appended to the rules defined when the constructor was called.
      *
      * @param  array $rules
      * @return Zend_Console_Getopt Provides a fluent interface
      */
     public function addRules($rules)
     {
         $ruleMode = $this->_getoptConfig['ruleMode'];
         switch ($this->_getoptConfig['ruleMode']) {
             case self::MODE_ZEND:
                 if (is_array($rules)) {
                     $this->_addRulesModeZend($rules);
                     break;
                 }
                 // intentional fallthrough
             case self::MODE_GNU:
                 $this->_addRulesModeGnu($rules);
                 break;
             default:
                 /**
                  * Call addRulesModeFoo() for ruleMode 'foo'.
                  * The developer should subclass Getopt and
                  * provide this method.
                  */
                 $method = '_addRulesMode' . ucfirst($ruleMode);
                 $this->$method($rules);
         }
         $this->_parsed = false;
         return $this;
     }
 
     /**
      * Return the current set of options and parameters seen as a string.
      *
      * @return string
      */
     public function toString()
     {
         $this->parse();
         $s = array();
         foreach ($this->_options as $flag => $value) {
             $s[] = $flag . '=' . ($value === true ? 'true' : $value);
         }
         return implode(' ', $s);
     }
 
     /**
      * Return the current set of options and parameters seen
      * as an array of canonical options and parameters.
      *
      * Clusters have been expanded, and option aliases
      * have been mapped to their primary option names.
      *
      * @return array
      */
     public function toArray()
     {
         $this->parse();
         $s = array();
         foreach ($this->_options as $flag => $value) {
             $s[] = $flag;
             if ($value !== true) {
                 $s[] = $value;
             }
         }
         return $s;
     }
 
     /**
      * Return the current set of options and parameters seen in Json format.
      *
      * @return string
      */
     public function toJson()
     {
         $this->parse();
         $j = array();
         foreach ($this->_options as $flag => $value) {
             $j['options'][] = array(
                 'option' => array(
                     'flag' => $flag,
                     'parameter' => $value
                 )
             );
         }
 
         /**
          * @see Zend_Json
          */
         // require_once 'Zend/Json.php';
         $json = Zend_Json::encode($j);
 
         return $json;
     }
 
     /**
      * Return the current set of options and parameters seen in XML format.
      *
      * @return string
      */
     public function toXml()
     {
         $this->parse();
         $doc = new DomDocument('1.0', 'utf-8');
         $optionsNode = $doc->createElement('options');
         $doc->appendChild($optionsNode);
         foreach ($this->_options as $flag => $value) {
             $optionNode = $doc->createElement('option');
             $optionNode->setAttribute('flag', utf8_encode($flag));
             if ($value !== true) {
                 $optionNode->setAttribute('parameter', utf8_encode($value));
             }
             $optionsNode->appendChild($optionNode);
         }
         $xml = $doc->saveXML();
         return $xml;
     }
 
     /**
      * Return a list of options that have been seen in the current argv.
      *
      * @return array
      */
     public function getOptions()
     {
         $this->parse();
         return array_keys($this->_options);
     }
 
     /**
      * Return the state of the option seen on the command line of the
      * current application invocation.
      *
      * This function returns true, or the parameter value to the option, if any.
      * If the option was not given, this function returns null.
      *
      * @param  string $flag
      * @return mixed
      */
     public function getOption($flag)
     {
         $this->parse();
         if ($this->_getoptConfig[self::CONFIG_IGNORECASE]) {
             $flag = strtolower($flag);
         }
         if (isset($this->_ruleMap[$flag])) {
             $flag = $this->_ruleMap[$flag];
             if (isset($this->_options[$flag])) {
                 return $this->_options[$flag];
             }
         }
         return null;
     }
 
     /**
      * Return the arguments from the command-line following all options found.
      *
      * @return array
      */
     public function getRemainingArgs()
     {
         $this->parse();
         return $this->_remainingArgs;
     }
 
     /**
      * Return a useful option reference, formatted for display in an
      * error message.
      *
      * Note that this usage information is provided in most Exceptions
      * generated by this class.
      *
      * @return string
      */
     public function getUsageMessage()
     {
         $usage = "Usage: {$this->_progname} [ options ]\n";
         $maxLen = 20;
         $lines = array();
         foreach ($this->_rules as $rule) {
             $flags = array();
             if (is_array($rule['alias'])) {
                 foreach ($rule['alias'] as $flag) {
                     $flags[] = (strlen($flag) == 1 ? '-' : '--') . $flag;
                 }
             }
             $linepart['name'] = implode('|', $flags);
             if (isset($rule['param']) && $rule['param'] != 'none') {
                 $linepart['name'] .= ' ';
                 switch ($rule['param']) {
                     case 'optional':
                         $linepart['name'] .= "[ <{$rule['paramType']}> ]";
                         break;
                     case 'required':
                         $linepart['name'] .= "<{$rule['paramType']}>";
                         break;
                 }
             }
             if (strlen($linepart['name']) > $maxLen) {
                 $maxLen = strlen($linepart['name']);
             }
             $linepart['help'] = '';
             if (isset($rule['help'])) {
                 $linepart['help'] .= $rule['help'];
             }
             $lines[] = $linepart;
         }
         foreach ($lines as $linepart) {
             $usage .= sprintf("%s %s\n",
             str_pad($linepart['name'], $maxLen),
             $linepart['help']);
         }
         return $usage;
     }
 
     /**
      * Define aliases for options.
      *
      * The parameter $aliasMap is an associative array
      * mapping option name (short or long) to an alias.
      *
      * @param  array $aliasMap
      * @throws Zend_Console_Getopt_Exception
      * @return Zend_Console_Getopt Provides a fluent interface
      */
     public function setAliases($aliasMap)
     {
         foreach ($aliasMap as $flag => $alias)
         {
             if ($this->_getoptConfig[self::CONFIG_IGNORECASE]) {
                 $flag = strtolower($flag);
                 $alias = strtolower($alias);
             }
             if (!isset($this->_ruleMap[$flag])) {
                 continue;
             }
             $flag = $this->_ruleMap[$flag];
             if (isset($this->_rules[$alias]) || isset($this->_ruleMap[$alias])) {
                 $o = (strlen($alias) == 1 ? '-' : '--') . $alias;
                 // require_once 'Zend/Console/Getopt/Exception.php';
                 throw new Zend_Console_Getopt_Exception(
                     "Option \"$o\" is being defined more than once.");
             }
             $this->_rules[$flag]['alias'][] = $alias;
             $this->_ruleMap[$alias] = $flag;
         }
         return $this;
     }
 
     /**
      * Define help messages for options.
      *
      * The parameter $help_map is an associative array
      * mapping option name (short or long) to the help string.
      *
      * @param  array $helpMap
      * @return Zend_Console_Getopt Provides a fluent interface
      */
     public function setHelp($helpMap)
     {
         foreach ($helpMap as $flag => $help)
         {
             if (!isset($this->_ruleMap[$flag])) {
                 continue;
             }
             $flag = $this->_ruleMap[$flag];
             $this->_rules[$flag]['help'] = $help;
         }
         return $this;
     }
 
     /**
      * Parse command-line arguments and find both long and short
      * options.
      *
      * Also find option parameters, and remaining arguments after
      * all options have been parsed.
      *
      * @return Zend_Console_Getopt|null Provides a fluent interface
      */
     public function parse()
     {
         if ($this->_parsed === true) {
             return;
         }
         $argv = $this->_argv;
         $this->_options = array();
         $this->_remainingArgs = array();
         while (count($argv) > 0) {
             if ($argv[0] == '--') {
                 array_shift($argv);
                 if ($this->_getoptConfig[self::CONFIG_DASHDASH]) {
                     $this->_remainingArgs = array_merge($this->_remainingArgs, $argv);
                     break;
                 }
             }
             if (substr($argv[0], 0, 2) == '--') {
                 $this->_parseLongOption($argv);
             } else if (substr($argv[0], 0, 1) == '-' && ('-' != $argv[0] || count($argv) >1))  {
                 $this->_parseShortOptionCluster($argv);
             } else if($this->_getoptConfig[self::CONFIG_PARSEALL]) {
                 $this->_remainingArgs[] = array_shift($argv);
             } else {
                 /*
                  * We should put all other arguments in _remainingArgs and stop parsing
                  * since CONFIG_PARSEALL is false.
                  */
                 $this->_remainingArgs = array_merge($this->_remainingArgs, $argv);
                 break;
             }
         }
         $this->_parsed = true;
         return $this;
     }
 
     /**
      * @throws Zend_Console_Getopt_Exception
      */
     public function checkRequiredArguments()
     {
         foreach ($this->_rules as $name => $rule) {
             if ($rule['param'] === 'required') {
                 $defined = false;
                 foreach ($rule['alias'] as $alias) {
                     $defined = $defined === true ? true : array_key_exists($alias, $this->_options);
                 }
                 if ($defined === false) {
                     // require_once 'Zend/Console/Getopt/Exception.php';
                     throw new Zend_Console_Getopt_Exception(
                         'Option "$alias" requires a parameter.',
                         $this->getUsageMessage()
                     );
                 }
             }
         }
     }
 
     /**
      * Parse command-line arguments for a single long option.
      * A long option is preceded by a double '--' character.
      * Long options may not be clustered.
      *
      * @param  mixed &$argv
      * @return void
      */
     protected function _parseLongOption(&$argv)
     {
         $optionWithParam = ltrim(array_shift($argv), '-');
         $l = explode('=', $optionWithParam, 2);
         $flag = array_shift($l);
         $param = array_shift($l);
         if (isset($param)) {
             array_unshift($argv, $param);
         }
         $this->_parseSingleOption($flag, $argv);
     }
 
     /**
      * Parse command-line arguments for short options.
      * Short options are those preceded by a single '-' character.
      * Short options may be clustered.
      *
      * @param  mixed &$argv
      * @return void
      */
     protected function _parseShortOptionCluster(&$argv)
     {
         $flagCluster = ltrim(array_shift($argv), '-');
         foreach (str_split($flagCluster) as $flag) {
             $this->_parseSingleOption($flag, $argv);
         }
     }
 
     /**
      * Parse command-line arguments for a single option.
      *
      * @param  string $flag
      * @param  mixed  $argv
      * @throws Zend_Console_Getopt_Exception
      * @return void
      */
     protected function _parseSingleOption($flag, &$argv)
     {
         if ($this->_getoptConfig[self::CONFIG_IGNORECASE]) {
             $flag = strtolower($flag);
         }
         if (!isset($this->_ruleMap[$flag])) {
             // require_once 'Zend/Console/Getopt/Exception.php';
             throw new Zend_Console_Getopt_Exception(
                 "Option \"$flag\" is not recognized.",
                 $this->getUsageMessage());
         }
         $realFlag = $this->_ruleMap[$flag];
         switch ($this->_rules[$realFlag]['param']) {
             case 'required':
                 if (count($argv) > 0 && substr($argv[0], 0, 1) != '-') {
                     $param = array_shift($argv);
                     $this->_checkParameterType($realFlag, $param);
                 } else {
                     // require_once 'Zend/Console/Getopt/Exception.php';
                     throw new Zend_Console_Getopt_Exception(
                         "Option \"$flag\" requires a parameter.",
                         $this->getUsageMessage());
                 }
                 break;
             case 'optional':
                 if (count($argv) > 0 && substr($argv[0], 0, 1) != '-') {
                     $param = array_shift($argv);
                     $this->_checkParameterType($realFlag, $param);
                 } else {
                     $param = true;
                 }
                 break;
             default:
                 $param = true;
         }
         $this->_options[$realFlag] = $param;
     }
 
     /**
      * Return true if the parameter is in a valid format for
      * the option $flag.
      * Throw an exception in most other cases.
      *
      * @param  string $flag
      * @param  string $param
      * @throws Zend_Console_Getopt_Exception
      * @return bool
      */
     protected function _checkParameterType($flag, $param)
     {
         $type = 'string';
         if (isset($this->_rules[$flag]['paramType'])) {
             $type = $this->_rules[$flag]['paramType'];
         }
         switch ($type) {
             case 'word':
                 if (preg_match('/\W/', $param)) {
                     // require_once 'Zend/Console/Getopt/Exception.php';
                     throw new Zend_Console_Getopt_Exception(
                         "Option \"$flag\" requires a single-word parameter, but was given \"$param\".",
                         $this->getUsageMessage());
                 }
                 break;
             case 'integer':
                 if (preg_match('/\D/', $param)) {
                     // require_once 'Zend/Console/Getopt/Exception.php';
                     throw new Zend_Console_Getopt_Exception(
                         "Option \"$flag\" requires an integer parameter, but was given \"$param\".",
                         $this->getUsageMessage());
                 }
                 break;
             case 'string':
             default:
                 break;
         }
         return true;
     }
 
     /**
      * Define legal options using the gnu-style format.
      *
      * @param  string $rules
      * @return void
      */
     protected function _addRulesModeGnu($rules)
     {
         $ruleArray = array();
 
         /**
          * Options may be single alphanumeric characters.
          * Options may have a ':' which indicates a required string parameter.
          * No long options or option aliases are supported in GNU style.
          */
         preg_match_all('/([a-zA-Z0-9]:?)/', $rules, $ruleArray);
         foreach ($ruleArray[1] as $rule) {
             $r = array();
             $flag = substr($rule, 0, 1);
             if ($this->_getoptConfig[self::CONFIG_IGNORECASE]) {
                 $flag = strtolower($flag);
             }
             $r['alias'][] = $flag;
             if (substr($rule, 1, 1) == ':') {
                 $r['param'] = 'required';
                 $r['paramType'] = 'string';
             } else {
                 $r['param'] = 'none';
             }
             $this->_rules[$flag] = $r;
             $this->_ruleMap[$flag] = $flag;
         }
     }
 
     /**
      * Define legal options using the Zend-style format.
      *
      * @param  array $rules
      * @throws Zend_Console_Getopt_Exception
      * @return void
      */
     protected function _addRulesModeZend($rules)
     {
         foreach ($rules as $ruleCode => $helpMessage)
         {
             // this may have to translate the long parm type if there
             // are any complaints that =string will not work (even though that use
             // case is not documented)
             if (in_array(substr($ruleCode, -2, 1), array('-', '='))) {
                 $flagList  = substr($ruleCode, 0, -2);
                 $delimiter = substr($ruleCode, -2, 1);
                 $paramType = substr($ruleCode, -1);
             } else {
                 $flagList = $ruleCode;
                 $delimiter = $paramType = null;
             }
             if ($this->_getoptConfig[self::CONFIG_IGNORECASE]) {
                 $flagList = strtolower($flagList);
             }
             $flags = explode('|', $flagList);
             $rule = array();
             $mainFlag = $flags[0];
             foreach ($flags as $flag) {
                 if (empty($flag)) {
                     // require_once 'Zend/Console/Getopt/Exception.php';
                     throw new Zend_Console_Getopt_Exception(
                         "Blank flag not allowed in rule \"$ruleCode\".");
                 }
                 if (strlen($flag) == 1) {
                     if (isset($this->_ruleMap[$flag])) {
                         // require_once 'Zend/Console/Getopt/Exception.php';
                         throw new Zend_Console_Getopt_Exception(
                             "Option \"-$flag\" is being defined more than once.");
                     }
                     $this->_ruleMap[$flag] = $mainFlag;
                     $rule['alias'][] = $flag;
                 } else {
                     if (isset($this->_rules[$flag]) || isset($this->_ruleMap[$flag])) {
                         // require_once 'Zend/Console/Getopt/Exception.php';
                         throw new Zend_Console_Getopt_Exception(
                             "Option \"--$flag\" is being defined more than once.");
                     }
                     $this->_ruleMap[$flag] = $mainFlag;
                     $rule['alias'][] = $flag;
                 }
             }
             if (isset($delimiter)) {
                 switch ($delimiter) {
                     case self::PARAM_REQUIRED:
                         $rule['param'] = 'required';
                         break;
                     case self::PARAM_OPTIONAL:
                     default:
                         $rule['param'] = 'optional';
                 }
                 switch (substr($paramType, 0, 1)) {
                     case self::TYPE_WORD:
                         $rule['paramType'] = 'word';
                         break;
                     case self::TYPE_INTEGER:
                         $rule['paramType'] = 'integer';
                         break;
                     case self::TYPE_STRING:
                     default:
                         $rule['paramType'] = 'string';
                 }
             } else {
                 $rule['param'] = 'none';
             }
             $rule['help'] = $helpMessage;
             $this->_rules[$mainFlag] = $rule;
         }
     }
 
 }