xpressengine / xe-core

libs/PEAR.1.9/PEAR5.php

Indentation +23 added lines, -23 removed lines

@@ -5,29 +5,29 @@
  */
 class PEAR5
 {
-    /**
-    * If you have a class that's mostly/entirely static, and you need static
-    * properties, you can use this method to simulate them. Eg. in your method(s)
-    * do this: $myVar = &PEAR5::getStaticProperty('myclass', 'myVar');
-    * You MUST use a reference, or they will not persist!
-    *
-    * @access public
-    * @param  string $class  The calling classname, to prevent clashes
-    * @param  string $var    The variable to retrieve.
-    * @return mixed   A reference to the variable. If not set it will be
-    *                 auto initialised to NULL.
-    */
-    static function &getStaticProperty($class, $var)
-    {
-        static $properties;
-        if (!isset($properties[$class])) {
-            $properties[$class] = array();
-        }
+	/**
+	 * If you have a class that's mostly/entirely static, and you need static
+	 * properties, you can use this method to simulate them. Eg. in your method(s)
+	 * do this: $myVar = &PEAR5::getStaticProperty('myclass', 'myVar');
+	 * You MUST use a reference, or they will not persist!
+	 *
+	 * @access public
+	 * @param  string $class  The calling classname, to prevent clashes
+	 * @param  string $var    The variable to retrieve.
+	 * @return mixed   A reference to the variable. If not set it will be
+	 *                 auto initialised to NULL.
+	 */
+	static function &getStaticProperty($class, $var)
+	{
+		static $properties;
+		if (!isset($properties[$class])) {
+			$properties[$class] = array();
+		}
 
-        if (!array_key_exists($var, $properties[$class])) {
-            $properties[$class][$var] = null;
-        }
+		if (!array_key_exists($var, $properties[$class])) {
+			$properties[$class][$var] = null;
+		}
 
-        return $properties[$class][$var];
-    }
+		return $properties[$class][$var];
+	}
 }
\ No newline at end of file

libs/PEAR/Net/Socket.php

Indentation +490 added lines, -490 removed lines

@@ -34,495 +34,495 @@
  */
 class Net_Socket extends PEAR {
 
-    /**
-     * Socket file pointer.
-     * @var resource $fp
-     */
-    var $fp = null;
-
-    /**
-     * Whether the socket is blocking. Defaults to true.
-     * @var boolean $blocking
-     */
-    var $blocking = true;
-
-    /**
-     * Whether the socket is persistent. Defaults to false.
-     * @var boolean $persistent
-     */
-    var $persistent = false;
-
-    /**
-     * The IP address to connect to.
-     * @var string $addr
-     */
-    var $addr = '';
-
-    /**
-     * The port number to connect to.
-     * @var integer $port
-     */
-    var $port = 0;
-
-    /**
-     * Number of seconds to wait on socket connections before assuming
-     * there's no more data. Defaults to no timeout.
-     * @var integer $timeout
-     */
-    var $timeout = false;
-
-    /**
-     * Number of bytes to read at a time in readLine() and
-     * readAll(). Defaults to 2048.
-     * @var integer $lineLength
-     */
-    var $lineLength = 2048;
-
-    /**
-     * Connect to the specified port. If called when the socket is
-     * already connected, it disconnects and connects again.
-     *
-     * @param string  $addr        IP address or host name.
-     * @param integer $port        TCP port number.
-     * @param boolean $persistent  (optional) Whether the connection is
-     *                             persistent (kept open between requests
-     *                             by the web server).
-     * @param integer $timeout     (optional) How long to wait for data.
-     * @param array   $options     See options for stream_context_create.
-     *
-     * @access public
-     *
-     * @return boolean | PEAR_Error  True on success or a PEAR_Error on failure.
-     */
-    function connect($addr, $port = 0, $persistent = null, $timeout = null, $options = null)
-    {
-        if (is_resource($this->fp)) {
-            @fclose($this->fp);
-            $this->fp = null;
-        }
-
-        if (!$addr) {
-            return $this->raiseError('$addr cannot be empty');
-        } elseif (strspn($addr, '.0123456789') == strlen($addr) ||
-                  strstr($addr, '/') !== false) {
-            $this->addr = $addr;
-        } else {
-            $this->addr = @gethostbyname($addr);
-        }
-
-        $this->port = $port % 65536;
-
-        if ($persistent !== null) {
-            $this->persistent = $persistent;
-        }
-
-        if ($timeout !== null) {
-            $this->timeout = $timeout;
-        }
-
-        $openfunc = $this->persistent ? 'pfsockopen' : 'fsockopen';
-        $errno = 0;
-        $errstr = '';
-        if ($options && function_exists('stream_context_create')) {
-            if ($this->timeout) {
-                $timeout = $this->timeout;
-            } else {
-                $timeout = 0;
-            }
-            $context = stream_context_create($options);
-            $fp = @$openfunc($this->addr, $this->port, $errno, $errstr, $timeout, $context);
-        } else {
-            if ($this->timeout) {
-                $fp = @$openfunc($this->addr, $this->port, $errno, $errstr, $this->timeout);
-            } else {
-                $fp = @$openfunc($this->addr, $this->port, $errno, $errstr);
-            }
-        }
-
-        if (!$fp) {
-            return $this->raiseError($errstr, $errno);
-        }
-
-        $this->fp = $fp;
-
-        return $this->setBlocking($this->blocking);
-    }
-
-    /**
-     * Disconnects from the peer, closes the socket.
-     *
-     * @access public
-     * @return mixed true on success or an error object otherwise
-     */
-    function disconnect()
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        @fclose($this->fp);
-        $this->fp = null;
-        return true;
-    }
-
-    /**
-     * Find out if the socket is in blocking mode.
-     *
-     * @access public
-     * @return boolean  The current blocking mode.
-     */
-    function isBlocking()
-    {
-        return $this->blocking;
-    }
-
-    /**
-     * Sets whether the socket connection should be blocking or
-     * not. A read call to a non-blocking socket will return immediately
-     * if there is no data available, whereas it will block until there
-     * is data for blocking sockets.
-     *
-     * @param boolean $mode  True for blocking sockets, false for nonblocking.
-     * @access public
-     * @return mixed true on success or an error object otherwise
-     */
-    function setBlocking($mode)
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        $this->blocking = $mode;
-        socket_set_blocking($this->fp, $this->blocking);
-        return true;
-    }
-
-    /**
-     * Sets the timeout value on socket descriptor,
-     * expressed in the sum of seconds and microseconds
-     *
-     * @param integer $seconds  Seconds.
-     * @param integer $microseconds  Microseconds.
-     * @access public
-     * @return mixed true on success or an error object otherwise
-     */
-    function setTimeout($seconds, $microseconds)
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        return socket_set_timeout($this->fp, $seconds, $microseconds);
-    }
-
-    /**
-     * Returns information about an existing socket resource.
-     * Currently returns four entries in the result array:
-     *
-     * <p>
-     * timed_out (bool) - The socket timed out waiting for data<br>
-     * blocked (bool) - The socket was blocked<br>
-     * eof (bool) - Indicates EOF event<br>
-     * unread_bytes (int) - Number of bytes left in the socket buffer<br>
-     * </p>
-     *
-     * @access public
-     * @return mixed Array containing information about existing socket resource or an error object otherwise
-     */
-    function getStatus()
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        return socket_get_status($this->fp);
-    }
-
-    /**
-     * Get a specified line of data
-     *
-     * @access public
-     * @return $size bytes of data from the socket, or a PEAR_Error if
-     *         not connected.
-     */
-    function gets($size)
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        return @fgets($this->fp, $size);
-    }
-
-    /**
-     * Read a specified amount of data. This is guaranteed to return,
-     * and has the added benefit of getting everything in one fread()
-     * chunk; if you know the size of the data you're getting
-     * beforehand, this is definitely the way to go.
-     *
-     * @param integer $size  The number of bytes to read from the socket.
-     * @access public
-     * @return $size bytes of data from the socket, or a PEAR_Error if
-     *         not connected.
-     */
-    function read($size)
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        return @fread($this->fp, $size);
-    }
-
-    /**
-     * Write a specified amount of data.
-     *
-     * @param string  $data       Data to write.
-     * @param integer $blocksize  Amount of data to write at once.
-     *                            NULL means all at once.
-     *
-     * @access public
-     * @return mixed true on success or an error object otherwise
-     */
-    function write($data, $blocksize = null)
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        if (is_null($blocksize) && !OS_WINDOWS) {
-            return fwrite($this->fp, $data);
-        } else {
-            if (is_null($blocksize)) {
-                $blocksize = 1024;
-            }
-
-            $pos = 0;
-            $size = strlen($data);
-            while ($pos < $size) {
-                $written = @fwrite($this->fp, substr($data, $pos, $blocksize));
-                if ($written === false) {
-                    return false;
-                }
-                $pos += $written;
-            }
-
-            return $pos;
-        }
-    }
-
-    /**
-     * Write a line of data to the socket, followed by a trailing "\r\n".
-     *
-     * @access public
-     * @return mixed fputs result, or an error
-     */
-    function writeLine($data)
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        return fwrite($this->fp, $data . "\r\n");
-    }
-
-    /**
-     * Tests for end-of-file on a socket descriptor.
-     *
-     * @access public
-     * @return bool
-     */
-    function eof()
-    {
-        return (is_resource($this->fp) && feof($this->fp));
-    }
-
-    /**
-     * Reads a byte of data
-     *
-     * @access public
-     * @return 1 byte of data from the socket, or a PEAR_Error if
-     *         not connected.
-     */
-    function readByte()
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        return ord(@fread($this->fp, 1));
-    }
-
-    /**
-     * Reads a word of data
-     *
-     * @access public
-     * @return 1 word of data from the socket, or a PEAR_Error if
-     *         not connected.
-     */
-    function readWord()
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        $buf = @fread($this->fp, 2);
-        return (ord($buf[0]) + (ord($buf[1]) << 8));
-    }
-
-    /**
-     * Reads an int of data
-     *
-     * @access public
-     * @return integer  1 int of data from the socket, or a PEAR_Error if
-     *                  not connected.
-     */
-    function readInt()
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        $buf = @fread($this->fp, 4);
-        return (ord($buf[0]) + (ord($buf[1]) << 8) +
-                (ord($buf[2]) << 16) + (ord($buf[3]) << 24));
-    }
-
-    /**
-     * Reads a zero-terminated string of data
-     *
-     * @access public
-     * @return string, or a PEAR_Error if
-     *         not connected.
-     */
-    function readString()
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        $string = '';
-        while (($char = @fread($this->fp, 1)) != "\x00")  {
-            $string .= $char;
-        }
-        return $string;
-    }
-
-    /**
-     * Reads an IP Address and returns it in a dot formated string
-     *
-     * @access public
-     * @return Dot formated string, or a PEAR_Error if
-     *         not connected.
-     */
-    function readIPAddress()
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        $buf = @fread($this->fp, 4);
-        return sprintf("%s.%s.%s.%s", ord($buf[0]), ord($buf[1]),
-                       ord($buf[2]), ord($buf[3]));
-    }
-
-    /**
-     * Read until either the end of the socket or a newline, whichever
-     * comes first. Strips the trailing newline from the returned data.
-     *
-     * @access public
-     * @return All available data up to a newline, without that
-     *         newline, or until the end of the socket, or a PEAR_Error if
-     *         not connected.
-     */
-    function readLine()
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        $line = '';
-        $timeout = time() + $this->timeout;
-        while (!feof($this->fp) && (!$this->timeout || time() < $timeout)) {
-            $line .= @fgets($this->fp, $this->lineLength);
-            if (substr($line, -1) == "\n") {
-                return rtrim($line, "\r\n");
-            }
-        }
-        return $line;
-    }
-
-    /**
-     * Read until the socket closes, or until there is no more data in
-     * the inner PHP buffer. If the inner buffer is empty, in blocking
-     * mode we wait for at least 1 byte of data. Therefore, in
-     * blocking mode, if there is no data at all to be read, this
-     * function will never exit (unless the socket is closed on the
-     * remote end).
-     *
-     * @access public
-     *
-     * @return string  All data until the socket closes, or a PEAR_Error if
-     *                 not connected.
-     */
-    function readAll()
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        $data = '';
-        while (!feof($this->fp)) {
-            $data .= @fread($this->fp, $this->lineLength);
-        }
-        return $data;
-    }
-
-    /**
-     * Runs the equivalent of the select() system call on the socket
-     * with a timeout specified by tv_sec and tv_usec.
-     *
-     * @param integer $state    Which of read/write/error to check for.
-     * @param integer $tv_sec   Number of seconds for timeout.
-     * @param integer $tv_usec  Number of microseconds for timeout.
-     *
-     * @access public
-     * @return False if select fails, integer describing which of read/write/error
-     *         are ready, or PEAR_Error if not connected.
-     */
-    function select($state, $tv_sec, $tv_usec = 0)
-    {
-        if (!is_resource($this->fp)) {
-            return $this->raiseError('not connected');
-        }
-
-        $read = null;
-        $write = null;
-        $except = null;
-        if ($state & NET_SOCKET_READ) {
-            $read[] = $this->fp;
-        }
-        if ($state & NET_SOCKET_WRITE) {
-            $write[] = $this->fp;
-        }
-        if ($state & NET_SOCKET_ERROR) {
-            $except[] = $this->fp;
-        }
-        if (false === ($sr = stream_select($read, $write, $except, $tv_sec, $tv_usec))) {
-            return false;
-        }
-
-        $result = 0;
-        if (count($read)) {
-            $result |= NET_SOCKET_READ;
-        }
-        if (count($write)) {
-            $result |= NET_SOCKET_WRITE;
-        }
-        if (count($except)) {
-            $result |= NET_SOCKET_ERROR;
-        }
-        return $result;
-    }
+	/**
+	 * Socket file pointer.
+	 * @var resource $fp
+	 */
+	var $fp = null;
+
+	/**
+	 * Whether the socket is blocking. Defaults to true.
+	 * @var boolean $blocking
+	 */
+	var $blocking = true;
+
+	/**
+	 * Whether the socket is persistent. Defaults to false.
+	 * @var boolean $persistent
+	 */
+	var $persistent = false;
+
+	/**
+	 * The IP address to connect to.
+	 * @var string $addr
+	 */
+	var $addr = '';
+
+	/**
+	 * The port number to connect to.
+	 * @var integer $port
+	 */
+	var $port = 0;
+
+	/**
+	 * Number of seconds to wait on socket connections before assuming
+	 * there's no more data. Defaults to no timeout.
+	 * @var integer $timeout
+	 */
+	var $timeout = false;
+
+	/**
+	 * Number of bytes to read at a time in readLine() and
+	 * readAll(). Defaults to 2048.
+	 * @var integer $lineLength
+	 */
+	var $lineLength = 2048;
+
+	/**
+	 * Connect to the specified port. If called when the socket is
+	 * already connected, it disconnects and connects again.
+	 *
+	 * @param string  $addr        IP address or host name.
+	 * @param integer $port        TCP port number.
+	 * @param boolean $persistent  (optional) Whether the connection is
+	 *                             persistent (kept open between requests
+	 *                             by the web server).
+	 * @param integer $timeout     (optional) How long to wait for data.
+	 * @param array   $options     See options for stream_context_create.
+	 *
+	 * @access public
+	 *
+	 * @return boolean | PEAR_Error  True on success or a PEAR_Error on failure.
+	 */
+	function connect($addr, $port = 0, $persistent = null, $timeout = null, $options = null)
+	{
+		if (is_resource($this->fp)) {
+			@fclose($this->fp);
+			$this->fp = null;
+		}
+
+		if (!$addr) {
+			return $this->raiseError('$addr cannot be empty');
+		} elseif (strspn($addr, '.0123456789') == strlen($addr) ||
+				  strstr($addr, '/') !== false) {
+			$this->addr = $addr;
+		} else {
+			$this->addr = @gethostbyname($addr);
+		}
+
+		$this->port = $port % 65536;
+
+		if ($persistent !== null) {
+			$this->persistent = $persistent;
+		}
+
+		if ($timeout !== null) {
+			$this->timeout = $timeout;
+		}
+
+		$openfunc = $this->persistent ? 'pfsockopen' : 'fsockopen';
+		$errno = 0;
+		$errstr = '';
+		if ($options && function_exists('stream_context_create')) {
+			if ($this->timeout) {
+				$timeout = $this->timeout;
+			} else {
+				$timeout = 0;
+			}
+			$context = stream_context_create($options);
+			$fp = @$openfunc($this->addr, $this->port, $errno, $errstr, $timeout, $context);
+		} else {
+			if ($this->timeout) {
+				$fp = @$openfunc($this->addr, $this->port, $errno, $errstr, $this->timeout);
+			} else {
+				$fp = @$openfunc($this->addr, $this->port, $errno, $errstr);
+			}
+		}
+
+		if (!$fp) {
+			return $this->raiseError($errstr, $errno);
+		}
+
+		$this->fp = $fp;
+
+		return $this->setBlocking($this->blocking);
+	}
+
+	/**
+	 * Disconnects from the peer, closes the socket.
+	 *
+	 * @access public
+	 * @return mixed true on success or an error object otherwise
+	 */
+	function disconnect()
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		@fclose($this->fp);
+		$this->fp = null;
+		return true;
+	}
+
+	/**
+	 * Find out if the socket is in blocking mode.
+	 *
+	 * @access public
+	 * @return boolean  The current blocking mode.
+	 */
+	function isBlocking()
+	{
+		return $this->blocking;
+	}
+
+	/**
+	 * Sets whether the socket connection should be blocking or
+	 * not. A read call to a non-blocking socket will return immediately
+	 * if there is no data available, whereas it will block until there
+	 * is data for blocking sockets.
+	 *
+	 * @param boolean $mode  True for blocking sockets, false for nonblocking.
+	 * @access public
+	 * @return mixed true on success or an error object otherwise
+	 */
+	function setBlocking($mode)
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		$this->blocking = $mode;
+		socket_set_blocking($this->fp, $this->blocking);
+		return true;
+	}
+
+	/**
+	 * Sets the timeout value on socket descriptor,
+	 * expressed in the sum of seconds and microseconds
+	 *
+	 * @param integer $seconds  Seconds.
+	 * @param integer $microseconds  Microseconds.
+	 * @access public
+	 * @return mixed true on success or an error object otherwise
+	 */
+	function setTimeout($seconds, $microseconds)
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		return socket_set_timeout($this->fp, $seconds, $microseconds);
+	}
+
+	/**
+	 * Returns information about an existing socket resource.
+	 * Currently returns four entries in the result array:
+	 *
+	 * <p>
+	 * timed_out (bool) - The socket timed out waiting for data<br>
+	 * blocked (bool) - The socket was blocked<br>
+	 * eof (bool) - Indicates EOF event<br>
+	 * unread_bytes (int) - Number of bytes left in the socket buffer<br>
+	 * </p>
+	 *
+	 * @access public
+	 * @return mixed Array containing information about existing socket resource or an error object otherwise
+	 */
+	function getStatus()
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		return socket_get_status($this->fp);
+	}
+
+	/**
+	 * Get a specified line of data
+	 *
+	 * @access public
+	 * @return $size bytes of data from the socket, or a PEAR_Error if
+	 *         not connected.
+	 */
+	function gets($size)
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		return @fgets($this->fp, $size);
+	}
+
+	/**
+	 * Read a specified amount of data. This is guaranteed to return,
+	 * and has the added benefit of getting everything in one fread()
+	 * chunk; if you know the size of the data you're getting
+	 * beforehand, this is definitely the way to go.
+	 *
+	 * @param integer $size  The number of bytes to read from the socket.
+	 * @access public
+	 * @return $size bytes of data from the socket, or a PEAR_Error if
+	 *         not connected.
+	 */
+	function read($size)
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		return @fread($this->fp, $size);
+	}
+
+	/**
+	 * Write a specified amount of data.
+	 *
+	 * @param string  $data       Data to write.
+	 * @param integer $blocksize  Amount of data to write at once.
+	 *                            NULL means all at once.
+	 *
+	 * @access public
+	 * @return mixed true on success or an error object otherwise
+	 */
+	function write($data, $blocksize = null)
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		if (is_null($blocksize) && !OS_WINDOWS) {
+			return fwrite($this->fp, $data);
+		} else {
+			if (is_null($blocksize)) {
+				$blocksize = 1024;
+			}
+
+			$pos = 0;
+			$size = strlen($data);
+			while ($pos < $size) {
+				$written = @fwrite($this->fp, substr($data, $pos, $blocksize));
+				if ($written === false) {
+					return false;
+				}
+				$pos += $written;
+			}
+
+			return $pos;
+		}
+	}
+
+	/**
+	 * Write a line of data to the socket, followed by a trailing "\r\n".
+	 *
+	 * @access public
+	 * @return mixed fputs result, or an error
+	 */
+	function writeLine($data)
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		return fwrite($this->fp, $data . "\r\n");
+	}
+
+	/**
+	 * Tests for end-of-file on a socket descriptor.
+	 *
+	 * @access public
+	 * @return bool
+	 */
+	function eof()
+	{
+		return (is_resource($this->fp) && feof($this->fp));
+	}
+
+	/**
+	 * Reads a byte of data
+	 *
+	 * @access public
+	 * @return 1 byte of data from the socket, or a PEAR_Error if
+	 *         not connected.
+	 */
+	function readByte()
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		return ord(@fread($this->fp, 1));
+	}
+
+	/**
+	 * Reads a word of data
+	 *
+	 * @access public
+	 * @return 1 word of data from the socket, or a PEAR_Error if
+	 *         not connected.
+	 */
+	function readWord()
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		$buf = @fread($this->fp, 2);
+		return (ord($buf[0]) + (ord($buf[1]) << 8));
+	}
+
+	/**
+	 * Reads an int of data
+	 *
+	 * @access public
+	 * @return integer  1 int of data from the socket, or a PEAR_Error if
+	 *                  not connected.
+	 */
+	function readInt()
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		$buf = @fread($this->fp, 4);
+		return (ord($buf[0]) + (ord($buf[1]) << 8) +
+				(ord($buf[2]) << 16) + (ord($buf[3]) << 24));
+	}
+
+	/**
+	 * Reads a zero-terminated string of data
+	 *
+	 * @access public
+	 * @return string, or a PEAR_Error if
+	 *         not connected.
+	 */
+	function readString()
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		$string = '';
+		while (($char = @fread($this->fp, 1)) != "\x00")  {
+			$string .= $char;
+		}
+		return $string;
+	}
+
+	/**
+	 * Reads an IP Address and returns it in a dot formated string
+	 *
+	 * @access public
+	 * @return Dot formated string, or a PEAR_Error if
+	 *         not connected.
+	 */
+	function readIPAddress()
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		$buf = @fread($this->fp, 4);
+		return sprintf("%s.%s.%s.%s", ord($buf[0]), ord($buf[1]),
+					   ord($buf[2]), ord($buf[3]));
+	}
+
+	/**
+	 * Read until either the end of the socket or a newline, whichever
+	 * comes first. Strips the trailing newline from the returned data.
+	 *
+	 * @access public
+	 * @return All available data up to a newline, without that
+	 *         newline, or until the end of the socket, or a PEAR_Error if
+	 *         not connected.
+	 */
+	function readLine()
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		$line = '';
+		$timeout = time() + $this->timeout;
+		while (!feof($this->fp) && (!$this->timeout || time() < $timeout)) {
+			$line .= @fgets($this->fp, $this->lineLength);
+			if (substr($line, -1) == "\n") {
+				return rtrim($line, "\r\n");
+			}
+		}
+		return $line;
+	}
+
+	/**
+	 * Read until the socket closes, or until there is no more data in
+	 * the inner PHP buffer. If the inner buffer is empty, in blocking
+	 * mode we wait for at least 1 byte of data. Therefore, in
+	 * blocking mode, if there is no data at all to be read, this
+	 * function will never exit (unless the socket is closed on the
+	 * remote end).
+	 *
+	 * @access public
+	 *
+	 * @return string  All data until the socket closes, or a PEAR_Error if
+	 *                 not connected.
+	 */
+	function readAll()
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		$data = '';
+		while (!feof($this->fp)) {
+			$data .= @fread($this->fp, $this->lineLength);
+		}
+		return $data;
+	}
+
+	/**
+	 * Runs the equivalent of the select() system call on the socket
+	 * with a timeout specified by tv_sec and tv_usec.
+	 *
+	 * @param integer $state    Which of read/write/error to check for.
+	 * @param integer $tv_sec   Number of seconds for timeout.
+	 * @param integer $tv_usec  Number of microseconds for timeout.
+	 *
+	 * @access public
+	 * @return False if select fails, integer describing which of read/write/error
+	 *         are ready, or PEAR_Error if not connected.
+	 */
+	function select($state, $tv_sec, $tv_usec = 0)
+	{
+		if (!is_resource($this->fp)) {
+			return $this->raiseError('not connected');
+		}
+
+		$read = null;
+		$write = null;
+		$except = null;
+		if ($state & NET_SOCKET_READ) {
+			$read[] = $this->fp;
+		}
+		if ($state & NET_SOCKET_WRITE) {
+			$write[] = $this->fp;
+		}
+		if ($state & NET_SOCKET_ERROR) {
+			$except[] = $this->fp;
+		}
+		if (false === ($sr = stream_select($read, $write, $except, $tv_sec, $tv_usec))) {
+			return false;
+		}
+
+		$result = 0;
+		if (count($read)) {
+			$result |= NET_SOCKET_READ;
+		}
+		if (count($write)) {
+			$result |= NET_SOCKET_WRITE;
+		}
+		if (count($except)) {
+			$result |= NET_SOCKET_ERROR;
+		}
+		return $result;
+	}
 
 }

Spacing +3 added lines, -3 removed lines

@@ -21,7 +21,7 @@ 
 
 require_once 'PEAR.php';
 
-define('NET_SOCKET_READ',  1);
+define('NET_SOCKET_READ', 1);
 define('NET_SOCKET_WRITE', 2);
 define('NET_SOCKET_ERROR', 3);
 
@@ -323,7 +323,7 @@ 
             return $this->raiseError('not connected');
         }
 
-        return fwrite($this->fp, $data . "\r\n");
+        return fwrite($this->fp, $data."\r\n");
     }
 
     /**
@@ -402,7 +402,7 @@ 
         }
 
         $string = '';
-        while (($char = @fread($this->fp, 1)) != "\x00")  {
+        while (($char = @fread($this->fp, 1)) != "\x00") {
             $string .= $char;
         }
         return $string;

libs/PEAR/PEAR.php

Indentation +979 added lines, -979 removed lines

@@ -40,25 +40,25 @@ 
 define('PEAR_ERROR_EXCEPTION', 32);
 /**#@-*/
 define('PEAR_ZE2', (function_exists('version_compare') &&
-                    version_compare(zend_version(), "2-dev", "ge")));
+					version_compare(zend_version(), "2-dev", "ge")));
 
 if (substr(PHP_OS, 0, 3) == 'WIN') {
-    define('OS_WINDOWS', true);
-    define('OS_UNIX',    false);
-    define('PEAR_OS',    'Windows');
+	define('OS_WINDOWS', true);
+	define('OS_UNIX',    false);
+	define('PEAR_OS',    'Windows');
 } else {
-    define('OS_WINDOWS', false);
-    define('OS_UNIX',    true);
-    define('PEAR_OS',    'Unix'); // blatant assumption
+	define('OS_WINDOWS', false);
+	define('OS_UNIX',    true);
+	define('PEAR_OS',    'Unix'); // blatant assumption
 }
 
 // instant backwards compatibility
 if (!defined('PATH_SEPARATOR')) {
-    if (OS_WINDOWS) {
-        define('PATH_SEPARATOR', ';');
-    } else {
-        define('PATH_SEPARATOR', ':');
-    }
+	if (OS_WINDOWS) {
+		define('PATH_SEPARATOR', ';');
+	} else {
+		define('PATH_SEPARATOR', ':');
+	}
 }
 
 $GLOBALS['_PEAR_default_error_mode']     = PEAR_ERROR_RETURN;
@@ -101,704 +101,704 @@ 
  */
 class PEAR
 {
-    // {{{ properties
-
-    /**
-     * Whether to enable internal debug messages.
-     *
-     * @var     bool
-     * @access  private
-     */
-    var $_debug = false;
-
-    /**
-     * Default error mode for this object.
-     *
-     * @var     int
-     * @access  private
-     */
-    var $_default_error_mode = null;
-
-    /**
-     * Default error options used for this object when error mode
-     * is PEAR_ERROR_TRIGGER.
-     *
-     * @var     int
-     * @access  private
-     */
-    var $_default_error_options = null;
-
-    /**
-     * Default error handler (callback) for this object, if error mode is
-     * PEAR_ERROR_CALLBACK.
-     *
-     * @var     string
-     * @access  private
-     */
-    var $_default_error_handler = '';
-
-    /**
-     * Which class to use for error objects.
-     *
-     * @var     string
-     * @access  private
-     */
-    var $_error_class = 'PEAR_Error';
-
-    /**
-     * An array of expected errors.
-     *
-     * @var     array
-     * @access  private
-     */
-    var $_expected_errors = array();
-
-    // }}}
-
-    // {{{ constructor
-
-    /**
-     * Constructor.  Registers this object in
-     * $_PEAR_destructor_object_list for destructor emulation if a
-     * destructor object exists.
-     *
-     * @param string $error_class  (optional) which class to use for
-     *        error objects, defaults to PEAR_Error.
-     * @access public
-     * @return void
-     */
-    function PEAR($error_class = null)
-    {
-        $classname = strtolower(get_class($this));
-        if ($this->_debug) {
-            print "PEAR constructor called, class=$classname\n";
-        }
-        if ($error_class !== null) {
-            $this->_error_class = $error_class;
-        }
-        while ($classname && strcasecmp($classname, "pear")) {
-            $destructor = "_$classname";
-            if (method_exists($this, $destructor)) {
-                global $_PEAR_destructor_object_list;
-                $_PEAR_destructor_object_list[] = &$this;
-                if (!isset($GLOBALS['_PEAR_SHUTDOWN_REGISTERED'])) {
-                    register_shutdown_function("_PEAR_call_destructors");
-                    $GLOBALS['_PEAR_SHUTDOWN_REGISTERED'] = true;
-                }
-                break;
-            } else {
-                $classname = get_parent_class($classname);
-            }
-        }
-    }
-
-    // }}}
-    // {{{ destructor
-
-    /**
-     * Destructor (the emulated type of...).  Does nothing right now,
-     * but is included for forward compatibility, so subclass
-     * destructors should always call it.
-     *
-     * See the note in the class desciption about output from
-     * destructors.
-     *
-     * @access public
-     * @return void
-     */
-    function _PEAR() {
-        if ($this->_debug) {
-            printf("PEAR destructor called, class=%s\n", strtolower(get_class($this)));
-        }
-    }
-
-    // }}}
-    // {{{ getStaticProperty()
-
-    /**
-    * If you have a class that's mostly/entirely static, and you need static
-    * properties, you can use this method to simulate them. Eg. in your method(s)
-    * do this: $myVar = &PEAR::getStaticProperty('myclass', 'myVar');
-    * You MUST use a reference, or they will not persist!
-    *
-    * @access public
-    * @param  string $class  The calling classname, to prevent clashes
-    * @param  string $var    The variable to retrieve.
-    * @return mixed   A reference to the variable. If not set it will be
-    *                 auto initialised to NULL.
-    */
-    function &getStaticProperty($class, $var)
-    {
-        static $properties;
-        if (!isset($properties[$class])) {
-            $properties[$class] = array();
-        }
-        if (!array_key_exists($var, $properties[$class])) {
-            $properties[$class][$var] = null;
-        }
-        return $properties[$class][$var];
-    }
-
-    // }}}
-    // {{{ registerShutdownFunc()
-
-    /**
-    * Use this function to register a shutdown method for static
-    * classes.
-    *
-    * @access public
-    * @param  mixed $func  The function name (or array of class/method) to call
-    * @param  mixed $args  The arguments to pass to the function
-    * @return void
-    */
-    function registerShutdownFunc($func, $args = array())
-    {
-        // if we are called statically, there is a potential
-        // that no shutdown func is registered.  Bug #6445
-        if (!isset($GLOBALS['_PEAR_SHUTDOWN_REGISTERED'])) {
-            register_shutdown_function("_PEAR_call_destructors");
-            $GLOBALS['_PEAR_SHUTDOWN_REGISTERED'] = true;
-        }
-        $GLOBALS['_PEAR_shutdown_funcs'][] = array($func, $args);
-    }
-
-    // }}}
-    // {{{ isError()
-
-    /**
-     * Tell whether a value is a PEAR error.
-     *
-     * @param   mixed $data   the value to test
-     * @param   int   $code   if $data is an error object, return true
-     *                        only if $code is a string and
-     *                        $obj->getMessage() == $code or
-     *                        $code is an integer and $obj->getCode() == $code
-     * @access  public
-     * @return  bool    true if parameter is an error
-     */
-    function isError($data, $code = null)
-    {
-        if (is_a($data, 'PEAR_Error')) {
-            if (is_null($code)) {
-                return true;
-            } elseif (is_string($code)) {
-                return $data->getMessage() == $code;
-            } else {
-                return $data->getCode() == $code;
-            }
-        }
-        return false;
-    }
-
-    // }}}
-    // {{{ setErrorHandling()
-
-    /**
-     * Sets how errors generated by this object should be handled.
-     * Can be invoked both in objects and statically.  If called
-     * statically, setErrorHandling sets the default behaviour for all
-     * PEAR objects.  If called in an object, setErrorHandling sets
-     * the default behaviour for that object.
-     *
-     * @param int $mode
-     *        One of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT,
-     *        PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE,
-     *        PEAR_ERROR_CALLBACK or PEAR_ERROR_EXCEPTION.
-     *
-     * @param mixed $options
-     *        When $mode is PEAR_ERROR_TRIGGER, this is the error level (one
-     *        of E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR).
-     *
-     *        When $mode is PEAR_ERROR_CALLBACK, this parameter is expected
-     *        to be the callback function or method.  A callback
-     *        function is a string with the name of the function, a
-     *        callback method is an array of two elements: the element
-     *        at index 0 is the object, and the element at index 1 is
-     *        the name of the method to call in the object.
-     *
-     *        When $mode is PEAR_ERROR_PRINT or PEAR_ERROR_DIE, this is
-     *        a printf format string used when printing the error
-     *        message.
-     *
-     * @access public
-     * @return void
-     * @see PEAR_ERROR_RETURN
-     * @see PEAR_ERROR_PRINT
-     * @see PEAR_ERROR_TRIGGER
-     * @see PEAR_ERROR_DIE
-     * @see PEAR_ERROR_CALLBACK
-     * @see PEAR_ERROR_EXCEPTION
-     *
-     * @since PHP 4.0.5
-     */
-
-    function setErrorHandling($mode = null, $options = null)
-    {
-        if (isset($this) && is_a($this, 'PEAR')) {
-            $setmode     = &$this->_default_error_mode;
-            $setoptions  = &$this->_default_error_options;
-        } else {
-            $setmode     = &$GLOBALS['_PEAR_default_error_mode'];
-            $setoptions  = &$GLOBALS['_PEAR_default_error_options'];
-        }
-
-        switch ($mode) {
-            case PEAR_ERROR_EXCEPTION:
-            case PEAR_ERROR_RETURN:
-            case PEAR_ERROR_PRINT:
-            case PEAR_ERROR_TRIGGER:
-            case PEAR_ERROR_DIE:
-            case null:
-                $setmode = $mode;
-                $setoptions = $options;
-                break;
-
-            case PEAR_ERROR_CALLBACK:
-                $setmode = $mode;
-                // class/object method callback
-                if (is_callable($options)) {
-                    $setoptions = $options;
-                } else {
-                    trigger_error("invalid error callback", E_USER_WARNING);
-                }
-                break;
-
-            default:
-                trigger_error("invalid error mode", E_USER_WARNING);
-                break;
-        }
-    }
-
-    // }}}
-    // {{{ expectError()
-
-    /**
-     * This method is used to tell which errors you expect to get.
-     * Expected errors are always returned with error mode
-     * PEAR_ERROR_RETURN.  Expected error codes are stored in a stack,
-     * and this method pushes a new element onto it.  The list of
-     * expected errors are in effect until they are popped off the
-     * stack with the popExpect() method.
-     *
-     * Note that this method can not be called statically
-     *
-     * @param mixed $code a single error code or an array of error codes to expect
-     *
-     * @return int     the new depth of the "expected errors" stack
-     * @access public
-     */
-    function expectError($code = '*')
-    {
-        if (is_array($code)) {
-            array_push($this->_expected_errors, $code);
-        } else {
-            array_push($this->_expected_errors, array($code));
-        }
-        return sizeof($this->_expected_errors);
-    }
-
-    // }}}
-    // {{{ popExpect()
-
-    /**
-     * This method pops one element off the expected error codes
-     * stack.
-     *
-     * @return array   the list of error codes that were popped
-     */
-    function popExpect()
-    {
-        return array_pop($this->_expected_errors);
-    }
-
-    // }}}
-    // {{{ _checkDelExpect()
-
-    /**
-     * This method checks unsets an error code if available
-     *
-     * @param mixed error code
-     * @return bool true if the error code was unset, false otherwise
-     * @access private
-     * @since PHP 4.3.0
-     */
-    function _checkDelExpect($error_code)
-    {
-        $deleted = false;
-
-        foreach ($this->_expected_errors AS $key => $error_array) {
-            if (in_array($error_code, $error_array)) {
-                unset($this->_expected_errors[$key][array_search($error_code, $error_array)]);
-                $deleted = true;
-            }
-
-            // clean up empty arrays
-            if (0 == count($this->_expected_errors[$key])) {
-                unset($this->_expected_errors[$key]);
-            }
-        }
-        return $deleted;
-    }
-
-    // }}}
-    // {{{ delExpect()
-
-    /**
-     * This method deletes all occurences of the specified element from
-     * the expected error codes stack.
-     *
-     * @param  mixed $error_code error code that should be deleted
-     * @return mixed list of error codes that were deleted or error
-     * @access public
-     * @since PHP 4.3.0
-     */
-    function delExpect($error_code)
-    {
-        $deleted = false;
-
-        if ((is_array($error_code) && (0 != count($error_code)))) {
-            // $error_code is a non-empty array here;
-            // we walk through it trying to unset all
-            // values
-            foreach($error_code as $key => $error) {
-                if ($this->_checkDelExpect($error)) {
-                    $deleted =  true;
-                } else {
-                    $deleted = false;
-                }
-            }
-            return $deleted ? true : PEAR::raiseError("The expected error you submitted does not exist"); // IMPROVE ME
-        } elseif (!empty($error_code)) {
-            // $error_code comes alone, trying to unset it
-            if ($this->_checkDelExpect($error_code)) {
-                return true;
-            } else {
-                return PEAR::raiseError("The expected error you submitted does not exist"); // IMPROVE ME
-            }
-        } else {
-            // $error_code is empty
-            return PEAR::raiseError("The expected error you submitted is empty"); // IMPROVE ME
-        }
-    }
-
-    // }}}
-    // {{{ raiseError()
-
-    /**
-     * This method is a wrapper that returns an instance of the
-     * configured error class with this object's default error
-     * handling applied.  If the $mode and $options parameters are not
-     * specified, the object's defaults are used.
-     *
-     * @param mixed $message a text error message or a PEAR error object
-     *
-     * @param int $code      a numeric error code (it is up to your class
-     *                  to define these if you want to use codes)
-     *
-     * @param int $mode      One of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT,
-     *                  PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE,
-     *                  PEAR_ERROR_CALLBACK, PEAR_ERROR_EXCEPTION.
-     *
-     * @param mixed $options If $mode is PEAR_ERROR_TRIGGER, this parameter
-     *                  specifies the PHP-internal error level (one of
-     *                  E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR).
-     *                  If $mode is PEAR_ERROR_CALLBACK, this
-     *                  parameter specifies the callback function or
-     *                  method.  In other error modes this parameter
-     *                  is ignored.
-     *
-     * @param string $userinfo If you need to pass along for example debug
-     *                  information, this parameter is meant for that.
-     *
-     * @param string $error_class The returned error object will be
-     *                  instantiated from this class, if specified.
-     *
-     * @param bool $skipmsg If true, raiseError will only pass error codes,
-     *                  the error message parameter will be dropped.
-     *
-     * @access public
-     * @return object   a PEAR error object
-     * @see PEAR::setErrorHandling
-     * @since PHP 4.0.5
-     */
-    function &raiseError($message = null,
-                         $code = null,
-                         $mode = null,
-                         $options = null,
-                         $userinfo = null,
-                         $error_class = null,
-                         $skipmsg = false)
-    {
-        // The error is yet a PEAR error object
-        if (is_object($message)) {
-            $code        = $message->getCode();
-            $userinfo    = $message->getUserInfo();
-            $error_class = $message->getType();
-            $message->error_message_prefix = '';
-            $message     = $message->getMessage();
-        }
-
-        if (isset($this) && isset($this->_expected_errors) && sizeof($this->_expected_errors) > 0 && sizeof($exp = end($this->_expected_errors))) {
-            if ($exp[0] == "*" ||
-                (is_int(reset($exp)) && in_array($code, $exp)) ||
-                (is_string(reset($exp)) && in_array($message, $exp))) {
-                $mode = PEAR_ERROR_RETURN;
-            }
-        }
-        // No mode given, try global ones
-        if ($mode === null) {
-            // Class error handler
-            if (isset($this) && isset($this->_default_error_mode)) {
-                $mode    = $this->_default_error_mode;
-                $options = $this->_default_error_options;
-            // Global error handler
-            } elseif (isset($GLOBALS['_PEAR_default_error_mode'])) {
-                $mode    = $GLOBALS['_PEAR_default_error_mode'];
-                $options = $GLOBALS['_PEAR_default_error_options'];
-            }
-        }
-
-        if ($error_class !== null) {
-            $ec = $error_class;
-        } elseif (isset($this) && isset($this->_error_class)) {
-            $ec = $this->_error_class;
-        } else {
-            $ec = 'PEAR_Error';
-        }
-        if ($skipmsg) {
-            $a = &new $ec($code, $mode, $options, $userinfo);
-            return $a;
-        } else {
-            $a = &new $ec($message, $code, $mode, $options, $userinfo);
-            return $a;
-        }
-    }
-
-    // }}}
-    // {{{ throwError()
-
-    /**
-     * Simpler form of raiseError with fewer options.  In most cases
-     * message, code and userinfo are enough.
-     *
-     * @param string $message
-     *
-     */
-    function &throwError($message = null,
-                         $code = null,
-                         $userinfo = null)
-    {
-        if (isset($this) && is_a($this, 'PEAR')) {
-            $a = &$this->raiseError($message, $code, null, null, $userinfo);
-            return $a;
-        } else {
-            $a = &PEAR::raiseError($message, $code, null, null, $userinfo);
-            return $a;
-        }
-    }
-
-    // }}}
-    function staticPushErrorHandling($mode, $options = null)
-    {
-        $stack = &$GLOBALS['_PEAR_error_handler_stack'];
-        $def_mode    = &$GLOBALS['_PEAR_default_error_mode'];
-        $def_options = &$GLOBALS['_PEAR_default_error_options'];
-        $stack[] = array($def_mode, $def_options);
-        switch ($mode) {
-            case PEAR_ERROR_EXCEPTION:
-            case PEAR_ERROR_RETURN:
-            case PEAR_ERROR_PRINT:
-            case PEAR_ERROR_TRIGGER:
-            case PEAR_ERROR_DIE:
-            case null:
-                $def_mode = $mode;
-                $def_options = $options;
-                break;
-
-            case PEAR_ERROR_CALLBACK:
-                $def_mode = $mode;
-                // class/object method callback
-                if (is_callable($options)) {
-                    $def_options = $options;
-                } else {
-                    trigger_error("invalid error callback", E_USER_WARNING);
-                }
-                break;
-
-            default:
-                trigger_error("invalid error mode", E_USER_WARNING);
-                break;
-        }
-        $stack[] = array($mode, $options);
-        return true;
-    }
-
-    function staticPopErrorHandling()
-    {
-        $stack = &$GLOBALS['_PEAR_error_handler_stack'];
-        $setmode     = &$GLOBALS['_PEAR_default_error_mode'];
-        $setoptions  = &$GLOBALS['_PEAR_default_error_options'];
-        array_pop($stack);
-        list($mode, $options) = $stack[sizeof($stack) - 1];
-        array_pop($stack);
-        switch ($mode) {
-            case PEAR_ERROR_EXCEPTION:
-            case PEAR_ERROR_RETURN:
-            case PEAR_ERROR_PRINT:
-            case PEAR_ERROR_TRIGGER:
-            case PEAR_ERROR_DIE:
-            case null:
-                $setmode = $mode;
-                $setoptions = $options;
-                break;
-
-            case PEAR_ERROR_CALLBACK:
-                $setmode = $mode;
-                // class/object method callback
-                if (is_callable($options)) {
-                    $setoptions = $options;
-                } else {
-                    trigger_error("invalid error callback", E_USER_WARNING);
-                }
-                break;
-
-            default:
-                trigger_error("invalid error mode", E_USER_WARNING);
-                break;
-        }
-        return true;
-    }
-
-    // {{{ pushErrorHandling()
-
-    /**
-     * Push a new error handler on top of the error handler options stack. With this
-     * you can easily override the actual error handler for some code and restore
-     * it later with popErrorHandling.
-     *
-     * @param mixed $mode (same as setErrorHandling)
-     * @param mixed $options (same as setErrorHandling)
-     *
-     * @return bool Always true
-     *
-     * @see PEAR::setErrorHandling
-     */
-    function pushErrorHandling($mode, $options = null)
-    {
-        $stack = &$GLOBALS['_PEAR_error_handler_stack'];
-        if (isset($this) && is_a($this, 'PEAR')) {
-            $def_mode    = &$this->_default_error_mode;
-            $def_options = &$this->_default_error_options;
-        } else {
-            $def_mode    = &$GLOBALS['_PEAR_default_error_mode'];
-            $def_options = &$GLOBALS['_PEAR_default_error_options'];
-        }
-        $stack[] = array($def_mode, $def_options);
-
-        if (isset($this) && is_a($this, 'PEAR')) {
-            $this->setErrorHandling($mode, $options);
-        } else {
-            PEAR::setErrorHandling($mode, $options);
-        }
-        $stack[] = array($mode, $options);
-        return true;
-    }
-
-    // }}}
-    // {{{ popErrorHandling()
-
-    /**
-    * Pop the last error handler used
-    *
-    * @return bool Always true
-    *
-    * @see PEAR::pushErrorHandling
-    */
-    function popErrorHandling()
-    {
-        $stack = &$GLOBALS['_PEAR_error_handler_stack'];
-        array_pop($stack);
-        list($mode, $options) = $stack[sizeof($stack) - 1];
-        array_pop($stack);
-        if (isset($this) && is_a($this, 'PEAR')) {
-            $this->setErrorHandling($mode, $options);
-        } else {
-            PEAR::setErrorHandling($mode, $options);
-        }
-        return true;
-    }
-
-    // }}}
-    // {{{ loadExtension()
-
-    /**
-    * OS independant PHP extension load. Remember to take care
-    * on the correct extension name for case sensitive OSes.
-    *
-    * @param string $ext The extension name
-    * @return bool Success or not on the dl() call
-    */
-    function loadExtension($ext)
-    {
-        if (!extension_loaded($ext)) {
-            // if either returns true dl() will produce a FATAL error, stop that
-            if ((ini_get('enable_dl') != 1) || (ini_get('safe_mode') == 1)) {
-                return false;
-            }
-            if (OS_WINDOWS) {
-                $suffix = '.dll';
-            } elseif (PHP_OS == 'HP-UX') {
-                $suffix = '.sl';
-            } elseif (PHP_OS == 'AIX') {
-                $suffix = '.a';
-            } elseif (PHP_OS == 'OSX') {
-                $suffix = '.bundle';
-            } else {
-                $suffix = '.so';
-            }
-            return @dl('php_'.$ext.$suffix) || @dl($ext.$suffix);
-        }
-        return true;
-    }
-
-    // }}}
+	// {{{ properties
+
+	/**
+	 * Whether to enable internal debug messages.
+	 *
+	 * @var     bool
+	 * @access  private
+	 */
+	var $_debug = false;
+
+	/**
+	 * Default error mode for this object.
+	 *
+	 * @var     int
+	 * @access  private
+	 */
+	var $_default_error_mode = null;
+
+	/**
+	 * Default error options used for this object when error mode
+	 * is PEAR_ERROR_TRIGGER.
+	 *
+	 * @var     int
+	 * @access  private
+	 */
+	var $_default_error_options = null;
+
+	/**
+	 * Default error handler (callback) for this object, if error mode is
+	 * PEAR_ERROR_CALLBACK.
+	 *
+	 * @var     string
+	 * @access  private
+	 */
+	var $_default_error_handler = '';
+
+	/**
+	 * Which class to use for error objects.
+	 *
+	 * @var     string
+	 * @access  private
+	 */
+	var $_error_class = 'PEAR_Error';
+
+	/**
+	 * An array of expected errors.
+	 *
+	 * @var     array
+	 * @access  private
+	 */
+	var $_expected_errors = array();
+
+	// }}}
+
+	// {{{ constructor
+
+	/**
+	 * Constructor.  Registers this object in
+	 * $_PEAR_destructor_object_list for destructor emulation if a
+	 * destructor object exists.
+	 *
+	 * @param string $error_class  (optional) which class to use for
+	 *        error objects, defaults to PEAR_Error.
+	 * @access public
+	 * @return void
+	 */
+	function PEAR($error_class = null)
+	{
+		$classname = strtolower(get_class($this));
+		if ($this->_debug) {
+			print "PEAR constructor called, class=$classname\n";
+		}
+		if ($error_class !== null) {
+			$this->_error_class = $error_class;
+		}
+		while ($classname && strcasecmp($classname, "pear")) {
+			$destructor = "_$classname";
+			if (method_exists($this, $destructor)) {
+				global $_PEAR_destructor_object_list;
+				$_PEAR_destructor_object_list[] = &$this;
+				if (!isset($GLOBALS['_PEAR_SHUTDOWN_REGISTERED'])) {
+					register_shutdown_function("_PEAR_call_destructors");
+					$GLOBALS['_PEAR_SHUTDOWN_REGISTERED'] = true;
+				}
+				break;
+			} else {
+				$classname = get_parent_class($classname);
+			}
+		}
+	}
+
+	// }}}
+	// {{{ destructor
+
+	/**
+	 * Destructor (the emulated type of...).  Does nothing right now,
+	 * but is included for forward compatibility, so subclass
+	 * destructors should always call it.
+	 *
+	 * See the note in the class desciption about output from
+	 * destructors.
+	 *
+	 * @access public
+	 * @return void
+	 */
+	function _PEAR() {
+		if ($this->_debug) {
+			printf("PEAR destructor called, class=%s\n", strtolower(get_class($this)));
+		}
+	}
+
+	// }}}
+	// {{{ getStaticProperty()
+
+	/**
+	 * If you have a class that's mostly/entirely static, and you need static
+	 * properties, you can use this method to simulate them. Eg. in your method(s)
+	 * do this: $myVar = &PEAR::getStaticProperty('myclass', 'myVar');
+	 * You MUST use a reference, or they will not persist!
+	 *
+	 * @access public
+	 * @param  string $class  The calling classname, to prevent clashes
+	 * @param  string $var    The variable to retrieve.
+	 * @return mixed   A reference to the variable. If not set it will be
+	 *                 auto initialised to NULL.
+	 */
+	function &getStaticProperty($class, $var)
+	{
+		static $properties;
+		if (!isset($properties[$class])) {
+			$properties[$class] = array();
+		}
+		if (!array_key_exists($var, $properties[$class])) {
+			$properties[$class][$var] = null;
+		}
+		return $properties[$class][$var];
+	}
+
+	// }}}
+	// {{{ registerShutdownFunc()
+
+	/**
+	 * Use this function to register a shutdown method for static
+	 * classes.
+	 *
+	 * @access public
+	 * @param  mixed $func  The function name (or array of class/method) to call
+	 * @param  mixed $args  The arguments to pass to the function
+	 * @return void
+	 */
+	function registerShutdownFunc($func, $args = array())
+	{
+		// if we are called statically, there is a potential
+		// that no shutdown func is registered.  Bug #6445
+		if (!isset($GLOBALS['_PEAR_SHUTDOWN_REGISTERED'])) {
+			register_shutdown_function("_PEAR_call_destructors");
+			$GLOBALS['_PEAR_SHUTDOWN_REGISTERED'] = true;
+		}
+		$GLOBALS['_PEAR_shutdown_funcs'][] = array($func, $args);
+	}
+
+	// }}}
+	// {{{ isError()
+
+	/**
+	 * Tell whether a value is a PEAR error.
+	 *
+	 * @param   mixed $data   the value to test
+	 * @param   int   $code   if $data is an error object, return true
+	 *                        only if $code is a string and
+	 *                        $obj->getMessage() == $code or
+	 *                        $code is an integer and $obj->getCode() == $code
+	 * @access  public
+	 * @return  bool    true if parameter is an error
+	 */
+	function isError($data, $code = null)
+	{
+		if (is_a($data, 'PEAR_Error')) {
+			if (is_null($code)) {
+				return true;
+			} elseif (is_string($code)) {
+				return $data->getMessage() == $code;
+			} else {
+				return $data->getCode() == $code;
+			}
+		}
+		return false;
+	}
+
+	// }}}
+	// {{{ setErrorHandling()
+
+	/**
+	 * Sets how errors generated by this object should be handled.
+	 * Can be invoked both in objects and statically.  If called
+	 * statically, setErrorHandling sets the default behaviour for all
+	 * PEAR objects.  If called in an object, setErrorHandling sets
+	 * the default behaviour for that object.
+	 *
+	 * @param int $mode
+	 *        One of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT,
+	 *        PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE,
+	 *        PEAR_ERROR_CALLBACK or PEAR_ERROR_EXCEPTION.
+	 *
+	 * @param mixed $options
+	 *        When $mode is PEAR_ERROR_TRIGGER, this is the error level (one
+	 *        of E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR).
+	 *
+	 *        When $mode is PEAR_ERROR_CALLBACK, this parameter is expected
+	 *        to be the callback function or method.  A callback
+	 *        function is a string with the name of the function, a
+	 *        callback method is an array of two elements: the element
+	 *        at index 0 is the object, and the element at index 1 is
+	 *        the name of the method to call in the object.
+	 *
+	 *        When $mode is PEAR_ERROR_PRINT or PEAR_ERROR_DIE, this is
+	 *        a printf format string used when printing the error
+	 *        message.
+	 *
+	 * @access public
+	 * @return void
+	 * @see PEAR_ERROR_RETURN
+	 * @see PEAR_ERROR_PRINT
+	 * @see PEAR_ERROR_TRIGGER
+	 * @see PEAR_ERROR_DIE
+	 * @see PEAR_ERROR_CALLBACK
+	 * @see PEAR_ERROR_EXCEPTION
+	 *
+	 * @since PHP 4.0.5
+	 */
+
+	function setErrorHandling($mode = null, $options = null)
+	{
+		if (isset($this) && is_a($this, 'PEAR')) {
+			$setmode     = &$this->_default_error_mode;
+			$setoptions  = &$this->_default_error_options;
+		} else {
+			$setmode     = &$GLOBALS['_PEAR_default_error_mode'];
+			$setoptions  = &$GLOBALS['_PEAR_default_error_options'];
+		}
+
+		switch ($mode) {
+			case PEAR_ERROR_EXCEPTION:
+			case PEAR_ERROR_RETURN:
+			case PEAR_ERROR_PRINT:
+			case PEAR_ERROR_TRIGGER:
+			case PEAR_ERROR_DIE:
+			case null:
+				$setmode = $mode;
+				$setoptions = $options;
+				break;
+
+			case PEAR_ERROR_CALLBACK:
+				$setmode = $mode;
+				// class/object method callback
+				if (is_callable($options)) {
+					$setoptions = $options;
+				} else {
+					trigger_error("invalid error callback", E_USER_WARNING);
+				}
+				break;
+
+			default:
+				trigger_error("invalid error mode", E_USER_WARNING);
+				break;
+		}
+	}
+
+	// }}}
+	// {{{ expectError()
+
+	/**
+	 * This method is used to tell which errors you expect to get.
+	 * Expected errors are always returned with error mode
+	 * PEAR_ERROR_RETURN.  Expected error codes are stored in a stack,
+	 * and this method pushes a new element onto it.  The list of
+	 * expected errors are in effect until they are popped off the
+	 * stack with the popExpect() method.
+	 *
+	 * Note that this method can not be called statically
+	 *
+	 * @param mixed $code a single error code or an array of error codes to expect
+	 *
+	 * @return int     the new depth of the "expected errors" stack
+	 * @access public
+	 */
+	function expectError($code = '*')
+	{
+		if (is_array($code)) {
+			array_push($this->_expected_errors, $code);
+		} else {
+			array_push($this->_expected_errors, array($code));
+		}
+		return sizeof($this->_expected_errors);
+	}
+
+	// }}}
+	// {{{ popExpect()
+
+	/**
+	 * This method pops one element off the expected error codes
+	 * stack.
+	 *
+	 * @return array   the list of error codes that were popped
+	 */
+	function popExpect()
+	{
+		return array_pop($this->_expected_errors);
+	}
+
+	// }}}
+	// {{{ _checkDelExpect()
+
+	/**
+	 * This method checks unsets an error code if available
+	 *
+	 * @param mixed error code
+	 * @return bool true if the error code was unset, false otherwise
+	 * @access private
+	 * @since PHP 4.3.0
+	 */
+	function _checkDelExpect($error_code)
+	{
+		$deleted = false;
+
+		foreach ($this->_expected_errors AS $key => $error_array) {
+			if (in_array($error_code, $error_array)) {
+				unset($this->_expected_errors[$key][array_search($error_code, $error_array)]);
+				$deleted = true;
+			}
+
+			// clean up empty arrays
+			if (0 == count($this->_expected_errors[$key])) {
+				unset($this->_expected_errors[$key]);
+			}
+		}
+		return $deleted;
+	}
+
+	// }}}
+	// {{{ delExpect()
+
+	/**
+	 * This method deletes all occurences of the specified element from
+	 * the expected error codes stack.
+	 *
+	 * @param  mixed $error_code error code that should be deleted
+	 * @return mixed list of error codes that were deleted or error
+	 * @access public
+	 * @since PHP 4.3.0
+	 */
+	function delExpect($error_code)
+	{
+		$deleted = false;
+
+		if ((is_array($error_code) && (0 != count($error_code)))) {
+			// $error_code is a non-empty array here;
+			// we walk through it trying to unset all
+			// values
+			foreach($error_code as $key => $error) {
+				if ($this->_checkDelExpect($error)) {
+					$deleted =  true;
+				} else {
+					$deleted = false;
+				}
+			}
+			return $deleted ? true : PEAR::raiseError("The expected error you submitted does not exist"); // IMPROVE ME
+		} elseif (!empty($error_code)) {
+			// $error_code comes alone, trying to unset it
+			if ($this->_checkDelExpect($error_code)) {
+				return true;
+			} else {
+				return PEAR::raiseError("The expected error you submitted does not exist"); // IMPROVE ME
+			}
+		} else {
+			// $error_code is empty
+			return PEAR::raiseError("The expected error you submitted is empty"); // IMPROVE ME
+		}
+	}
+
+	// }}}
+	// {{{ raiseError()
+
+	/**
+	 * This method is a wrapper that returns an instance of the
+	 * configured error class with this object's default error
+	 * handling applied.  If the $mode and $options parameters are not
+	 * specified, the object's defaults are used.
+	 *
+	 * @param mixed $message a text error message or a PEAR error object
+	 *
+	 * @param int $code      a numeric error code (it is up to your class
+	 *                  to define these if you want to use codes)
+	 *
+	 * @param int $mode      One of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT,
+	 *                  PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE,
+	 *                  PEAR_ERROR_CALLBACK, PEAR_ERROR_EXCEPTION.
+	 *
+	 * @param mixed $options If $mode is PEAR_ERROR_TRIGGER, this parameter
+	 *                  specifies the PHP-internal error level (one of
+	 *                  E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR).
+	 *                  If $mode is PEAR_ERROR_CALLBACK, this
+	 *                  parameter specifies the callback function or
+	 *                  method.  In other error modes this parameter
+	 *                  is ignored.
+	 *
+	 * @param string $userinfo If you need to pass along for example debug
+	 *                  information, this parameter is meant for that.
+	 *
+	 * @param string $error_class The returned error object will be
+	 *                  instantiated from this class, if specified.
+	 *
+	 * @param bool $skipmsg If true, raiseError will only pass error codes,
+	 *                  the error message parameter will be dropped.
+	 *
+	 * @access public
+	 * @return object   a PEAR error object
+	 * @see PEAR::setErrorHandling
+	 * @since PHP 4.0.5
+	 */
+	function &raiseError($message = null,
+						 $code = null,
+						 $mode = null,
+						 $options = null,
+						 $userinfo = null,
+						 $error_class = null,
+						 $skipmsg = false)
+	{
+		// The error is yet a PEAR error object
+		if (is_object($message)) {
+			$code        = $message->getCode();
+			$userinfo    = $message->getUserInfo();
+			$error_class = $message->getType();
+			$message->error_message_prefix = '';
+			$message     = $message->getMessage();
+		}
+
+		if (isset($this) && isset($this->_expected_errors) && sizeof($this->_expected_errors) > 0 && sizeof($exp = end($this->_expected_errors))) {
+			if ($exp[0] == "*" ||
+				(is_int(reset($exp)) && in_array($code, $exp)) ||
+				(is_string(reset($exp)) && in_array($message, $exp))) {
+				$mode = PEAR_ERROR_RETURN;
+			}
+		}
+		// No mode given, try global ones
+		if ($mode === null) {
+			// Class error handler
+			if (isset($this) && isset($this->_default_error_mode)) {
+				$mode    = $this->_default_error_mode;
+				$options = $this->_default_error_options;
+			// Global error handler
+			} elseif (isset($GLOBALS['_PEAR_default_error_mode'])) {
+				$mode    = $GLOBALS['_PEAR_default_error_mode'];
+				$options = $GLOBALS['_PEAR_default_error_options'];
+			}
+		}
+
+		if ($error_class !== null) {
+			$ec = $error_class;
+		} elseif (isset($this) && isset($this->_error_class)) {
+			$ec = $this->_error_class;
+		} else {
+			$ec = 'PEAR_Error';
+		}
+		if ($skipmsg) {
+			$a = &new $ec($code, $mode, $options, $userinfo);
+			return $a;
+		} else {
+			$a = &new $ec($message, $code, $mode, $options, $userinfo);
+			return $a;
+		}
+	}
+
+	// }}}
+	// {{{ throwError()
+
+	/**
+	 * Simpler form of raiseError with fewer options.  In most cases
+	 * message, code and userinfo are enough.
+	 *
+	 * @param string $message
+	 *
+	 */
+	function &throwError($message = null,
+						 $code = null,
+						 $userinfo = null)
+	{
+		if (isset($this) && is_a($this, 'PEAR')) {
+			$a = &$this->raiseError($message, $code, null, null, $userinfo);
+			return $a;
+		} else {
+			$a = &PEAR::raiseError($message, $code, null, null, $userinfo);
+			return $a;
+		}
+	}
+
+	// }}}
+	function staticPushErrorHandling($mode, $options = null)
+	{
+		$stack = &$GLOBALS['_PEAR_error_handler_stack'];
+		$def_mode    = &$GLOBALS['_PEAR_default_error_mode'];
+		$def_options = &$GLOBALS['_PEAR_default_error_options'];
+		$stack[] = array($def_mode, $def_options);
+		switch ($mode) {
+			case PEAR_ERROR_EXCEPTION:
+			case PEAR_ERROR_RETURN:
+			case PEAR_ERROR_PRINT:
+			case PEAR_ERROR_TRIGGER:
+			case PEAR_ERROR_DIE:
+			case null:
+				$def_mode = $mode;
+				$def_options = $options;
+				break;
+
+			case PEAR_ERROR_CALLBACK:
+				$def_mode = $mode;
+				// class/object method callback
+				if (is_callable($options)) {
+					$def_options = $options;
+				} else {
+					trigger_error("invalid error callback", E_USER_WARNING);
+				}
+				break;
+
+			default:
+				trigger_error("invalid error mode", E_USER_WARNING);
+				break;
+		}
+		$stack[] = array($mode, $options);
+		return true;
+	}
+
+	function staticPopErrorHandling()
+	{
+		$stack = &$GLOBALS['_PEAR_error_handler_stack'];
+		$setmode     = &$GLOBALS['_PEAR_default_error_mode'];
+		$setoptions  = &$GLOBALS['_PEAR_default_error_options'];
+		array_pop($stack);
+		list($mode, $options) = $stack[sizeof($stack) - 1];
+		array_pop($stack);
+		switch ($mode) {
+			case PEAR_ERROR_EXCEPTION:
+			case PEAR_ERROR_RETURN:
+			case PEAR_ERROR_PRINT:
+			case PEAR_ERROR_TRIGGER:
+			case PEAR_ERROR_DIE:
+			case null:
+				$setmode = $mode;
+				$setoptions = $options;
+				break;
+
+			case PEAR_ERROR_CALLBACK:
+				$setmode = $mode;
+				// class/object method callback
+				if (is_callable($options)) {
+					$setoptions = $options;
+				} else {
+					trigger_error("invalid error callback", E_USER_WARNING);
+				}
+				break;
+
+			default:
+				trigger_error("invalid error mode", E_USER_WARNING);
+				break;
+		}
+		return true;
+	}
+
+	// {{{ pushErrorHandling()
+
+	/**
+	 * Push a new error handler on top of the error handler options stack. With this
+	 * you can easily override the actual error handler for some code and restore
+	 * it later with popErrorHandling.
+	 *
+	 * @param mixed $mode (same as setErrorHandling)
+	 * @param mixed $options (same as setErrorHandling)
+	 *
+	 * @return bool Always true
+	 *
+	 * @see PEAR::setErrorHandling
+	 */
+	function pushErrorHandling($mode, $options = null)
+	{
+		$stack = &$GLOBALS['_PEAR_error_handler_stack'];
+		if (isset($this) && is_a($this, 'PEAR')) {
+			$def_mode    = &$this->_default_error_mode;
+			$def_options = &$this->_default_error_options;
+		} else {
+			$def_mode    = &$GLOBALS['_PEAR_default_error_mode'];
+			$def_options = &$GLOBALS['_PEAR_default_error_options'];
+		}
+		$stack[] = array($def_mode, $def_options);
+
+		if (isset($this) && is_a($this, 'PEAR')) {
+			$this->setErrorHandling($mode, $options);
+		} else {
+			PEAR::setErrorHandling($mode, $options);
+		}
+		$stack[] = array($mode, $options);
+		return true;
+	}
+
+	// }}}
+	// {{{ popErrorHandling()
+
+	/**
+	 * Pop the last error handler used
+	 *
+	 * @return bool Always true
+	 *
+	 * @see PEAR::pushErrorHandling
+	 */
+	function popErrorHandling()
+	{
+		$stack = &$GLOBALS['_PEAR_error_handler_stack'];
+		array_pop($stack);
+		list($mode, $options) = $stack[sizeof($stack) - 1];
+		array_pop($stack);
+		if (isset($this) && is_a($this, 'PEAR')) {
+			$this->setErrorHandling($mode, $options);
+		} else {
+			PEAR::setErrorHandling($mode, $options);
+		}
+		return true;
+	}
+
+	// }}}
+	// {{{ loadExtension()
+
+	/**
+	 * OS independant PHP extension load. Remember to take care
+	 * on the correct extension name for case sensitive OSes.
+	 *
+	 * @param string $ext The extension name
+	 * @return bool Success or not on the dl() call
+	 */
+	function loadExtension($ext)
+	{
+		if (!extension_loaded($ext)) {
+			// if either returns true dl() will produce a FATAL error, stop that
+			if ((ini_get('enable_dl') != 1) || (ini_get('safe_mode') == 1)) {
+				return false;
+			}
+			if (OS_WINDOWS) {
+				$suffix = '.dll';
+			} elseif (PHP_OS == 'HP-UX') {
+				$suffix = '.sl';
+			} elseif (PHP_OS == 'AIX') {
+				$suffix = '.a';
+			} elseif (PHP_OS == 'OSX') {
+				$suffix = '.bundle';
+			} else {
+				$suffix = '.so';
+			}
+			return @dl('php_'.$ext.$suffix) || @dl($ext.$suffix);
+		}
+		return true;
+	}
+
+	// }}}
 }
 
 // {{{ _PEAR_call_destructors()
 
 function _PEAR_call_destructors()
 {
-    global $_PEAR_destructor_object_list;
-    if (is_array($_PEAR_destructor_object_list) &&
-        sizeof($_PEAR_destructor_object_list))
-    {
-        reset($_PEAR_destructor_object_list);
-        if (PEAR::getStaticProperty('PEAR', 'destructlifo')) {
-            $_PEAR_destructor_object_list = array_reverse($_PEAR_destructor_object_list);
-        }
-        while (list($k, $objref) = each($_PEAR_destructor_object_list)) {
-            $classname = get_class($objref);
-            while ($classname) {
-                $destructor = "_$classname";
-                if (method_exists($objref, $destructor)) {
-                    $objref->$destructor();
-                    break;
-                } else {
-                    $classname = get_parent_class($classname);
-                }
-            }
-        }
-        // Empty the object list to ensure that destructors are
-        // not called more than once.
-        $_PEAR_destructor_object_list = array();
-    }
-
-    // Now call the shutdown functions
-    if (is_array($GLOBALS['_PEAR_shutdown_funcs']) AND !empty($GLOBALS['_PEAR_shutdown_funcs'])) {
-        foreach ($GLOBALS['_PEAR_shutdown_funcs'] as $value) {
-            call_user_func_array($value[0], $value[1]);
-        }
-    }
+	global $_PEAR_destructor_object_list;
+	if (is_array($_PEAR_destructor_object_list) &&
+		sizeof($_PEAR_destructor_object_list))
+	{
+		reset($_PEAR_destructor_object_list);
+		if (PEAR::getStaticProperty('PEAR', 'destructlifo')) {
+			$_PEAR_destructor_object_list = array_reverse($_PEAR_destructor_object_list);
+		}
+		while (list($k, $objref) = each($_PEAR_destructor_object_list)) {
+			$classname = get_class($objref);
+			while ($classname) {
+				$destructor = "_$classname";
+				if (method_exists($objref, $destructor)) {
+					$objref->$destructor();
+					break;
+				} else {
+					$classname = get_parent_class($classname);
+				}
+			}
+		}
+		// Empty the object list to ensure that destructors are
+		// not called more than once.
+		$_PEAR_destructor_object_list = array();
+	}
+
+	// Now call the shutdown functions
+	if (is_array($GLOBALS['_PEAR_shutdown_funcs']) AND !empty($GLOBALS['_PEAR_shutdown_funcs'])) {
+		foreach ($GLOBALS['_PEAR_shutdown_funcs'] as $value) {
+			call_user_func_array($value[0], $value[1]);
+		}
+	}
 }
 
 // }}}
@@ -821,281 +821,281 @@ 
  */
 class PEAR_Error
 {
-    // {{{ properties
-
-    var $error_message_prefix = '';
-    var $mode                 = PEAR_ERROR_RETURN;
-    var $level                = E_USER_NOTICE;
-    var $code                 = -1;
-    var $message              = '';
-    var $userinfo             = '';
-    var $backtrace            = null;
-
-    // }}}
-    // {{{ constructor
-
-    /**
-     * PEAR_Error constructor
-     *
-     * @param string $message  message
-     *
-     * @param int $code     (optional) error code
-     *
-     * @param int $mode     (optional) error mode, one of: PEAR_ERROR_RETURN,
-     * PEAR_ERROR_PRINT, PEAR_ERROR_DIE, PEAR_ERROR_TRIGGER,
-     * PEAR_ERROR_CALLBACK or PEAR_ERROR_EXCEPTION
-     *
-     * @param mixed $options   (optional) error level, _OR_ in the case of
-     * PEAR_ERROR_CALLBACK, the callback function or object/method
-     * tuple.
-     *
-     * @param string $userinfo (optional) additional user/debug info
-     *
-     * @access public
-     *
-     */
-    function PEAR_Error($message = 'unknown error', $code = null,
-                        $mode = null, $options = null, $userinfo = null)
-    {
-        if ($mode === null) {
-            $mode = PEAR_ERROR_RETURN;
-        }
-        $this->message   = $message;
-        $this->code      = $code;
-        $this->mode      = $mode;
-        $this->userinfo  = $userinfo;
-        if (!PEAR::getStaticProperty('PEAR_Error', 'skiptrace')) {
-            $this->backtrace = debug_backtrace();
-            if (isset($this->backtrace[0]) && isset($this->backtrace[0]['object'])) {
-                unset($this->backtrace[0]['object']);
-            }
-        }
-        if ($mode & PEAR_ERROR_CALLBACK) {
-            $this->level = E_USER_NOTICE;
-            $this->callback = $options;
-        } else {
-            if ($options === null) {
-                $options = E_USER_NOTICE;
-            }
-            $this->level = $options;
-            $this->callback = null;
-        }
-        if ($this->mode & PEAR_ERROR_PRINT) {
-            if (is_null($options) || is_int($options)) {
-                $format = "%s";
-            } else {
-                $format = $options;
-            }
-            printf($format, $this->getMessage());
-        }
-        if ($this->mode & PEAR_ERROR_TRIGGER) {
-            trigger_error($this->getMessage(), $this->level);
-        }
-        if ($this->mode & PEAR_ERROR_DIE) {
-            $msg = $this->getMessage();
-            if (is_null($options) || is_int($options)) {
-                $format = "%s";
-                if (substr($msg, -1) != "\n") {
-                    $msg .= "\n";
-                }
-            } else {
-                $format = $options;
-            }
-            die(sprintf($format, $msg));
-        }
-        if ($this->mode & PEAR_ERROR_CALLBACK) {
-            if (is_callable($this->callback)) {
-                call_user_func($this->callback, $this);
-            }
-        }
-        if ($this->mode & PEAR_ERROR_EXCEPTION) {
-            trigger_error("PEAR_ERROR_EXCEPTION is obsolete, use class PEAR_Exception for exceptions", E_USER_WARNING);
-            eval('$e = new Exception($this->message, $this->code);throw($e);');
-        }
-    }
-
-    // }}}
-    // {{{ getMode()
-
-    /**
-     * Get the error mode from an error object.
-     *
-     * @return int error mode
-     * @access public
-     */
-    function getMode() {
-        return $this->mode;
-    }
-
-    // }}}
-    // {{{ getCallback()
-
-    /**
-     * Get the callback function/method from an error object.
-     *
-     * @return mixed callback function or object/method array
-     * @access public
-     */
-    function getCallback() {
-        return $this->callback;
-    }
-
-    // }}}
-    // {{{ getMessage()
-
-
-    /**
-     * Get the error message from an error object.
-     *
-     * @return  string  full error message
-     * @access public
-     */
-    function getMessage()
-    {
-        return ($this->error_message_prefix . $this->message);
-    }
-
-
-    // }}}
-    // {{{ getCode()
-
-    /**
-     * Get error code from an error object
-     *
-     * @return int error code
-     * @access public
-     */
-     function getCode()
-     {
-        return $this->code;
-     }
-
-    // }}}
-    // {{{ getType()
-
-    /**
-     * Get the name of this error/exception.
-     *
-     * @return string error/exception name (type)
-     * @access public
-     */
-    function getType()
-    {
-        return get_class($this);
-    }
-
-    // }}}
-    // {{{ getUserInfo()
-
-    /**
-     * Get additional user-supplied information.
-     *
-     * @return string user-supplied information
-     * @access public
-     */
-    function getUserInfo()
-    {
-        return $this->userinfo;
-    }
-
-    // }}}
-    // {{{ getDebugInfo()
-
-    /**
-     * Get additional debug information supplied by the application.
-     *
-     * @return string debug information
-     * @access public
-     */
-    function getDebugInfo()
-    {
-        return $this->getUserInfo();
-    }
-
-    // }}}
-    // {{{ getBacktrace()
-
-    /**
-     * Get the call backtrace from where the error was generated.
-     * Supported with PHP 4.3.0 or newer.
-     *
-     * @param int $frame (optional) what frame to fetch
-     * @return array Backtrace, or NULL if not available.
-     * @access public
-     */
-    function getBacktrace($frame = null)
-    {
-        if (defined('PEAR_IGNORE_BACKTRACE')) {
-            return null;
-        }
-        if ($frame === null) {
-            return $this->backtrace;
-        }
-        return $this->backtrace[$frame];
-    }
-
-    // }}}
-    // {{{ addUserInfo()
-
-    function addUserInfo($info)
-    {
-        if (empty($this->userinfo)) {
-            $this->userinfo = $info;
-        } else {
-            $this->userinfo .= " ** $info";
-        }
-    }
-
-    // }}}
-    // {{{ toString()
-
-    /**
-     * Make a string representation of this object.
-     *
-     * @return string a string with an object summary
-     * @access public
-     */
-    function toString() {
-        $modes = array();
-        $levels = array(E_USER_NOTICE  => 'notice',
-                        E_USER_WARNING => 'warning',
-                        E_USER_ERROR   => 'error');
-        if ($this->mode & PEAR_ERROR_CALLBACK) {
-            if (is_array($this->callback)) {
-                $callback = (is_object($this->callback[0]) ?
-                    strtolower(get_class($this->callback[0])) :
-                    $this->callback[0]) . '::' .
-                    $this->callback[1];
-            } else {
-                $callback = $this->callback;
-            }
-            return sprintf('[%s: message="%s" code=%d mode=callback '.
-                           'callback=%s prefix="%s" info="%s"]',
-                           strtolower(get_class($this)), $this->message, $this->code,
-                           $callback, $this->error_message_prefix,
-                           $this->userinfo);
-        }
-        if ($this->mode & PEAR_ERROR_PRINT) {
-            $modes[] = 'print';
-        }
-        if ($this->mode & PEAR_ERROR_TRIGGER) {
-            $modes[] = 'trigger';
-        }
-        if ($this->mode & PEAR_ERROR_DIE) {
-            $modes[] = 'die';
-        }
-        if ($this->mode & PEAR_ERROR_RETURN) {
-            $modes[] = 'return';
-        }
-        return sprintf('[%s: message="%s" code=%d mode=%s level=%s '.
-                       'prefix="%s" info="%s"]',
-                       strtolower(get_class($this)), $this->message, $this->code,
-                       implode("|", $modes), $levels[$this->level],
-                       $this->error_message_prefix,
-                       $this->userinfo);
-    }
-
-    // }}}
+	// {{{ properties
+
+	var $error_message_prefix = '';
+	var $mode                 = PEAR_ERROR_RETURN;
+	var $level                = E_USER_NOTICE;
+	var $code                 = -1;
+	var $message              = '';
+	var $userinfo             = '';
+	var $backtrace            = null;
+
+	// }}}
+	// {{{ constructor
+
+	/**
+	 * PEAR_Error constructor
+	 *
+	 * @param string $message  message
+	 *
+	 * @param int $code     (optional) error code
+	 *
+	 * @param int $mode     (optional) error mode, one of: PEAR_ERROR_RETURN,
+	 * PEAR_ERROR_PRINT, PEAR_ERROR_DIE, PEAR_ERROR_TRIGGER,
+	 * PEAR_ERROR_CALLBACK or PEAR_ERROR_EXCEPTION
+	 *
+	 * @param mixed $options   (optional) error level, _OR_ in the case of
+	 * PEAR_ERROR_CALLBACK, the callback function or object/method
+	 * tuple.
+	 *
+	 * @param string $userinfo (optional) additional user/debug info
+	 *
+	 * @access public
+	 *
+	 */
+	function PEAR_Error($message = 'unknown error', $code = null,
+						$mode = null, $options = null, $userinfo = null)
+	{
+		if ($mode === null) {
+			$mode = PEAR_ERROR_RETURN;
+		}
+		$this->message   = $message;
+		$this->code      = $code;
+		$this->mode      = $mode;
+		$this->userinfo  = $userinfo;
+		if (!PEAR::getStaticProperty('PEAR_Error', 'skiptrace')) {
+			$this->backtrace = debug_backtrace();
+			if (isset($this->backtrace[0]) && isset($this->backtrace[0]['object'])) {
+				unset($this->backtrace[0]['object']);
+			}
+		}
+		if ($mode & PEAR_ERROR_CALLBACK) {
+			$this->level = E_USER_NOTICE;
+			$this->callback = $options;
+		} else {
+			if ($options === null) {
+				$options = E_USER_NOTICE;
+			}
+			$this->level = $options;
+			$this->callback = null;
+		}
+		if ($this->mode & PEAR_ERROR_PRINT) {
+			if (is_null($options) || is_int($options)) {
+				$format = "%s";
+			} else {
+				$format = $options;
+			}
+			printf($format, $this->getMessage());
+		}
+		if ($this->mode & PEAR_ERROR_TRIGGER) {
+			trigger_error($this->getMessage(), $this->level);
+		}
+		if ($this->mode & PEAR_ERROR_DIE) {
+			$msg = $this->getMessage();
+			if (is_null($options) || is_int($options)) {
+				$format = "%s";
+				if (substr($msg, -1) != "\n") {
+					$msg .= "\n";
+				}
+			} else {
+				$format = $options;
+			}
+			die(sprintf($format, $msg));
+		}
+		if ($this->mode & PEAR_ERROR_CALLBACK) {
+			if (is_callable($this->callback)) {
+				call_user_func($this->callback, $this);
+			}
+		}
+		if ($this->mode & PEAR_ERROR_EXCEPTION) {
+			trigger_error("PEAR_ERROR_EXCEPTION is obsolete, use class PEAR_Exception for exceptions", E_USER_WARNING);
+			eval('$e = new Exception($this->message, $this->code);throw($e);');
+		}
+	}
+
+	// }}}
+	// {{{ getMode()
+
+	/**
+	 * Get the error mode from an error object.
+	 *
+	 * @return int error mode
+	 * @access public
+	 */
+	function getMode() {
+		return $this->mode;
+	}
+
+	// }}}
+	// {{{ getCallback()
+
+	/**
+	 * Get the callback function/method from an error object.
+	 *
+	 * @return mixed callback function or object/method array
+	 * @access public
+	 */
+	function getCallback() {
+		return $this->callback;
+	}
+
+	// }}}
+	// {{{ getMessage()
+
+
+	/**
+	 * Get the error message from an error object.
+	 *
+	 * @return  string  full error message
+	 * @access public
+	 */
+	function getMessage()
+	{
+		return ($this->error_message_prefix . $this->message);
+	}
+
+
+	// }}}
+	// {{{ getCode()
+
+	/**
+	 * Get error code from an error object
+	 *
+	 * @return int error code
+	 * @access public
+	 */
+	 function getCode()
+	 {
+		return $this->code;
+	 }
+
+	// }}}
+	// {{{ getType()
+
+	/**
+	 * Get the name of this error/exception.
+	 *
+	 * @return string error/exception name (type)
+	 * @access public
+	 */
+	function getType()
+	{
+		return get_class($this);
+	}
+
+	// }}}
+	// {{{ getUserInfo()
+
+	/**
+	 * Get additional user-supplied information.
+	 *
+	 * @return string user-supplied information
+	 * @access public
+	 */
+	function getUserInfo()
+	{
+		return $this->userinfo;
+	}
+
+	// }}}
+	// {{{ getDebugInfo()
+
+	/**
+	 * Get additional debug information supplied by the application.
+	 *
+	 * @return string debug information
+	 * @access public
+	 */
+	function getDebugInfo()
+	{
+		return $this->getUserInfo();
+	}
+
+	// }}}
+	// {{{ getBacktrace()
+
+	/**
+	 * Get the call backtrace from where the error was generated.
+	 * Supported with PHP 4.3.0 or newer.
+	 *
+	 * @param int $frame (optional) what frame to fetch
+	 * @return array Backtrace, or NULL if not available.
+	 * @access public
+	 */
+	function getBacktrace($frame = null)
+	{
+		if (defined('PEAR_IGNORE_BACKTRACE')) {
+			return null;
+		}
+		if ($frame === null) {
+			return $this->backtrace;
+		}
+		return $this->backtrace[$frame];
+	}
+
+	// }}}
+	// {{{ addUserInfo()
+
+	function addUserInfo($info)
+	{
+		if (empty($this->userinfo)) {
+			$this->userinfo = $info;
+		} else {
+			$this->userinfo .= " ** $info";
+		}
+	}
+
+	// }}}
+	// {{{ toString()
+
+	/**
+	 * Make a string representation of this object.
+	 *
+	 * @return string a string with an object summary
+	 * @access public
+	 */
+	function toString() {
+		$modes = array();
+		$levels = array(E_USER_NOTICE  => 'notice',
+						E_USER_WARNING => 'warning',
+						E_USER_ERROR   => 'error');
+		if ($this->mode & PEAR_ERROR_CALLBACK) {
+			if (is_array($this->callback)) {
+				$callback = (is_object($this->callback[0]) ?
+					strtolower(get_class($this->callback[0])) :
+					$this->callback[0]) . '::' .
+					$this->callback[1];
+			} else {
+				$callback = $this->callback;
+			}
+			return sprintf('[%s: message="%s" code=%d mode=callback '.
+						   'callback=%s prefix="%s" info="%s"]',
+						   strtolower(get_class($this)), $this->message, $this->code,
+						   $callback, $this->error_message_prefix,
+						   $this->userinfo);
+		}
+		if ($this->mode & PEAR_ERROR_PRINT) {
+			$modes[] = 'print';
+		}
+		if ($this->mode & PEAR_ERROR_TRIGGER) {
+			$modes[] = 'trigger';
+		}
+		if ($this->mode & PEAR_ERROR_DIE) {
+			$modes[] = 'die';
+		}
+		if ($this->mode & PEAR_ERROR_RETURN) {
+			$modes[] = 'return';
+		}
+		return sprintf('[%s: message="%s" code=%d mode=%s level=%s '.
+					   'prefix="%s" info="%s"]',
+					   strtolower(get_class($this)), $this->message, $this->code,
+					   implode("|", $modes), $levels[$this->level],
+					   $this->error_message_prefix,
+					   $this->userinfo);
+	}
+
+	// }}}
 }
 
 /*

Spacing +13 added lines, -14 removed lines

@@ -28,11 +28,11 @@ 
 /**#@+
  * ERROR constants
  */
-define('PEAR_ERROR_RETURN',     1);
-define('PEAR_ERROR_PRINT',      2);
-define('PEAR_ERROR_TRIGGER',    4);
-define('PEAR_ERROR_DIE',        8);
-define('PEAR_ERROR_CALLBACK',  16);
+define('PEAR_ERROR_RETURN', 1);
+define('PEAR_ERROR_PRINT', 2);
+define('PEAR_ERROR_TRIGGER', 4);
+define('PEAR_ERROR_DIE', 8);
+define('PEAR_ERROR_CALLBACK', 16);
 /**
  * WARNING: obsolete
  * @deprecated
@@ -44,12 +44,12 @@ 
 
 if (substr(PHP_OS, 0, 3) == 'WIN') {
     define('OS_WINDOWS', true);
-    define('OS_UNIX',    false);
-    define('PEAR_OS',    'Windows');
+    define('OS_UNIX', false);
+    define('PEAR_OS', 'Windows');
 } else {
     define('OS_WINDOWS', false);
-    define('OS_UNIX',    true);
-    define('PEAR_OS',    'Unix'); // blatant assumption
+    define('OS_UNIX', true);
+    define('PEAR_OS', 'Unix'); // blatant assumption
 }
 
 // instant backwards compatibility
@@ -460,9 +460,9 @@ 
             // $error_code is a non-empty array here;
             // we walk through it trying to unset all
             // values
-            foreach($error_code as $key => $error) {
+            foreach ($error_code as $key => $error) {
                 if ($this->_checkDelExpect($error)) {
-                    $deleted =  true;
+                    $deleted = true;
                 } else {
                     $deleted = false;
                 }
@@ -952,7 +952,7 @@ 
      */
     function getMessage()
     {
-        return ($this->error_message_prefix . $this->message);
+        return ($this->error_message_prefix.$this->message);
     }
 
 
@@ -1063,8 +1063,7 @@ 
         if ($this->mode & PEAR_ERROR_CALLBACK) {
             if (is_array($this->callback)) {
                 $callback = (is_object($this->callback[0]) ?
-                    strtolower(get_class($this->callback[0])) :
-                    $this->callback[0]) . '::' .
+                    strtolower(get_class($this->callback[0])) : $this->callback[0]).'::'.
                     $this->callback[1];
             } else {
                 $callback = $this->callback;

libs/idna_convert/example.php

Indentation +9 added lines, -9 removed lines

@@ -8,24 +8,24 @@
 
 $version_select = '<select size="1" name="idn_version"><option value="2003">IDNA 2003</option><option value="2008"';
 if ($idn_version == 2008) {
-    $version_select .= ' selected="selected"';
+	$version_select .= ' selected="selected"';
 }
 $version_select .= '>IDNA 2008</option></select>';
 
 if (isset($_REQUEST['encode'])) {
-    $decoded = isset($_REQUEST['decoded']) ? stripslashes($_REQUEST['decoded']) : '';
-    $encoded = $IDN->encode($decoded);
+	$decoded = isset($_REQUEST['decoded']) ? stripslashes($_REQUEST['decoded']) : '';
+	$encoded = $IDN->encode($decoded);
 }
 if (isset($_REQUEST['decode'])) {
-    $encoded = isset($_REQUEST['encoded']) ? stripslashes($_REQUEST['encoded']) : '';
-    $decoded = $IDN->decode($encoded);
+	$encoded = isset($_REQUEST['encoded']) ? stripslashes($_REQUEST['encoded']) : '';
+	$decoded = $IDN->decode($encoded);
 }
 $lang = 'en';
 if (isset($_REQUEST['lang'])) {
-    if ('de' == $_REQUEST['lang'] || 'en' == $_REQUEST['lang']) {
-        $lang = $_REQUEST['lang'];
-        $add .= '<input type="hidden" name="lang" value="'.$lang.'" />'."\n";
-    }
+	if ('de' == $_REQUEST['lang'] || 'en' == $_REQUEST['lang']) {
+		$lang = $_REQUEST['lang'];
+		$add .= '<input type="hidden" name="lang" value="'.$lang.'" />'."\n";
+	}
 }
 ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

libs/idna_convert/transcode_wrapper.php

Braces +27 added lines, -9 removed lines

@@ -30,15 +30,21 @@ 
     }
     if (function_exists('mb_convert_encoding')) {
         $conv = @mb_convert_encoding($string, 'UTF-8', strtoupper($encoding));
-        if ($conv) return $conv;
+        if ($conv) {
+        	return $conv;
+        }
     }
     if (function_exists('iconv')) {
         $conv = @iconv(strtoupper($encoding), 'UTF-8', $string);
-        if ($conv) return $conv;
+        if ($conv) {
+        	return $conv;
+        }
     }
     if (function_exists('libiconv')) {
         $conv = @libiconv(strtoupper($encoding), 'UTF-8', $string);
-        if ($conv) return $conv;
+        if ($conv) {
+        	return $conv;
+        }
     }
     return $safe;
 }
@@ -55,7 +61,9 @@ 
 function decode_utf8($string = '', $encoding = 'iso-8859-1', $safe_mode = false)
 {
     $safe = ($safe_mode) ? $string : false;
-    if (!$encoding) $encoding = 'ISO-8859-1';
+    if (!$encoding) {
+    	$encoding = 'ISO-8859-1';
+    }
     if (strtoupper($encoding) == 'UTF-8' || strtoupper($encoding) == 'UTF8') {
         return $string;
     } elseif (strtoupper($encoding) == 'ISO-8859-1') {
@@ -67,15 +75,21 @@ 
     }
     if (function_exists('mb_convert_encoding')) {
         $conv = @mb_convert_encoding($string, strtoupper($encoding), 'UTF-8');
-        if ($conv) return $conv;
+        if ($conv) {
+        	return $conv;
+        }
     }
     if (function_exists('iconv')) {
         $conv = @iconv('UTF-8', strtoupper($encoding), $string);
-        if ($conv) return $conv;
+        if ($conv) {
+        	return $conv;
+        }
     }
     if (function_exists('libiconv')) {
         $conv = @libiconv('UTF-8', strtoupper($encoding), $string);
-        if ($conv) return $conv;
+        if ($conv) {
+        	return $conv;
+        }
     }
     return $safe;
 }
@@ -89,7 +103,9 @@ 
  */
 function map_w1252_iso8859_1($string = '')
 {
-    if ($string == '') return '';
+    if ($string == '') {
+    	return '';
+    }
     $return = '';
     for ($i = 0; $i < strlen($string); ++$i) {
         $c = ord($string{$i});
@@ -116,7 +132,9 @@ 
  */
 function map_iso8859_1_w1252($string = '')
 {
-    if ($string == '') return '';
+    if ($string == '') {
+    	return '';
+    }
     $return = '';
     for ($i = 0; $i < strlen($string); ++$i) {
         $c = ord($string{$i});

Indentation +79 added lines, -79 removed lines

@@ -18,29 +18,29 @@ 
  */
 function encode_utf8($string = '', $encoding = 'iso-8859-1', $safe_mode = false)
 {
-    $safe = ($safe_mode) ? $string : false;
-    if (strtoupper($encoding) == 'UTF-8' || strtoupper($encoding) == 'UTF8') {
-        return $string;
-    } elseif (strtoupper($encoding) == 'ISO-8859-1') {
-        return utf8_encode($string);
-    } elseif (strtoupper($encoding) == 'WINDOWS-1252') {
-        return utf8_encode(map_w1252_iso8859_1($string));
-    } elseif (strtoupper($encoding) == 'UNICODE-1-1-UTF-7') {
-        $encoding = 'utf-7';
-    }
-    if (function_exists('mb_convert_encoding')) {
-        $conv = @mb_convert_encoding($string, 'UTF-8', strtoupper($encoding));
-        if ($conv) return $conv;
-    }
-    if (function_exists('iconv')) {
-        $conv = @iconv(strtoupper($encoding), 'UTF-8', $string);
-        if ($conv) return $conv;
-    }
-    if (function_exists('libiconv')) {
-        $conv = @libiconv(strtoupper($encoding), 'UTF-8', $string);
-        if ($conv) return $conv;
-    }
-    return $safe;
+	$safe = ($safe_mode) ? $string : false;
+	if (strtoupper($encoding) == 'UTF-8' || strtoupper($encoding) == 'UTF8') {
+		return $string;
+	} elseif (strtoupper($encoding) == 'ISO-8859-1') {
+		return utf8_encode($string);
+	} elseif (strtoupper($encoding) == 'WINDOWS-1252') {
+		return utf8_encode(map_w1252_iso8859_1($string));
+	} elseif (strtoupper($encoding) == 'UNICODE-1-1-UTF-7') {
+		$encoding = 'utf-7';
+	}
+	if (function_exists('mb_convert_encoding')) {
+		$conv = @mb_convert_encoding($string, 'UTF-8', strtoupper($encoding));
+		if ($conv) return $conv;
+	}
+	if (function_exists('iconv')) {
+		$conv = @iconv(strtoupper($encoding), 'UTF-8', $string);
+		if ($conv) return $conv;
+	}
+	if (function_exists('libiconv')) {
+		$conv = @libiconv(strtoupper($encoding), 'UTF-8', $string);
+		if ($conv) return $conv;
+	}
+	return $safe;
 }
 
 /**
@@ -54,30 +54,30 @@ 
  */
 function decode_utf8($string = '', $encoding = 'iso-8859-1', $safe_mode = false)
 {
-    $safe = ($safe_mode) ? $string : false;
-    if (!$encoding) $encoding = 'ISO-8859-1';
-    if (strtoupper($encoding) == 'UTF-8' || strtoupper($encoding) == 'UTF8') {
-        return $string;
-    } elseif (strtoupper($encoding) == 'ISO-8859-1') {
-        return utf8_decode($string);
-    } elseif (strtoupper($encoding) == 'WINDOWS-1252') {
-        return map_iso8859_1_w1252(utf8_decode($string));
-    } elseif (strtoupper($encoding) == 'UNICODE-1-1-UTF-7') {
-        $encoding = 'utf-7';
-    }
-    if (function_exists('mb_convert_encoding')) {
-        $conv = @mb_convert_encoding($string, strtoupper($encoding), 'UTF-8');
-        if ($conv) return $conv;
-    }
-    if (function_exists('iconv')) {
-        $conv = @iconv('UTF-8', strtoupper($encoding), $string);
-        if ($conv) return $conv;
-    }
-    if (function_exists('libiconv')) {
-        $conv = @libiconv('UTF-8', strtoupper($encoding), $string);
-        if ($conv) return $conv;
-    }
-    return $safe;
+	$safe = ($safe_mode) ? $string : false;
+	if (!$encoding) $encoding = 'ISO-8859-1';
+	if (strtoupper($encoding) == 'UTF-8' || strtoupper($encoding) == 'UTF8') {
+		return $string;
+	} elseif (strtoupper($encoding) == 'ISO-8859-1') {
+		return utf8_decode($string);
+	} elseif (strtoupper($encoding) == 'WINDOWS-1252') {
+		return map_iso8859_1_w1252(utf8_decode($string));
+	} elseif (strtoupper($encoding) == 'UNICODE-1-1-UTF-7') {
+		$encoding = 'utf-7';
+	}
+	if (function_exists('mb_convert_encoding')) {
+		$conv = @mb_convert_encoding($string, strtoupper($encoding), 'UTF-8');
+		if ($conv) return $conv;
+	}
+	if (function_exists('iconv')) {
+		$conv = @iconv('UTF-8', strtoupper($encoding), $string);
+		if ($conv) return $conv;
+	}
+	if (function_exists('libiconv')) {
+		$conv = @libiconv('UTF-8', strtoupper($encoding), $string);
+		if ($conv) return $conv;
+	}
+	return $safe;
 }
 
 /**
@@ -89,22 +89,22 @@ 
  */
 function map_w1252_iso8859_1($string = '')
 {
-    if ($string == '') return '';
-    $return = '';
-    for ($i = 0; $i < strlen($string); ++$i) {
-        $c = ord($string{$i});
-        switch ($c) {
-            case 129: $return .= chr(252); break;
-            case 132: $return .= chr(228); break;
-            case 142: $return .= chr(196); break;
-            case 148: $return .= chr(246); break;
-            case 153: $return .= chr(214); break;
-            case 154: $return .= chr(220); break;
-            case 225: $return .= chr(223); break;
-            default: $return .= chr($c); break;
-        }
-    }
-    return $return;
+	if ($string == '') return '';
+	$return = '';
+	for ($i = 0; $i < strlen($string); ++$i) {
+		$c = ord($string{$i});
+		switch ($c) {
+			case 129: $return .= chr(252); break;
+			case 132: $return .= chr(228); break;
+			case 142: $return .= chr(196); break;
+			case 148: $return .= chr(246); break;
+			case 153: $return .= chr(214); break;
+			case 154: $return .= chr(220); break;
+			case 225: $return .= chr(223); break;
+			default: $return .= chr($c); break;
+		}
+	}
+	return $return;
 }
 
 /**
@@ -116,22 +116,22 @@ 
  */
 function map_iso8859_1_w1252($string = '')
 {
-    if ($string == '') return '';
-    $return = '';
-    for ($i = 0; $i < strlen($string); ++$i) {
-        $c = ord($string{$i});
-        switch ($c) {
-            case 196: $return .= chr(142); break;
-            case 214: $return .= chr(153); break;
-            case 220: $return .= chr(154); break;
-            case 223: $return .= chr(225); break;
-            case 228: $return .= chr(132); break;
-            case 246: $return .= chr(148); break;
-            case 252: $return .= chr(129); break;
-            default: $return .= chr($c); break;
-        }
-    }
-    return $return;
+	if ($string == '') return '';
+	$return = '';
+	for ($i = 0; $i < strlen($string); ++$i) {
+		$c = ord($string{$i});
+		switch ($c) {
+			case 196: $return .= chr(142); break;
+			case 214: $return .= chr(153); break;
+			case 220: $return .= chr(154); break;
+			case 223: $return .= chr(225); break;
+			case 228: $return .= chr(132); break;
+			case 246: $return .= chr(148); break;
+			case 252: $return .= chr(129); break;
+			default: $return .= chr($c); break;
+		}
+	}
+	return $return;
 }
 
 ?>
\ No newline at end of file

libs/idna_convert/uctc.php

Indentation +266 added lines, -266 removed lines

@@ -16,285 +16,285 @@
  * @version 0.0.6 2009-05-10
  */
 class uctc {
-    private static $mechs = array('ucs4', /*'ucs4le', 'ucs4be', */'ucs4array', /*'utf16', 'utf16le', 'utf16be', */'utf8', 'utf7', 'utf7imap');
-    private static $allow_overlong = false;
-    private static $safe_mode;
-    private static $safe_char;
+	private static $mechs = array('ucs4', /*'ucs4le', 'ucs4be', */'ucs4array', /*'utf16', 'utf16le', 'utf16be', */'utf8', 'utf7', 'utf7imap');
+	private static $allow_overlong = false;
+	private static $safe_mode;
+	private static $safe_char;
 
-    /**
-     * The actual conversion routine
-     *
-     * @param mixed $data  The data to convert, usually a string, array when converting from UCS-4 array
-     * @param string $from  Original encoding of the data
-     * @param string $to  Target encoding of the data
-     * @param bool $safe_mode  SafeMode tries to correct invalid codepoints
-     * @return mixed  False on failure, String or array on success, depending on target encoding
-     * @access public
-     * @since 0.0.1
-     */
-    public static function convert($data, $from, $to, $safe_mode = false, $safe_char = 0xFFFC)
-    {
-        self::$safe_mode = ($safe_mode) ? true : false;
-        self::$safe_char = ($safe_char) ? $safe_char : 0xFFFC;
-        if (self::$safe_mode) self::$allow_overlong = true;
-        if (!in_array($from, self::$mechs)) throw new Exception('Invalid input format specified');
-        if (!in_array($to, self::$mechs)) throw new Exception('Invalid output format specified');
-        if ($from != 'ucs4array') eval('$data = self::'.$from.'_ucs4array($data);');
-        if ($to != 'ucs4array') eval('$data = self::ucs4array_'.$to.'($data);');
-        return $data;
-    }
+	/**
+	 * The actual conversion routine
+	 *
+	 * @param mixed $data  The data to convert, usually a string, array when converting from UCS-4 array
+	 * @param string $from  Original encoding of the data
+	 * @param string $to  Target encoding of the data
+	 * @param bool $safe_mode  SafeMode tries to correct invalid codepoints
+	 * @return mixed  False on failure, String or array on success, depending on target encoding
+	 * @access public
+	 * @since 0.0.1
+	 */
+	public static function convert($data, $from, $to, $safe_mode = false, $safe_char = 0xFFFC)
+	{
+		self::$safe_mode = ($safe_mode) ? true : false;
+		self::$safe_char = ($safe_char) ? $safe_char : 0xFFFC;
+		if (self::$safe_mode) self::$allow_overlong = true;
+		if (!in_array($from, self::$mechs)) throw new Exception('Invalid input format specified');
+		if (!in_array($to, self::$mechs)) throw new Exception('Invalid output format specified');
+		if ($from != 'ucs4array') eval('$data = self::'.$from.'_ucs4array($data);');
+		if ($to != 'ucs4array') eval('$data = self::ucs4array_'.$to.'($data);');
+		return $data;
+	}
 
-    /**
-     * This converts an UTF-8 encoded string to its UCS-4 representation
-     *
-     * @param string $input  The UTF-8 string to convert
-     * @return array  Array of 32bit values representing each codepoint
-     * @access private
-     */
-    private static function utf8_ucs4array($input)
-    {
-        $output = array();
-        $out_len = 0;
-        $inp_len = strlen($input);
-        $mode = 'next';
-        $test = 'none';
-        for ($k = 0; $k < $inp_len; ++$k) {
-            $v = ord($input{$k}); // Extract byte from input string
+	/**
+	 * This converts an UTF-8 encoded string to its UCS-4 representation
+	 *
+	 * @param string $input  The UTF-8 string to convert
+	 * @return array  Array of 32bit values representing each codepoint
+	 * @access private
+	 */
+	private static function utf8_ucs4array($input)
+	{
+		$output = array();
+		$out_len = 0;
+		$inp_len = strlen($input);
+		$mode = 'next';
+		$test = 'none';
+		for ($k = 0; $k < $inp_len; ++$k) {
+			$v = ord($input{$k}); // Extract byte from input string
 
-            if ($v < 128) { // We found an ASCII char - put into stirng as is
-                $output[$out_len] = $v;
-                ++$out_len;
-                if ('add' == $mode) {
-                    if (self::$safe_mode) {
-                        $output[$out_len-2] = self::$safe_char;
-                        $mode = 'next';
-                    } else {
-                        throw new Exception('Conversion from UTF-8 to UCS-4 failed: malformed input at byte '.$k);
-                    }
-                }
-                continue;
-            }
-            if ('next' == $mode) { // Try to find the next start byte; determine the width of the Unicode char
-                $start_byte = $v;
-                $mode = 'add';
-                $test = 'range';
-                if ($v >> 5 == 6) { // &110xxxxx 10xxxxx
-                    $next_byte = 0; // Tells, how many times subsequent bitmasks must rotate 6bits to the left
-                    $v = ($v - 192) << 6;
-                } elseif ($v >> 4 == 14) { // &1110xxxx 10xxxxxx 10xxxxxx
-                    $next_byte = 1;
-                    $v = ($v - 224) << 12;
-                } elseif ($v >> 3 == 30) { // &11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-                    $next_byte = 2;
-                    $v = ($v - 240) << 18;
-                } elseif (self::$safe_mode) {
-                    $mode = 'next';
-                    $output[$out_len] = self::$safe_char;
-                    ++$out_len;
-                    continue;
-                } else {
-                    throw new Exception('This might be UTF-8, but I don\'t understand it at byte '.$k);
-                }
-                if ($inp_len-$k-$next_byte < 2) {
-                    $output[$out_len] = self::$safe_char;
-                    $mode = 'no';
-                    continue;
-                }
+			if ($v < 128) { // We found an ASCII char - put into stirng as is
+				$output[$out_len] = $v;
+				++$out_len;
+				if ('add' == $mode) {
+					if (self::$safe_mode) {
+						$output[$out_len-2] = self::$safe_char;
+						$mode = 'next';
+					} else {
+						throw new Exception('Conversion from UTF-8 to UCS-4 failed: malformed input at byte '.$k);
+					}
+				}
+				continue;
+			}
+			if ('next' == $mode) { // Try to find the next start byte; determine the width of the Unicode char
+				$start_byte = $v;
+				$mode = 'add';
+				$test = 'range';
+				if ($v >> 5 == 6) { // &110xxxxx 10xxxxx
+					$next_byte = 0; // Tells, how many times subsequent bitmasks must rotate 6bits to the left
+					$v = ($v - 192) << 6;
+				} elseif ($v >> 4 == 14) { // &1110xxxx 10xxxxxx 10xxxxxx
+					$next_byte = 1;
+					$v = ($v - 224) << 12;
+				} elseif ($v >> 3 == 30) { // &11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+					$next_byte = 2;
+					$v = ($v - 240) << 18;
+				} elseif (self::$safe_mode) {
+					$mode = 'next';
+					$output[$out_len] = self::$safe_char;
+					++$out_len;
+					continue;
+				} else {
+					throw new Exception('This might be UTF-8, but I don\'t understand it at byte '.$k);
+				}
+				if ($inp_len-$k-$next_byte < 2) {
+					$output[$out_len] = self::$safe_char;
+					$mode = 'no';
+					continue;
+				}
 
-                if ('add' == $mode) {
-                    $output[$out_len] = (int) $v;
-                    ++$out_len;
-                    continue;
-                }
-            }
-            if ('add' == $mode) {
-                if (!self::$allow_overlong && $test == 'range') {
-                    $test = 'none';
-                    if (($v < 0xA0 && $start_byte == 0xE0) || ($v < 0x90 && $start_byte == 0xF0) || ($v > 0x8F && $start_byte == 0xF4)) {
-                        throw new Exception('Bogus UTF-8 character detected (out of legal range) at byte '.$k);
-                    }
-                }
-                if ($v >> 6 == 2) { // Bit mask must be 10xxxxxx
-                    $v = ($v-128) << ($next_byte*6);
-                    $output[($out_len-1)] += $v;
-                    --$next_byte;
-                } else {
-                    if (self::$safe_mode) {
-                        $output[$out_len-1] = ord(self::$safe_char);
-                        $k--;
-                        $mode = 'next';
-                        continue;
-                    } else {
-                        throw new Exception('Conversion from UTF-8 to UCS-4 failed: malformed input at byte '.$k);
-                    }
-                }
-                if ($next_byte < 0) {
-                    $mode = 'next';
-                }
-            }
-        } // for
-        return $output;
-    }
+				if ('add' == $mode) {
+					$output[$out_len] = (int) $v;
+					++$out_len;
+					continue;
+				}
+			}
+			if ('add' == $mode) {
+				if (!self::$allow_overlong && $test == 'range') {
+					$test = 'none';
+					if (($v < 0xA0 && $start_byte == 0xE0) || ($v < 0x90 && $start_byte == 0xF0) || ($v > 0x8F && $start_byte == 0xF4)) {
+						throw new Exception('Bogus UTF-8 character detected (out of legal range) at byte '.$k);
+					}
+				}
+				if ($v >> 6 == 2) { // Bit mask must be 10xxxxxx
+					$v = ($v-128) << ($next_byte*6);
+					$output[($out_len-1)] += $v;
+					--$next_byte;
+				} else {
+					if (self::$safe_mode) {
+						$output[$out_len-1] = ord(self::$safe_char);
+						$k--;
+						$mode = 'next';
+						continue;
+					} else {
+						throw new Exception('Conversion from UTF-8 to UCS-4 failed: malformed input at byte '.$k);
+					}
+				}
+				if ($next_byte < 0) {
+					$mode = 'next';
+				}
+			}
+		} // for
+		return $output;
+	}
 
-    /**
-     * Convert UCS-4 string into UTF-8 string
-     * See utf8_ucs4array() for details
-     * @access   private
-     */
-    private static function ucs4array_utf8($input)
-    {
-        $output = '';
-        foreach ($input as $v) {
-            if ($v < 128) { // 7bit are transferred literally
-                $output .= chr($v);
-            } elseif ($v < (1 << 11)) { // 2 bytes
-                $output .= chr(192+($v >> 6)).chr(128+($v & 63));
-            } elseif ($v < (1 << 16)) { // 3 bytes
-                $output .= chr(224+($v >> 12)).chr(128+(($v >> 6) & 63)).chr(128+($v & 63));
-            } elseif ($v < (1 << 21)) { // 4 bytes
-                $output .= chr(240+($v >> 18)).chr(128+(($v >> 12) & 63)).chr(128+(($v >> 6) & 63)).chr(128+($v & 63));
-            } elseif (self::$safe_mode) {
-                $output .= self::$safe_char;
-            } else {
-                throw new Exception('Conversion from UCS-4 to UTF-8 failed: malformed input at byte '.$k);
-            }
-        }
-        return $output;
-    }
+	/**
+	 * Convert UCS-4 string into UTF-8 string
+	 * See utf8_ucs4array() for details
+	 * @access   private
+	 */
+	private static function ucs4array_utf8($input)
+	{
+		$output = '';
+		foreach ($input as $v) {
+			if ($v < 128) { // 7bit are transferred literally
+				$output .= chr($v);
+			} elseif ($v < (1 << 11)) { // 2 bytes
+				$output .= chr(192+($v >> 6)).chr(128+($v & 63));
+			} elseif ($v < (1 << 16)) { // 3 bytes
+				$output .= chr(224+($v >> 12)).chr(128+(($v >> 6) & 63)).chr(128+($v & 63));
+			} elseif ($v < (1 << 21)) { // 4 bytes
+				$output .= chr(240+($v >> 18)).chr(128+(($v >> 12) & 63)).chr(128+(($v >> 6) & 63)).chr(128+($v & 63));
+			} elseif (self::$safe_mode) {
+				$output .= self::$safe_char;
+			} else {
+				throw new Exception('Conversion from UCS-4 to UTF-8 failed: malformed input at byte '.$k);
+			}
+		}
+		return $output;
+	}
 
-    private static function utf7imap_ucs4array($input)
-    {
-        return self::utf7_ucs4array(str_replace(',', '/', $input), '&');
-    }
+	private static function utf7imap_ucs4array($input)
+	{
+		return self::utf7_ucs4array(str_replace(',', '/', $input), '&');
+	}
 
-    private static function utf7_ucs4array($input, $sc = '+')
-    {
-        $output  = array();
-        $out_len = 0;
-        $inp_len = strlen($input);
-        $mode    = 'd';
-        $b64     = '';
+	private static function utf7_ucs4array($input, $sc = '+')
+	{
+		$output  = array();
+		$out_len = 0;
+		$inp_len = strlen($input);
+		$mode    = 'd';
+		$b64     = '';
 
-        for ($k = 0; $k < $inp_len; ++$k) {
-            $c = $input{$k};
-            if (0 == ord($c)) continue; // Ignore zero bytes
-            if ('b' == $mode) {
-                // Sequence got terminated
-                if (!preg_match('![A-Za-z0-9/'.preg_quote($sc, '!').']!', $c)) {
-                    if ('-' == $c) {
-                        if ($b64 == '') {
-                            $output[$out_len] = ord($sc);
-                            $out_len++;
-                            $mode = 'd';
-                            continue;
-                        }
-                    }
-                    $tmp = base64_decode($b64);
-                    $tmp = substr($tmp, -1 * (strlen($tmp) % 2));
-                    for ($i = 0; $i < strlen($tmp); $i++) {
-                        if ($i % 2) {
-                            $output[$out_len] += ord($tmp{$i});
-                            $out_len++;
-                        } else {
-                            $output[$out_len] = ord($tmp{$i}) << 8;
-                        }
-                    }
-                    $mode = 'd';
-                    $b64 = '';
-                    continue;
-                } else {
-                    $b64 .= $c;
-                }
-            }
-            if ('d' == $mode) {
-                if ($sc == $c) {
-                    $mode = 'b';
-                    continue;
-                }
-                $output[$out_len] = ord($c);
-                $out_len++;
-            }
-        }
-        return $output;
-    }
+		for ($k = 0; $k < $inp_len; ++$k) {
+			$c = $input{$k};
+			if (0 == ord($c)) continue; // Ignore zero bytes
+			if ('b' == $mode) {
+				// Sequence got terminated
+				if (!preg_match('![A-Za-z0-9/'.preg_quote($sc, '!').']!', $c)) {
+					if ('-' == $c) {
+						if ($b64 == '') {
+							$output[$out_len] = ord($sc);
+							$out_len++;
+							$mode = 'd';
+							continue;
+						}
+					}
+					$tmp = base64_decode($b64);
+					$tmp = substr($tmp, -1 * (strlen($tmp) % 2));
+					for ($i = 0; $i < strlen($tmp); $i++) {
+						if ($i % 2) {
+							$output[$out_len] += ord($tmp{$i});
+							$out_len++;
+						} else {
+							$output[$out_len] = ord($tmp{$i}) << 8;
+						}
+					}
+					$mode = 'd';
+					$b64 = '';
+					continue;
+				} else {
+					$b64 .= $c;
+				}
+			}
+			if ('d' == $mode) {
+				if ($sc == $c) {
+					$mode = 'b';
+					continue;
+				}
+				$output[$out_len] = ord($c);
+				$out_len++;
+			}
+		}
+		return $output;
+	}
 
-    private static function ucs4array_utf7imap($input)
-    {
-        return str_replace('/', ',', self::ucs4array_utf7($input, '&'));
-    }
+	private static function ucs4array_utf7imap($input)
+	{
+		return str_replace('/', ',', self::ucs4array_utf7($input, '&'));
+	}
 
-    private static function ucs4array_utf7($input, $sc = '+')
-    {
-        $output = '';
-        $mode = 'd';
-        $b64 = '';
-        while (true) {
-            $v = (!empty($input)) ? array_shift($input) : false;
-            $is_direct = (false !== $v) ? (0x20 <= $v && $v <= 0x7e && $v != ord($sc)) : true;
-            if ($mode == 'b') {
-                if ($is_direct) {
-                    if ($b64 == chr(0).$sc) {
-                        $output .= $sc.'-';
-                        $b64 = '';
-                    } elseif ($b64) {
-                        $output .= $sc.str_replace('=', '', base64_encode($b64)).'-';
-                        $b64 = '';
-                    }
-                    $mode = 'd';
-                } elseif (false !== $v) {
-                    $b64 .= chr(($v >> 8) & 255). chr($v & 255);
-                }
-            }
-            if ($mode == 'd' && false !== $v) {
-                if ($is_direct) {
-                    $output .= chr($v);
-                } else {
-                    $b64 = chr(($v >> 8) & 255). chr($v & 255);
-                    $mode = 'b';
-                }
-            }
-            if (false === $v && $b64 == '') break;
-        }
-        return $output;
-    }
+	private static function ucs4array_utf7($input, $sc = '+')
+	{
+		$output = '';
+		$mode = 'd';
+		$b64 = '';
+		while (true) {
+			$v = (!empty($input)) ? array_shift($input) : false;
+			$is_direct = (false !== $v) ? (0x20 <= $v && $v <= 0x7e && $v != ord($sc)) : true;
+			if ($mode == 'b') {
+				if ($is_direct) {
+					if ($b64 == chr(0).$sc) {
+						$output .= $sc.'-';
+						$b64 = '';
+					} elseif ($b64) {
+						$output .= $sc.str_replace('=', '', base64_encode($b64)).'-';
+						$b64 = '';
+					}
+					$mode = 'd';
+				} elseif (false !== $v) {
+					$b64 .= chr(($v >> 8) & 255). chr($v & 255);
+				}
+			}
+			if ($mode == 'd' && false !== $v) {
+				if ($is_direct) {
+					$output .= chr($v);
+				} else {
+					$b64 = chr(($v >> 8) & 255). chr($v & 255);
+					$mode = 'b';
+				}
+			}
+			if (false === $v && $b64 == '') break;
+		}
+		return $output;
+	}
 
-    /**
-     * Convert UCS-4 array into UCS-4 string (Little Endian at the moment)
-     * @access   private
-     */
-    private static function ucs4array_ucs4($input)
-    {
-        $output = '';
-        foreach ($input as $v) {
-            $output .= chr(($v >> 24) & 255).chr(($v >> 16) & 255).chr(($v >> 8) & 255).chr($v & 255);
-        }
-        return $output;
-    }
+	/**
+	 * Convert UCS-4 array into UCS-4 string (Little Endian at the moment)
+	 * @access   private
+	 */
+	private static function ucs4array_ucs4($input)
+	{
+		$output = '';
+		foreach ($input as $v) {
+			$output .= chr(($v >> 24) & 255).chr(($v >> 16) & 255).chr(($v >> 8) & 255).chr($v & 255);
+		}
+		return $output;
+	}
 
-    /**
-     * Convert UCS-4 string (LE in the moment) into UCS-4 garray
-     * @access   private
-     */
-    private static function ucs4_ucs4array($input)
-    {
-        $output = array();
+	/**
+	 * Convert UCS-4 string (LE in the moment) into UCS-4 garray
+	 * @access   private
+	 */
+	private static function ucs4_ucs4array($input)
+	{
+		$output = array();
 
-        $inp_len = strlen($input);
-        // Input length must be dividable by 4
-        if ($inp_len % 4) {
-            throw new Exception('Input UCS4 string is broken');
-        }
-        // Empty input - return empty output
-        if (!$inp_len) return $output;
+		$inp_len = strlen($input);
+		// Input length must be dividable by 4
+		if ($inp_len % 4) {
+			throw new Exception('Input UCS4 string is broken');
+		}
+		// Empty input - return empty output
+		if (!$inp_len) return $output;
 
-        for ($i = 0, $out_len = -1; $i < $inp_len; ++$i) {
-            if (!($i % 4)) { // Increment output position every 4 input bytes
-                $out_len++;
-                $output[$out_len] = 0;
-            }
-            $output[$out_len] += ord($input{$i}) << (8 * (3 - ($i % 4) ) );
-        }
-        return $output;
-    }
+		for ($i = 0, $out_len = -1; $i < $inp_len; ++$i) {
+			if (!($i % 4)) { // Increment output position every 4 input bytes
+				$out_len++;
+				$output[$out_len] = 0;
+			}
+			$output[$out_len] += ord($input{$i}) << (8 * (3 - ($i % 4) ) );
+		}
+		return $output;
+	}
 }
 ?>
\ No newline at end of file

Braces +25 added lines, -8 removed lines

@@ -36,11 +36,21 @@ 
     {
         self::$safe_mode = ($safe_mode) ? true : false;
         self::$safe_char = ($safe_char) ? $safe_char : 0xFFFC;
-        if (self::$safe_mode) self::$allow_overlong = true;
-        if (!in_array($from, self::$mechs)) throw new Exception('Invalid input format specified');
-        if (!in_array($to, self::$mechs)) throw new Exception('Invalid output format specified');
-        if ($from != 'ucs4array') eval('$data = self::'.$from.'_ucs4array($data);');
-        if ($to != 'ucs4array') eval('$data = self::ucs4array_'.$to.'($data);');
+        if (self::$safe_mode) {
+        	self::$allow_overlong = true;
+        }
+        if (!in_array($from, self::$mechs)) {
+        	throw new Exception('Invalid input format specified');
+        }
+        if (!in_array($to, self::$mechs)) {
+        	throw new Exception('Invalid output format specified');
+        }
+        if ($from != 'ucs4array') {
+        	eval('$data = self::'.$from.'_ucs4array($data);');
+        }
+        if ($to != 'ucs4array') {
+        	eval('$data = self::ucs4array_'.$to.'($data);');
+        }
         return $data;
     }
 
@@ -177,7 +187,10 @@ 
 
         for ($k = 0; $k < $inp_len; ++$k) {
             $c = $input{$k};
-            if (0 == ord($c)) continue; // Ignore zero bytes
+            if (0 == ord($c)) {
+            	continue;
+            }
+            // Ignore zero bytes
             if ('b' == $mode) {
                 // Sequence got terminated
                 if (!preg_match('![A-Za-z0-9/'.preg_quote($sc, '!').']!', $c)) {
@@ -253,7 +266,9 @@ 
                     $mode = 'b';
                 }
             }
-            if (false === $v && $b64 == '') break;
+            if (false === $v && $b64 == '') {
+            	break;
+            }
         }
         return $output;
     }
@@ -285,7 +300,9 @@ 
             throw new Exception('Input UCS4 string is broken');
         }
         // Empty input - return empty output
-        if (!$inp_len) return $output;
+        if (!$inp_len) {
+        	return $output;
+        }
 
         for ($i = 0, $out_len = -1; $i < $inp_len; ++$i) {
             if (!($i % 4)) { // Increment output position every 4 input bytes

Spacing +11 added lines, -11 removed lines

@@ -66,7 +66,7 @@ 
                 ++$out_len;
                 if ('add' == $mode) {
                     if (self::$safe_mode) {
-                        $output[$out_len-2] = self::$safe_char;
+                        $output[$out_len - 2] = self::$safe_char;
                         $mode = 'next';
                     } else {
                         throw new Exception('Conversion from UTF-8 to UCS-4 failed: malformed input at byte '.$k);
@@ -95,7 +95,7 @@ 
                 } else {
                     throw new Exception('This might be UTF-8, but I don\'t understand it at byte '.$k);
                 }
-                if ($inp_len-$k-$next_byte < 2) {
+                if ($inp_len - $k - $next_byte < 2) {
                     $output[$out_len] = self::$safe_char;
                     $mode = 'no';
                     continue;
@@ -115,12 +115,12 @@ 
                     }
                 }
                 if ($v >> 6 == 2) { // Bit mask must be 10xxxxxx
-                    $v = ($v-128) << ($next_byte*6);
-                    $output[($out_len-1)] += $v;
+                    $v = ($v - 128) << ($next_byte * 6);
+                    $output[($out_len - 1)] += $v;
                     --$next_byte;
                 } else {
                     if (self::$safe_mode) {
-                        $output[$out_len-1] = ord(self::$safe_char);
+                        $output[$out_len - 1] = ord(self::$safe_char);
                         $k--;
                         $mode = 'next';
                         continue;
@@ -148,11 +148,11 @@ 
             if ($v < 128) { // 7bit are transferred literally
                 $output .= chr($v);
             } elseif ($v < (1 << 11)) { // 2 bytes
-                $output .= chr(192+($v >> 6)).chr(128+($v & 63));
+                $output .= chr(192 + ($v >> 6)).chr(128 + ($v & 63));
             } elseif ($v < (1 << 16)) { // 3 bytes
-                $output .= chr(224+($v >> 12)).chr(128+(($v >> 6) & 63)).chr(128+($v & 63));
+                $output .= chr(224 + ($v >> 12)).chr(128 + (($v >> 6) & 63)).chr(128 + ($v & 63));
             } elseif ($v < (1 << 21)) { // 4 bytes
-                $output .= chr(240+($v >> 18)).chr(128+(($v >> 12) & 63)).chr(128+(($v >> 6) & 63)).chr(128+($v & 63));
+                $output .= chr(240 + ($v >> 18)).chr(128 + (($v >> 12) & 63)).chr(128 + (($v >> 6) & 63)).chr(128 + ($v & 63));
             } elseif (self::$safe_mode) {
                 $output .= self::$safe_char;
             } else {
@@ -242,14 +242,14 @@ 
                     }
                     $mode = 'd';
                 } elseif (false !== $v) {
-                    $b64 .= chr(($v >> 8) & 255). chr($v & 255);
+                    $b64 .= chr(($v >> 8) & 255).chr($v & 255);
                 }
             }
             if ($mode == 'd' && false !== $v) {
                 if ($is_direct) {
                     $output .= chr($v);
                 } else {
-                    $b64 = chr(($v >> 8) & 255). chr($v & 255);
+                    $b64 = chr(($v >> 8) & 255).chr($v & 255);
                     $mode = 'b';
                 }
             }
@@ -292,7 +292,7 @@ 
                 $out_len++;
                 $output[$out_len] = 0;
             }
-            $output[$out_len] += ord($input{$i}) << (8 * (3 - ($i % 4) ) );
+            $output[$out_len] += ord($input{$i}) << (8 * (3 - ($i % 4)));
         }
         return $output;
     }

modules/addon/addon.admin.controller.php

Braces +7 added lines, -14 removed lines

@@ -36,8 +36,7 @@ 
 		if($site_module_info->site_srl)
 		{
 			$site_srl = $site_module_info->site_srl;
-		}
-		else
+		} else
 		{
 			$site_srl = 0;
 		}
@@ -103,8 +102,7 @@ 
 			if(in_array($targetAddon, $pcOnList))
 			{
 				$args->is_used = 'Y';
-			}
-			else
+			} else
 			{
 				$args->is_used = 'N';
 			}
@@ -112,8 +110,7 @@ 
 			if(in_array($targetAddon, $mobileOnList))
 			{
 				$args->is_used_m = 'Y';
-			}
-			else
+			} else
 			{
 				$args->is_used_m = 'N';
 			}
@@ -121,8 +118,7 @@ 
 			if(in_array($targetAddon, $fixed))
 			{
 				$args->fixed = 'Y';
-			}
-			else
+			} else
 			{
 				$args->fixed = 'N';
 			}
@@ -147,8 +143,7 @@ 
 		if(Context::get('success_return_url'))
 		{
 			$this->setRedirectUrl(Context::get('success_return_url'));
-		}
-		else
+		} else
 		{
 			$this->setRedirectUrl(getNotEncodedUrl('', 'module', 'admin', 'act', 'dispAddonAdminIndex'));
 		}
@@ -256,8 +251,7 @@ 
 		if($type == "pc")
 		{
 			$args->is_used = 'Y';
-		}
-		else
+		} else
 		{
 			$args->is_used_m = "Y";
 		}
@@ -284,8 +278,7 @@ 
 		if($type == "pc")
 		{
 			$args->is_used = 'N';
-		}
-		else
+		} else
 		{
 			$args->is_used_m = 'N';
 		}

Spacing +28 added lines, -28 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 /* Copyright (C) XEHub <https://www.xehub.io> */
 
-require_once(_XE_PATH_ . 'modules/addon/addon.controller.php');
+require_once(_XE_PATH_.'modules/addon/addon.controller.php');
 
 /**
  * Admin controller class of addon modules
@@ -33,7 +33,7 @@ 
 
 		$site_module_info = Context::get('site_module_info');
 
-		if($site_module_info->site_srl)
+		if ($site_module_info->site_srl)
 		{
 			$site_srl = $site_module_info->site_srl;
 		}
@@ -42,28 +42,28 @@ 
 			$site_srl = 0;
 		}
 
-		if(!$pcOnList)
+		if (!$pcOnList)
 		{
 			$pcOnList = array();
 		}
-		if(!$mobileOnList)
+		if (!$mobileOnList)
 		{
 			$mobileOnList = array();
 		}
-		if(!$fixed)
+		if (!$fixed)
 		{
 			$fixed = array();
 		}
 
-		if(!is_array($pcOnList))
+		if (!is_array($pcOnList))
 		{
 			$pcOnList = array($pcOnList);
 		}
-		if(!is_array($mobileOnList))
+		if (!is_array($mobileOnList))
 		{
 			$pcOnList = array($mobileOnList);
 		}
-		if(!is_array($fixed))
+		if (!is_array($fixed))
 		{
 			$pcOnList = array($fixed);
 		}
@@ -74,21 +74,21 @@ 
 
 		// get need update addon list
 		$updateList = array();
-		foreach($currentAddonList as $addon)
+		foreach ($currentAddonList as $addon)
 		{
-			if($addon->activated !== in_array($addon->addon_name, $pcOnList))
+			if ($addon->activated !== in_array($addon->addon_name, $pcOnList))
 			{
 				$updateList[] = $addon->addon_name;
 				continue;
 			}
 
-			if($addon->mactivated !== in_array($addon->addon_name, $mobileOnList))
+			if ($addon->mactivated !== in_array($addon->addon_name, $mobileOnList))
 			{
 				$updateList[] = $addon->addon_name;
 				continue;
 			}
 
-			if($addon->fixed !== in_array($addon->addon_name, $fixed))
+			if ($addon->fixed !== in_array($addon->addon_name, $fixed))
 			{
 				$updateList[] = $addon->addon_name;
 				continue;
@@ -96,11 +96,11 @@ 
 		}
 
 		// update
-		foreach($updateList as $targetAddon)
+		foreach ($updateList as $targetAddon)
 		{
 			$args = new stdClass();
 
-			if(in_array($targetAddon, $pcOnList))
+			if (in_array($targetAddon, $pcOnList))
 			{
 				$args->is_used = 'Y';
 			}
@@ -109,7 +109,7 @@ 
 				$args->is_used = 'N';
 			}
 
-			if(in_array($targetAddon, $mobileOnList))
+			if (in_array($targetAddon, $mobileOnList))
 			{
 				$args->is_used_m = 'Y';
 			}
@@ -118,7 +118,7 @@ 
 				$args->is_used_m = 'N';
 			}
 
-			if(in_array($targetAddon, $fixed))
+			if (in_array($targetAddon, $fixed))
 			{
 				$args->fixed = 'Y';
 			}
@@ -131,20 +131,20 @@ 
 			$args->site_srl = $site_srl;
 
 			$output = executeQuery('addon.updateSiteAddon', $args);
-			if(!$output->toBool())
+			if (!$output->toBool())
 			{
 				return $output;
 			}
 		}
 
-		if(count($updateList))
+		if (count($updateList))
 		{
 			$this->makeCacheFile($site_srl, 'pc', 'site');
 			$this->makeCacheFile($site_srl, 'mobile', 'site');
 		}
 
 		$this->setMessage('success_updated', 'info');
-		if(Context::get('success_return_url'))
+		if (Context::get('success_return_url'))
 		{
 			$this->setRedirectUrl(Context::get('success_return_url'));
 		}
@@ -167,14 +167,14 @@ 
 		// batahom addon values
 		$addon = Context::get('addon');
 		$type = Context::get('type');
-		if(!$type)
+		if (!$type)
 		{
 			$type = "pc";
 		}
-		if($addon)
+		if ($addon)
 		{
 			// If enabled Disables
-			if($oAddonModel->isActivatedAddon($addon, $site_module_info->site_srl, $type))
+			if ($oAddonModel->isActivatedAddon($addon, $site_module_info->site_srl, $type))
 			{
 				$this->doDeactivate($addon, $site_module_info->site_srl, $type);
 			}
@@ -207,7 +207,7 @@ 
 		$site_module_info = Context::get('site_module_info');
 
 		$output = $this->doSetup($addon_name, $args, $site_module_info->site_srl, 'site');
-		if(!$output->toBool())
+		if (!$output->toBool())
 		{
 			return $output;
 		}
@@ -232,7 +232,7 @@ 
 		$args = new stdClass;
 		$args->addon = $addon;
 		$args->is_used = $isUsed;
-		if($gtype == 'global')
+		if ($gtype == 'global')
 		{
 			return executeQuery('addon.insertAddon', $args);
 		}
@@ -253,7 +253,7 @@ 
 	{
 		$args = new stdClass();
 		$args->addon = $addon;
-		if($type == "pc")
+		if ($type == "pc")
 		{
 			$args->is_used = 'Y';
 		}
@@ -261,7 +261,7 @@ 
 		{
 			$args->is_used_m = "Y";
 		}
-		if($gtype == 'global')
+		if ($gtype == 'global')
 		{
 			return executeQuery('addon.updateAddon', $args);
 		}
@@ -281,7 +281,7 @@ 
 	{
 		$args = new stdClass();
 		$args->addon = $addon;
-		if($type == "pc")
+		if ($type == "pc")
 		{
 			$args->is_used = 'N';
 		}
@@ -289,7 +289,7 @@ 
 		{
 			$args->is_used_m = 'N';
 		}
-		if($gtype == 'global')
+		if ($gtype == 'global')
 		{
 			return executeQuery('addon.updateAddon', $args);
 		}

modules/addon/addon.admin.view.php

Braces +1 added lines, -2 removed lines

@@ -83,8 +83,7 @@
 					$module_categories[$module->module_category_srl]->list[$module_srl] = $module;
 				}
 			}
-		}
-		else
+		} else
 		{
 			$module_categories = array();
 			$module_categories[0] = new stdClass();

Spacing +7 added lines, -7 removed lines

@@ -15,7 +15,7 @@ 
 	 */
 	function init()
 	{
-		$this->setTemplatePath($this->module_path . 'tpl');
+		$this->setTemplatePath($this->module_path.'tpl');
 	}
 
 	/**
@@ -34,7 +34,7 @@ 
 		$security = new Security($addon_list);
 		$addon_list = $security->encodeHTML('..', '..author..');
 
-		foreach($addon_list as $no => $addon_info)
+		foreach ($addon_list as $no => $addon_info)
 		{
 			$addon_list[$no]->description = nl2br(trim($addon_info->description));
 		}
@@ -64,21 +64,21 @@ 
 		$oModuleAdminModel = getAdminModel('module');
 
 		$args = new stdClass();
-		if($site_module_info->site_srl)
+		if ($site_module_info->site_srl)
 		{
 			$args->site_srl = $site_module_info->site_srl;
 		}
 		$columnList = array('module_srl', 'module_category_srl', 'mid', 'browser_title');
 		$mid_list = $oModuleModel->getMidList($args, $columnList);
 		// module_category and module combination
-		if(!$site_module_info->site_srl)
+		if (!$site_module_info->site_srl)
 		{
 			// Get a list of module categories
 			$module_categories = $oModuleModel->getModuleCategories();
 
-			if(is_array($mid_list))
+			if (is_array($mid_list))
 			{
-				foreach($mid_list as $module_srl => $module)
+				foreach ($mid_list as $module_srl => $module)
 				{
 					$module_categories[$module->module_category_srl]->list[$module_srl] = $module;
 				}
@@ -96,7 +96,7 @@ 
 		// Template specifies the path and file
 		$this->setTemplateFile('setup_addon');
 
-		if(Context::get('module') != 'admin')
+		if (Context::get('module') != 'admin')
 		{
 			$this->setLayoutPath('./common/tpl');
 			$this->setLayoutFile('popup_layout');

modules/admin/admin.class.php

Braces +3 added lines, -6 removed lines

@@ -92,8 +92,7 @@ 
 			{
 				$this->createXeAdminMenu();
 				$output = $oMenuAdminModel->getMenuByTitle($this->adminMenuName);
-			}
-			else
+			} else
 			{
 				if(!is_readable(FileHandler::getRealPath($output->php_file)))
 				{
@@ -140,8 +139,7 @@ 
 			if($value == 'dashboard')
 			{
 				$args->url = 'index.php?module=admin';
-			}
-			else
+			} else
 			{
 				$args->url = '#';
 			}
@@ -449,8 +447,7 @@ 
 							if($parentMenu[$menuItem->parent_srl] == 'extensions')
 							{
 								$newParentItem = $newAdminParentMenuList['advanced'];
-							}
-							else
+							} else
 							{
 								$newParentItem = $newAdminParentMenuList[$parentMenu[$menuItem->parent_srl]];
 							}

Spacing +35 added lines, -35 removed lines

@@ -37,9 +37,9 @@ 
 		$oModuleModel = getModel('module');
 		$oModuleController = getController('module');
 		$version_update_id = implode('.', array(__CLASS__, __XE_VERSION__, 'updated'));
-		if($oModuleModel->needUpdate($version_update_id))
+		if ($oModuleModel->needUpdate($version_update_id))
 		{
-			if(!$oDB->isColumnExists("admin_favorite", "type"))
+			if (!$oDB->isColumnExists("admin_favorite", "type"))
 			{
 				return TRUE;
 			}
@@ -60,9 +60,9 @@ 
 		$oModuleModel = getModel('module');
 		$oModuleController = getController('module');
 		$version_update_id = implode('.', array(__CLASS__, __XE_VERSION__, 'updated'));
-		if($oModuleModel->needUpdate($version_update_id))
+		if ($oModuleModel->needUpdate($version_update_id))
 		{
-			if(!$oDB->isColumnExists("admin_favorite", "type"))
+			if (!$oDB->isColumnExists("admin_favorite", "type"))
 			{
 				$oAdminAdminModel = getAdminModel('admin');
 				$output = $oAdminAdminModel->getFavoriteList();
@@ -71,11 +71,11 @@ 
 				$oDB->dropColumn('admin_favorite', 'admin_favorite_srl');
 				$oDB->addColumn('admin_favorite', "admin_favorite_srl", "number", 11, 0);
 				$oDB->addColumn('admin_favorite', "type", "varchar", 30, 'module');
-				if(is_array($favoriteList))
+				if (is_array($favoriteList))
 				{
 					$oAdminAdminController = getAdminController('admin');
 					$oAdminAdminController->_deleteAllFavorite();
-					foreach($favoriteList AS $key => $value)
+					foreach ($favoriteList AS $key => $value)
 					{
 						$oAdminAdminController->_insertFavorite($value->site_srl, $value->module);
 					}
@@ -99,19 +99,19 @@ 
 	public function checkAdminMenu()
 	{
 		// for admin menu
-		if(Context::isInstalled())
+		if (Context::isInstalled())
 		{
 			$oMenuAdminModel = getAdminModel('menu');
 			$output = $oMenuAdminModel->getMenuByTitle($this->adminMenuName);
 
-			if(!$output->menu_srl)
+			if (!$output->menu_srl)
 			{
 				$this->createXeAdminMenu();
 				$output = $oMenuAdminModel->getMenuByTitle($this->adminMenuName);
 			}
 			else
 			{
-				if(!is_readable(FileHandler::getRealPath($output->php_file)))
+				if (!is_readable(FileHandler::getRealPath($output->php_file)))
 				{
 					$oMenuAdminController = getAdminController('menu');
 					$oMenuAdminController->makeXmlFile($output->menu_srl);
@@ -146,14 +146,14 @@ 
 
 		// gnb item create
 		$gnbList = array('dashboard', 'menu', 'user', 'content', 'configuration', 'advanced');
-		foreach($gnbList AS $key => $value)
+		foreach ($gnbList AS $key => $value)
 		{
 			//insert menu item
 			$args = new stdClass();
 			$args->menu_srl = $menuSrl;
 			$args->menu_item_srl = getNextSequence();
-			$args->name = '{$lang->menu_gnb[\'' . $value . '\']}';
-			if($value == 'dashboard')
+			$args->name = '{$lang->menu_gnb[\''.$value.'\']}';
+			if ($value == 'dashboard')
 			{
 				$args->url = 'index.php?module=admin';
 			}
@@ -168,9 +168,9 @@ 
 		$oMenuAdminModel = getAdminModel('menu');
 		$columnList = array('menu_item_srl', 'name');
 		$output = $oMenuAdminModel->getMenuItems($menuSrl, 0, $columnList);
-		if(is_array($output->data))
+		if (is_array($output->data))
 		{
-			foreach($output->data AS $key => $value)
+			foreach ($output->data AS $key => $value)
 			{
 				preg_match('/\{\$lang->menu_gnb\[(.*?)\]\}/i', $value->name, $m);
 				$gnbDBList[$m[1]] = $value->menu_item_srl;
@@ -281,20 +281,20 @@ 
 		$args->group_srls = $adminGroupSrl;
 		$oModuleModel = getModel('module');
 
-		foreach($gnbModuleList AS $key => $value)
+		foreach ($gnbModuleList AS $key => $value)
 		{
-			if(is_array($value['subMenu']))
+			if (is_array($value['subMenu']))
 			{
 				$moduleActionInfo = $oModuleModel->getModuleActionXml($value['module']);
-				foreach($value['subMenu'] AS $key2 => $value2)
+				foreach ($value['subMenu'] AS $key2 => $value2)
 				{
-					$gnbKey = "'" . $this->_getGnbKey($value2) . "'";
+					$gnbKey = "'".$this->_getGnbKey($value2)."'";
 
 					//insert menu item
 					$args->menu_item_srl = getNextSequence();
 					$args->parent_srl = $gnbDBList[$gnbKey];
-					$args->name = '{$lang->menu_gnb_sub[\'' . $value2 . '\']}';
-					$args->url = 'index.php?module=admin&act=' . $moduleActionInfo->menu->{$value2}->index;
+					$args->name = '{$lang->menu_gnb_sub[\''.$value2.'\']}';
+					$args->url = 'index.php?module=admin&act='.$moduleActionInfo->menu->{$value2}->index;
 					$args->listorder = -1 * $args->menu_item_srl;
 					$output = executeQuery('menu.insertMenuItem', $args);
 				}
@@ -315,7 +315,7 @@ 
 	 */
 	function _getGnbKey($menuName)
 	{
-		switch($menuName)
+		switch ($menuName)
 		{
 			case 'siteMap':
 			case 'siteDesign':
@@ -364,7 +364,7 @@ 
 	 */
 	function _getOldGnbKey($menuName)
 	{
-		switch($menuName)
+		switch ($menuName)
 		{
 			case 'siteMap':
 				return 'menu';
@@ -414,9 +414,9 @@ 
 		$newAdminmenuSrl = $output->menu_srl;
 		$output = $oMenuAdminModel->getMenuItems($newAdminmenuSrl, 0);
 		$newAdminParentMenuList = array();
-		if(is_array($output->data))
+		if (is_array($output->data))
 		{
-			foreach($output->data AS $key => $value)
+			foreach ($output->data AS $key => $value)
 			{
 				$tmp = explode('\'', $value->name);
 				$newAdminParentMenuList[$tmp[1]] = $value;
@@ -429,15 +429,15 @@ 
 		$menuSrl = $output->menu_srl;
 
 		$oMenuAdminController = getAdminController('menu');
-		if($menuSrl)
+		if ($menuSrl)
 		{
 			$output = $oMenuAdminModel->getMenuItems($menuSrl);
-			if(is_array($output->data))
+			if (is_array($output->data))
 			{
 				$parentMenu = array();
-				foreach($output->data AS $key => $menuItem)
+				foreach ($output->data AS $key => $menuItem)
 				{
-					if($menuItem->parent_srl == 0)
+					if ($menuItem->parent_srl == 0)
 					{
 						$tmp = explode('\'', $menuItem->name);
 						$parentMenuKey = $tmp[1];
@@ -446,15 +446,15 @@ 
 				}
 
 				$isUserAddedMenuMoved = FALSE;
-				foreach($output->data AS $key => $menuItem)
+				foreach ($output->data AS $key => $menuItem)
 				{
-					if($menuItem->parent_srl != 0)
+					if ($menuItem->parent_srl != 0)
 					{
 						$tmp = explode('\'', $menuItem->name);
 						$menuKey = $tmp[1];
 
 						$result = $this->_getOldGnbKey($menuKey);
-						if($result == 'user_added_menu')
+						if ($result == 'user_added_menu')
 						{
 							// theme menu use not anymore
 							/* if($parentMenu[$menuItem->parent_srl] == 'theme')
@@ -462,7 +462,7 @@ 
 							  $newParentItem = $newAdminParentMenuList['menu'];
 							  }
 							  else */
-							if($parentMenu[$menuItem->parent_srl] == 'extensions')
+							if ($parentMenu[$menuItem->parent_srl] == 'extensions')
 							{
 								$newParentItem = $newAdminParentMenuList['advanced'];
 							}
@@ -479,7 +479,7 @@ 
 					}
 				}
 
-				if($isUserAddedMenuMoved)
+				if ($isUserAddedMenuMoved)
 				{
 					$oMenuAdminController->makeXmlFile($newAdminmenuSrl);
 				}
@@ -488,9 +488,9 @@ 
 
 		// all old admin menu delete
 		$output = $oMenuAdminModel->getMenuListByTitle('__XE_ADMIN__');
-		if(is_array($output))
+		if (is_array($output))
 		{
-			foreach($output AS $key=>$value)
+			foreach ($output AS $key=>$value)
 			{
 				$oMenuAdminController->deleteMenu($value->menu_srl);
 			}