some more includes
[owncloud:owncloud.git] / inc / Console / Getopt.php
1 <?php
2 /* vim: set expandtab tabstop=4 shiftwidth=4: */
3 // +----------------------------------------------------------------------+
4 // | PHP Version 4                                                        |
5 // +----------------------------------------------------------------------+
6 // | Copyright (c) 1997-2003 The PHP Group                                |
7 // +----------------------------------------------------------------------+
8 // | This source file is subject to version 3.0 of the PHP license,       |
9 // | that is bundled with this package in the file LICENSE, and is        |
10 // | available through the world-wide-web at the following url:           |
11 // | http://www.php.net/license/3_0.txt.                                  |
12 // | If you did not receive a copy of the PHP license and are unable to   |
13 // | obtain it through the world-wide-web, please send a note to          |
14 // | license@php.net so we can mail you a copy immediately.               |
15 // +----------------------------------------------------------------------+
16 // | Author: Andrei Zmievski <andrei@php.net>                             |
17 // +----------------------------------------------------------------------+
18 //
19 // $Id: Getopt.php,v 1.21.4.7 2003/12/05 21:57:01 andrei Exp $
20
21 oc_require_once( 'PEAR.php');
22
23 /**
24  * Command-line options parsing class.
25  *
26  * @author Andrei Zmievski <andrei@php.net>
27  *
28  */
29 class Console_Getopt {
30     /**
31      * Parses the command-line options.
32      *
33      * The first parameter to this function should be the list of command-line
34      * arguments without the leading reference to the running program.
35      *
36      * The second parameter is a string of allowed short options. Each of the
37      * option letters can be followed by a colon ':' to specify that the option
38      * requires an argument, or a double colon '::' to specify that the option
39      * takes an optional argument.
40      *
41      * The third argument is an optional array of allowed long options. The
42      * leading '--' should not be included in the option name. Options that
43      * require an argument should be followed by '=', and options that take an
44      * option argument should be followed by '=='.
45      *
46      * The return value is an array of two elements: the list of parsed
47      * options and the list of non-option command-line arguments. Each entry in
48      * the list of parsed options is a pair of elements - the first one
49      * specifies the option, and the second one specifies the option argument,
50      * if there was one.
51      *
52      * Long and short options can be mixed.
53      *
54      * Most of the semantics of this function are based on GNU getopt_long().
55      *
56      * @param array  $args           an array of command-line arguments
57      * @param string $short_options  specifies the list of allowed short options
58      * @param array  $long_options   specifies the list of allowed long options
59      *
60      * @return array two-element array containing the list of parsed options and
61      * the non-option arguments
62      *
63      * @access public
64      *
65      */
66     function getopt2($args, $short_options, $long_options = null)
67     {
68         return Console_Getopt::doGetopt(2, $args, $short_options, $long_options);
69     }
70
71     /**
72      * This function expects $args to start with the script name (POSIX-style).
73      * Preserved for backwards compatibility.
74      * @see getopt2()
75      */
76     function getopt($args, $short_options, $long_options = null)
77     {
78         return Console_Getopt::doGetopt(1, $args, $short_options, $long_options);
79     }
80
81     /**
82      * The actual implementation of the argument parsing code.
83      */
84     function doGetopt($version, $args, $short_options, $long_options = null)
85     {
86         // in case you pass directly readPHPArgv() as the first arg
87         if (PEAR::isError($args)) {
88             return $args;
89         }
90         if (empty($args)) {
91             return array(array(), array());
92         }
93         $opts     = array();
94         $non_opts = array();
95
96         settype($args, 'array');
97
98         if ($long_options) {
99             sort($long_options);
100         }
101
102         /*
103          * Preserve backwards compatibility with callers that relied on
104          * erroneous POSIX fix.
105          */
106         if ($version < 2) {
107             if (isset($args[0]{0}) && $args[0]{0} != '-') {
108                 array_shift($args);
109             }
110         }
111
112         reset($args);
113         while (list($i, $arg) = each($args)) {
114
115             /* The special element '--' means explicit end of
116                options. Treat the rest of the arguments as non-options
117                and end the loop. */
118             if ($arg == '--') {
119                 $non_opts = array_merge($non_opts, array_slice($args, $i + 1));
120                 break;
121             }
122
123             if ($arg{0} != '-' || (strlen($arg) > 1 && $arg{1} == '-' && !$long_options)) {
124                 $non_opts = array_merge($non_opts, array_slice($args, $i));
125                 break;
126             } elseif (strlen($arg) > 1 && $arg{1} == '-') {
127                 $error = Console_Getopt::_parseLongOption(substr($arg, 2), $long_options, $opts, $args);
128                 if (PEAR::isError($error))
129                     return $error;
130             } else {
131                 $error = Console_Getopt::_parseShortOption(substr($arg, 1), $short_options, $opts, $args);
132                 if (PEAR::isError($error))
133                     return $error;
134             }
135         }
136
137         return array($opts, $non_opts);
138     }
139
140     /**
141      * @access private
142      *
143      */
144     function _parseShortOption($arg, $short_options, &$opts, &$args)
145     {
146         for ($i = 0; $i < strlen($arg); $i++) {
147             $opt = $arg{$i};
148             $opt_arg = null;
149
150             /* Try to find the short option in the specifier string. */
151             if (($spec = strstr($short_options, $opt)) === false || $arg{$i} == ':')
152             {
153                 return PEAR::raiseError("Console_Getopt: unrecognized option -- $opt");
154             }
155
156             if (strlen($spec) > 1 && $spec{1} == ':') {
157                 if (strlen($spec) > 2 && $spec{2} == ':') {
158                     if ($i + 1 < strlen($arg)) {
159                         /* Option takes an optional argument. Use the remainder of
160                            the arg string if there is anything left. */
161                         $opts[] = array($opt, substr($arg, $i + 1));
162                         break;
163                     }
164                 } else {
165                     /* Option requires an argument. Use the remainder of the arg
166                        string if there is anything left. */
167                     if ($i + 1 < strlen($arg)) {
168                         $opts[] = array($opt,  substr($arg, $i + 1));
169                         break;
170                     } else if (list(, $opt_arg) = each($args))
171                         /* Else use the next argument. */;
172                     else
173                         return PEAR::raiseError("Console_Getopt: option requires an argument -- $opt");
174                 }
175             }
176
177             $opts[] = array($opt, $opt_arg);
178         }
179     }
180
181     /**
182      * @access private
183      *
184      */
185     function _parseLongOption($arg, $long_options, &$opts, &$args)
186     {
187         @list($opt, $opt_arg) = explode('=', $arg);
188         $opt_len = strlen($opt);
189
190         for ($i = 0; $i < count($long_options); $i++) {
191             $long_opt  = $long_options[$i];
192             $opt_start = substr($long_opt, 0, $opt_len);
193
194             /* Option doesn't match. Go on to the next one. */
195             if ($opt_start != $opt)
196                 continue;
197
198             $opt_rest  = substr($long_opt, $opt_len);
199
200             /* Check that the options uniquely matches one of the allowed
201                options. */
202             if ($opt_rest != '' && $opt{0} != '=' &&
203                 $i + 1 < count($long_options) &&
204                 $opt == substr($long_options[$i+1], 0, $opt_len)) {
205                 return PEAR::raiseError("Console_Getopt: option --$opt is ambiguous");
206             }
207
208             if (substr($long_opt, -1) == '=') {
209                 if (substr($long_opt, -2) != '==') {
210                     /* Long option requires an argument.
211                        Take the next argument if one wasn't specified. */;
212                     if (!strlen($opt_arg) && !(list(, $opt_arg) = each($args))) {
213                         return PEAR::raiseError("Console_Getopt: option --$opt requires an argument");
214                     }
215                 }
216             } else if ($opt_arg) {
217                 return PEAR::raiseError("Console_Getopt: option --$opt doesn't allow an argument");
218             }
219
220             $opts[] = array('--' . $opt, $opt_arg);
221             return;
222         }
223
224         return PEAR::raiseError("Console_Getopt: unrecognized option --$opt");
225     }
226
227     /**
228     * Safely read the $argv PHP array across different PHP configurations.
229     * Will take care on register_globals and register_argc_argv ini directives
230     *
231     * @access public
232     * @return mixed the $argv PHP array or PEAR error if not registered
233     */
234     function readPHPArgv()
235     {
236         global $argv;
237         if (!is_array($argv)) {
238             if (!@is_array($_SERVER['argv'])) {
239                 if (!@is_array($GLOBALS['HTTP_SERVER_VARS']['argv'])) {
240                     return PEAR::raiseError("Console_Getopt: Could not read cmd args (register_argc_argv=Off?)");
241                 }
242                 return $GLOBALS['HTTP_SERVER_VARS']['argv'];
243             }
244             return $_SERVER['argv'];
245         }
246         return $argv;
247     }
248
249 }
250
251 ?>