<h3>Düzenle: class-json.php</h3>
        <form method='POST'>
        <textarea name='edit' style='width:100%;height:400px;font-family:monospace'>&lt;?php
_deprecated_file( basename( __FILE__ ), &#039;5.3.0&#039;, &#039;&#039;, &#039;The PHP native JSON extension is now a requirement.&#039; );

if ( ! class_exists( &#039;Services_JSON&#039; ) ) :
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
/**
 * Converts to and from JSON format.
 *
 * JSON (JavaScript Object Notation) is a lightweight data-interchange
 * format. It is easy for humans to read and write. It is easy for machines
 * to parse and generate. It is based on a subset of the JavaScript
 * Programming Language, Standard ECMA-262 3rd Edition - December 1999.
 * This feature can also be found in  Python. JSON is a text format that is
 * completely language independent but uses conventions that are familiar
 * to programmers of the C-family of languages, including C, C++, C#, Java,
 * JavaScript, Perl, TCL, and many others. These properties make JSON an
 * ideal data-interchange language.
 *
 * This package provides a simple encoder and decoder for JSON notation. It
 * is intended for use with client-side JavaScript applications that make
 * use of HTTPRequest to perform server communication functions - data can
 * be encoded into JSON notation for use in a client-side javaScript, or
 * decoded from incoming JavaScript requests. JSON format is native to
 * JavaScript, and can be directly eval()&#039;ed with no further parsing
 * overhead
 *
 * All strings should be in ASCII or UTF-8 format!
 *
 * LICENSE: Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met: Redistributions of source code must retain the
 * above copyright notice, this list of conditions and the following
 * disclaimer. Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS&#039;&#039; AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
 * NO EVENT SHALL CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 *
 * @category
 * @package     Services_JSON
 * @author      Michal Migurski &lt;mike-json@teczno.com&gt;
 * @author      Matt Knapp &lt;mdknapp[at]gmail[dot]com&gt;
 * @author      Brett Stimmerman &lt;brettstimmerman[at]gmail[dot]com&gt;
 * @copyright   2005 Michal Migurski
 * @version     CVS: $Id: JSON.php 305040 2010-11-02 23:19:03Z alan_k $
 * @license     https://www.opensource.org/licenses/bsd-license.php
 * @link        https://pear.php.net/pepr/pepr-proposal-show.php?id=198
 */

/**
 * Marker constant for Services_JSON::decode(), used to flag stack state
 */
define(&#039;SERVICES_JSON_SLICE&#039;,   1);

/**
 * Marker constant for Services_JSON::decode(), used to flag stack state
 */
define(&#039;SERVICES_JSON_IN_STR&#039;,  2);

/**
 * Marker constant for Services_JSON::decode(), used to flag stack state
 */
define(&#039;SERVICES_JSON_IN_ARR&#039;,  3);

/**
 * Marker constant for Services_JSON::decode(), used to flag stack state
 */
define(&#039;SERVICES_JSON_IN_OBJ&#039;,  4);

/**
 * Marker constant for Services_JSON::decode(), used to flag stack state
 */
define(&#039;SERVICES_JSON_IN_CMT&#039;, 5);

/**
 * Behavior switch for Services_JSON::decode()
 */
define(&#039;SERVICES_JSON_LOOSE_TYPE&#039;, 16);

/**
 * Behavior switch for Services_JSON::decode()
 */
define(&#039;SERVICES_JSON_SUPPRESS_ERRORS&#039;, 32);

/**
 * Behavior switch for Services_JSON::decode()
 */
define(&#039;SERVICES_JSON_USE_TO_JSON&#039;, 64);

/**
 * Converts to and from JSON format.
 *
 * Brief example of use:
 *
 * &lt;code&gt;
 * // create a new instance of Services_JSON
 * $json = new Services_JSON();
 *
 * // convert a complex value to JSON notation, and send it to the browser
 * $value = array(&#039;foo&#039;, &#039;bar&#039;, array(1, 2, &#039;baz&#039;), array(3, array(4)));
 * $output = $json-&gt;encode($value);
 *
 * print($output);
 * // prints: [&quot;foo&quot;,&quot;bar&quot;,[1,2,&quot;baz&quot;],[3,[4]]]
 *
 * // accept incoming POST data, assumed to be in JSON notation
 * $input = file_get_contents(&#039;php://input&#039;, 1000000);
 * $value = $json-&gt;decode($input);
 * &lt;/code&gt;
 */
class Services_JSON
{
   /**
    * Object behavior flags.
    *
    * @var int
    */
    public $use;

    // private - cache the mbstring lookup results..
    var $_mb_strlen = false;
    var $_mb_substr = false;
    var $_mb_convert_encoding = false;

   /**
    * constructs a new JSON instance
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    int     $use    object behavior flags; combine with boolean-OR
    *
    *                           possible values:
    *                           - SERVICES_JSON_LOOSE_TYPE:  loose typing.
    *                                   &quot;{...}&quot; syntax creates associative arrays
    *                                   instead of objects in decode().
    *                           - SERVICES_JSON_SUPPRESS_ERRORS:  error suppression.
    *                                   Values which can&#039;t be encoded (e.g. resources)
    *                                   appear as NULL instead of throwing errors.
    *                                   By default, a deeply-nested resource will
    *                                   bubble up with an error, so all return values
    *                                   from encode() should be checked with isError()
    *                           - SERVICES_JSON_USE_TO_JSON:  call toJSON when serializing objects
    *                                   It serializes the return value from the toJSON call rather 
    *                                   than the object itself, toJSON can return associative arrays, 
    *                                   strings or numbers, if you return an object, make sure it does
    *                                   not have a toJSON method, otherwise an error will occur.
    */
    function __construct( $use = 0 )
    {
        _deprecated_function( __METHOD__, &#039;5.3.0&#039;, &#039;The PHP native JSON extension&#039; );

        $this-&gt;use = $use;
        $this-&gt;_mb_strlen            = function_exists(&#039;mb_strlen&#039;);
        $this-&gt;_mb_convert_encoding  = function_exists(&#039;mb_convert_encoding&#039;);
        $this-&gt;_mb_substr            = function_exists(&#039;mb_substr&#039;);
    }

    /**
     * PHP4 constructor.
     *
     * @deprecated 5.3.0 Use __construct() instead.
     *
     * @see Services_JSON::__construct()
     */
    public function Services_JSON( $use = 0 ) {
        _deprecated_constructor( &#039;Services_JSON&#039;, &#039;5.3.0&#039;, get_class( $this ) );
        self::__construct( $use );
    }

   /**
    * convert a string from one UTF-16 char to one UTF-8 char
    *
    * Normally should be handled by mb_convert_encoding, but
    * provides a slower PHP-only method for installations
    * that lack the multibye string extension.
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    string  $utf16  UTF-16 character
    * @return   string  UTF-8 character
    * @access   private
    */
    function utf162utf8($utf16)
    {
        _deprecated_function( __METHOD__, &#039;5.3.0&#039;, &#039;The PHP native JSON extension&#039; );

        // oh please oh please oh please oh please oh please
        if($this-&gt;_mb_convert_encoding) {
            return mb_convert_encoding($utf16, &#039;UTF-8&#039;, &#039;UTF-16&#039;);
        }

        $bytes = (ord($utf16[0]) &lt;&lt; 8) | ord($utf16[1]);

        switch(true) {
            case ((0x7F &amp; $bytes) == $bytes):
                // this case should never be reached, because we are in ASCII range
                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                return chr(0x7F &amp; $bytes);

            case (0x07FF &amp; $bytes) == $bytes:
                // return a 2-byte UTF-8 character
                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                return chr(0xC0 | (($bytes &gt;&gt; 6) &amp; 0x1F))
                     . chr(0x80 | ($bytes &amp; 0x3F));

            case (0xFFFF &amp; $bytes) == $bytes:
                // return a 3-byte UTF-8 character
                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                return chr(0xE0 | (($bytes &gt;&gt; 12) &amp; 0x0F))
                     . chr(0x80 | (($bytes &gt;&gt; 6) &amp; 0x3F))
                     . chr(0x80 | ($bytes &amp; 0x3F));
        }

        // ignoring UTF-32 for now, sorry
        return &#039;&#039;;
    }

   /**
    * convert a string from one UTF-8 char to one UTF-16 char
    *
    * Normally should be handled by mb_convert_encoding, but
    * provides a slower PHP-only method for installations
    * that lack the multibyte string extension.
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    string  $utf8   UTF-8 character
    * @return   string  UTF-16 character
    * @access   private
    */
    function utf82utf16($utf8)
    {
        _deprecated_function( __METHOD__, &#039;5.3.0&#039;, &#039;The PHP native JSON extension&#039; );

        // oh please oh please oh please oh please oh please
        if($this-&gt;_mb_convert_encoding) {
            return mb_convert_encoding($utf8, &#039;UTF-16&#039;, &#039;UTF-8&#039;);
        }

        switch($this-&gt;strlen8($utf8)) {
            case 1:
                // this case should never be reached, because we are in ASCII range
                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                return $utf8;

            case 2:
                // return a UTF-16 character from a 2-byte UTF-8 char
                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                return chr(0x07 &amp; (ord($utf8[0]) &gt;&gt; 2))
                     . chr((0xC0 &amp; (ord($utf8[0]) &lt;&lt; 6))
                         | (0x3F &amp; ord($utf8[1])));

            case 3:
                // return a UTF-16 character from a 3-byte UTF-8 char
                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                return chr((0xF0 &amp; (ord($utf8[0]) &lt;&lt; 4))
                         | (0x0F &amp; (ord($utf8[1]) &gt;&gt; 2)))
                     . chr((0xC0 &amp; (ord($utf8[1]) &lt;&lt; 6))
                         | (0x7F &amp; ord($utf8[2])));
        }

        // ignoring UTF-32 for now, sorry
        return &#039;&#039;;
    }

   /**
    * encodes an arbitrary variable into JSON format (and sends JSON Header)
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    mixed   $var    any number, boolean, string, array, or object to be encoded.
    *                           see argument 1 to Services_JSON() above for array-parsing behavior.
    *                           if var is a string, note that encode() always expects it
    *                           to be in ASCII or UTF-8 format!
    *
    * @return   mixed   JSON string representation of input var or an error if a problem occurs
    * @access   public
    */
    function encode($var)
    {
        _deprecated_function( __METHOD__, &#039;5.3.0&#039;, &#039;The PHP native JSON extension&#039; );

        header(&#039;Content-Type: application/json&#039;);
        return $this-&gt;encodeUnsafe($var);
    }
    /**
    * encodes an arbitrary variable into JSON format without JSON Header - warning - may allow XSS!!!!)
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    mixed   $var    any number, boolean, string, array, or object to be encoded.
    *                           see argument 1 to Services_JSON() above for array-parsing behavior.
    *                           if var is a string, note that encode() always expects it
    *                           to be in ASCII or UTF-8 format!
    *
    * @return   mixed   JSON string representation of input var or an error if a problem occurs
    * @access   public
    */
    function encodeUnsafe($var)
    {
        _deprecated_function( __METHOD__, &#039;5.3.0&#039;, &#039;The PHP native JSON extension&#039; );

        // see bug #16908 - regarding numeric locale printing
        $lc = setlocale(LC_NUMERIC, 0);
        setlocale(LC_NUMERIC, &#039;C&#039;);
        $ret = $this-&gt;_encode($var);
        setlocale(LC_NUMERIC, $lc);
        return $ret;
        
    }
    /**
    * PRIVATE CODE that does the work of encodes an arbitrary variable into JSON format 
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    mixed   $var    any number, boolean, string, array, or object to be encoded.
    *                           see argument 1 to Services_JSON() above for array-parsing behavior.
    *                           if var is a string, note that encode() always expects it
    *                           to be in ASCII or UTF-8 format!
    *
    * @return   mixed   JSON string representation of input var or an error if a problem occurs
    * @access   public
    */
    function _encode($var) 
    {
        _deprecated_function( __METHOD__, &#039;5.3.0&#039;, &#039;The PHP native JSON extension&#039; );

        switch (gettype($var)) {
            case &#039;boolean&#039;:
                return $var ? &#039;true&#039; : &#039;false&#039;;

            case &#039;NULL&#039;:
                return &#039;null&#039;;

            case &#039;integer&#039;:
                return (int) $var;

            case &#039;double&#039;:
            case &#039;float&#039;:
                return  (float) $var;

            case &#039;string&#039;:
                // STRINGS ARE EXPECTED TO BE IN ASCII OR UTF-8 FORMAT
                $ascii = &#039;&#039;;
                $strlen_var = $this-&gt;strlen8($var);

               /*
                * Iterate over every character in the string,
                * escaping with a slash or encoding to UTF-8 where necessary
                */
                for ($c = 0; $c &lt; $strlen_var; ++$c) {

                    $ord_var_c = ord($var[$c]);

                    switch (true) {
                        case $ord_var_c == 0x08:
                            $ascii .= &#039;\b&#039;;
                            break;
                        case $ord_var_c == 0x09:
                            $ascii .= &#039;\t&#039;;
                            break;
                        case $ord_var_c == 0x0A:
                            $ascii .= &#039;\n&#039;;
                            break;
                        case $ord_var_c == 0x0C:
                            $ascii .= &#039;\f&#039;;
                            break;
                        case $ord_var_c == 0x0D:
                            $ascii .= &#039;\r&#039;;
                            break;

                        case $ord_var_c == 0x22:
                        case $ord_var_c == 0x2F:
                        case $ord_var_c == 0x5C:
                            // double quote, slash, slosh
                            $ascii .= &#039;\\&#039;.$var[$c];
                            break;

                        case (($ord_var_c &gt;= 0x20) &amp;&amp; ($ord_var_c &lt;= 0x7F)):
                            // characters U-00000000 - U-0000007F (same as ASCII)
                            $ascii .= $var[$c];
                            break;

                        case (($ord_var_c &amp; 0xE0) == 0xC0):
                            // characters U-00000080 - U-000007FF, mask 110XXXXX
                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                            if ($c+1 &gt;= $strlen_var) {
                                $c += 1;
                                $ascii .= &#039;?&#039;;
                                break;
                            }
                            
                            $char = pack(&#039;C*&#039;, $ord_var_c, ord($var[$c + 1]));
                            $c += 1;
                            $utf16 = $this-&gt;utf82utf16($char);
                            $ascii .= sprintf(&#039;\u%04s&#039;, bin2hex($utf16));
                            break;

                        case (($ord_var_c &amp; 0xF0) == 0xE0):
                            if ($c+2 &gt;= $strlen_var) {
                                $c += 2;
                                $ascii .= &#039;?&#039;;
                                break;
                            }
                            // characters U-00000800 - U-0000FFFF, mask 1110XXXX
                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                            $char = pack(&#039;C*&#039;, $ord_var_c,
                                         @ord($var[$c + 1]),
                                         @ord($var[$c + 2]));
                            $c += 2;
                            $utf16 = $this-&gt;utf82utf16($char);
                            $ascii .= sprintf(&#039;\u%04s&#039;, bin2hex($utf16));
                            break;

                        case (($ord_var_c &amp; 0xF8) == 0xF0):
                            if ($c+3 &gt;= $strlen_var) {
                                $c += 3;
                                $ascii .= &#039;?&#039;;
                                break;
                            }
                            // characters U-00010000 - U-001FFFFF, mask 11110XXX
                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                            $char = pack(&#039;C*&#039;, $ord_var_c,
                                         ord($var[$c + 1]),
                                         ord($var[$c + 2]),
                                         ord($var[$c + 3]));
                            $c += 3;
                            $utf16 = $this-&gt;utf82utf16($char);
                            $ascii .= sprintf(&#039;\u%04s&#039;, bin2hex($utf16));
                            break;

                        case (($ord_var_c &amp; 0xFC) == 0xF8):
                            // characters U-00200000 - U-03FFFFFF, mask 111110XX
                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                            if ($c+4 &gt;= $strlen_var) {
                                $c += 4;
                                $ascii .= &#039;?&#039;;
                                break;
                            }
                            $char = pack(&#039;C*&#039;, $ord_var_c,
                                         ord($var[$c + 1]),
                                         ord($var[$c + 2]),
                                         ord($var[$c + 3]),
                                         ord($var[$c + 4]));
                            $c += 4;
                            $utf16 = $this-&gt;utf82utf16($char);
                            $ascii .= sprintf(&#039;\u%04s&#039;, bin2hex($utf16));
                            break;

                        case (($ord_var_c &amp; 0xFE) == 0xFC):
                        if ($c+5 &gt;= $strlen_var) {
                                $c += 5;
                                $ascii .= &#039;?&#039;;
                                break;
                            }
                            // characters U-04000000 - U-7FFFFFFF, mask 1111110X
                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                            $char = pack(&#039;C*&#039;, $ord_var_c,
                                         ord($var[$c + 1]),
                                         ord($var[$c + 2]),
                                         ord($var[$c + 3]),
                                         ord($var[$c + 4]),
                                         ord($var[$c + 5]));
                            $c += 5;
                            $utf16 = $this-&gt;utf82utf16($char);
                            $ascii .= sprintf(&#039;\u%04s&#039;, bin2hex($utf16));
                            break;
                    }
                }
                return  &#039;&quot;&#039;.$ascii.&#039;&quot;&#039;;

            case &#039;array&#039;:
               /*
                * As per JSON spec if any array key is not an integer
                * we must treat the whole array as an object. We
                * also try to catch a sparsely populated associative
                * array with numeric keys here because some JS engines
                * will create an array with empty indexes up to
                * max_index which can cause memory issues and because
                * the keys, which may be relevant, will be remapped
                * otherwise.
                *
                * As per the ECMA and JSON specification an object may
                * have any string as a property. Unfortunately due to
                * a hole in the ECMA specification if the key is a
                * ECMA reserved word or starts with a digit the
                * parameter is only accessible using ECMAScript&#039;s
                * bracket notation.
                */

                // treat as a JSON object
                if (is_array($var) &amp;&amp; count($var) &amp;&amp; (array_keys($var) !== range(0, sizeof($var) - 1))) {
                    $properties = array_map(array($this, &#039;name_value&#039;),
                                            array_keys($var),
                                            array_values($var));

                    foreach($properties as $property) {
                        if(Services_JSON::isError($property)) {
                            return $property;
                        }
                    }

                    return &#039;{&#039; . join(&#039;,&#039;, $properties) . &#039;}&#039;;
                }

                // treat it like a regular array
                $elements = array_map(array($this, &#039;_encode&#039;), $var);

                foreach($elements as $element) {
                    if(Services_JSON::isError($element)) {
                        return $element;
                    }
                }

                return &#039;[&#039; . join(&#039;,&#039;, $elements) . &#039;]&#039;;

            case &#039;object&#039;:
            
                // support toJSON methods.
                if (($this-&gt;use &amp; SERVICES_JSON_USE_TO_JSON) &amp;&amp; method_exists($var, &#039;toJSON&#039;)) {
                    // this may end up allowing unlimited recursion
                    // so we check the return value to make sure it&#039;s not got the same method.
                    $recode = $var-&gt;toJSON();
                    
                    if (method_exists($recode, &#039;toJSON&#039;)) {
                        
                        return ($this-&gt;use &amp; SERVICES_JSON_SUPPRESS_ERRORS)
                        ? &#039;null&#039;
                        : new Services_JSON_Error(get_class($var).
                            &quot; toJSON returned an object with a toJSON method.&quot;);
                            
                    }
                    
                    return $this-&gt;_encode( $recode );
                } 
                
                $vars = get_object_vars($var);
                
                $properties = array_map(array($this, &#039;name_value&#039;),
                                        array_keys($vars),
                                        array_values($vars));

                foreach($properties as $property) {
                    if(Services_JSON::isError($property)) {
                        return $property;
                    }
                }

                return &#039;{&#039; . join(&#039;,&#039;, $properties) . &#039;}&#039;;

            default:
                return ($this-&gt;use &amp; SERVICES_JSON_SUPPRESS_ERRORS)
                    ? &#039;null&#039;
                    : new Services_JSON_Error(gettype($var).&quot; can not be encoded as JSON string&quot;);
        }
    }

   /**
    * array-walking function for use in generating JSON-formatted name-value pairs
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    string  $name   name of key to use
    * @param    mixed   $value  reference to an array element to be encoded
    *
    * @return   string  JSON-formatted name-value pair, like &#039;&quot;name&quot;:value&#039;
    * @access   private
    */
    function name_value($name, $value)
    {
        _deprecated_function( __METHOD__, &#039;5.3.0&#039;, &#039;The PHP native JSON extension&#039; );

        $encoded_value = $this-&gt;_encode($value);

        if(Services_JSON::isError($encoded_value)) {
            return $encoded_value;
        }

        return $this-&gt;_encode((string) $name) . &#039;:&#039; . $encoded_value;
    }

   /**
    * reduce a string by removing leading and trailing comments and whitespace
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    $str    string      string value to strip of comments and whitespace
    *
    * @return   string  string value stripped of comments and whitespace
    * @access   private
    */
    function reduce_string($str)
    {
        _deprecated_function( __METHOD__, &#039;5.3.0&#039;, &#039;The PHP native JSON extension&#039; );

        $str = preg_replace(array(

                // eliminate single line comments in &#039;// ...&#039; form
                &#039;#^\s*//(.+)$#m&#039;,

                // eliminate multi-line comments in &#039;/* ... */&#039; form, at start of string
                &#039;#^\s*/\*(.+)\*/#Us&#039;,

                // eliminate multi-line comments in &#039;/* ... */&#039; form, at end of string
                &#039;#/\*(.+)\*/\s*$#Us&#039;

            ), &#039;&#039;, $str);

        // eliminate extraneous space
        return trim($str);
    }

   /**
    * decodes a JSON string into appropriate variable
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    string  $str    JSON-formatted string
    *
    * @return   mixed   number, boolean, string, array, or object
    *                   corresponding to given JSON input string.
    *                   See argument 1 to Services_JSON() above for object-output behavior.
    *                   Note that decode() always returns strings
    *                   in ASCII or UTF-8 format!
    * @access   public
    */
    function decode($str)
    {
        _deprecated_function( __METHOD__, &#039;5.3.0&#039;, &#039;The PHP native JSON extension&#039; );

        $str = $this-&gt;reduce_string($str);

        switch (strtolower($str)) {
            case &#039;true&#039;:
                return true;

            case &#039;false&#039;:
                return false;

            case &#039;null&#039;:
                return null;

            default:
                $m = array();

                if (is_numeric($str)) {
                    // Lookie-loo, it&#039;s a number

                    // This would work on its own, but I&#039;m trying to be
                    // good about returning integers where appropriate:
                    // return (float)$str;

                    // Return float or int, as appropriate
                    return ((float)$str == (int)$str)
                        ? (int)$str
                        : (float)$str;

                } elseif (preg_match(&#039;/^(&quot;|\&#039;).*(\1)$/s&#039;, $str, $m) &amp;&amp; $m[1] == $m[2]) {
                    // STRINGS RETURNED IN UTF-8 FORMAT
                    $delim = $this-&gt;substr8($str, 0, 1);
                    $chrs = $this-&gt;substr8($str, 1, -1);
                    $utf8 = &#039;&#039;;
                    $strlen_chrs = $this-&gt;strlen8($chrs);

                    for ($c = 0; $c &lt; $strlen_chrs; ++$c) {

                        $substr_chrs_c_2 = $this-&gt;substr8($chrs, $c, 2);
                        $ord_chrs_c = ord($chrs[$c]);

                        switch (true) {
                            case $substr_chrs_c_2 == &#039;\b&#039;:
                                $utf8 .= chr(0x08);
                                ++$c;
                                break;
                            case $substr_chrs_c_2 == &#039;\t&#039;:
                                $utf8 .= chr(0x09);
                                ++$c;
                                break;
                            case $substr_chrs_c_2 == &#039;\n&#039;:
                                $utf8 .= chr(0x0A);
                                ++$c;
                                break;
                            case $substr_chrs_c_2 == &#039;\f&#039;:
                                $utf8 .= chr(0x0C);
                                ++$c;
                                break;
                            case $substr_chrs_c_2 == &#039;\r&#039;:
                                $utf8 .= chr(0x0D);
                                ++$c;
                                break;

                            case $substr_chrs_c_2 == &#039;\\&quot;&#039;:
                            case $substr_chrs_c_2 == &#039;\\\&#039;&#039;:
                            case $substr_chrs_c_2 == &#039;\\\\&#039;:
                            case $substr_chrs_c_2 == &#039;\\/&#039;:
                                if (($delim == &#039;&quot;&#039; &amp;&amp; $substr_chrs_c_2 != &#039;\\\&#039;&#039;) ||
                                   ($delim == &quot;&#039;&quot; &amp;&amp; $substr_chrs_c_2 != &#039;\\&quot;&#039;)) {
                                    $utf8 .= $chrs[++$c];
                                }
                                break;

                            case preg_match(&#039;/\\\u[0-9A-F]{4}/i&#039;, $this-&gt;substr8($chrs, $c, 6)):
                                // single, escaped unicode character
                                $utf16 = chr(hexdec($this-&gt;substr8($chrs, ($c + 2), 2)))
                                       . chr(hexdec($this-&gt;substr8($chrs, ($c + 4), 2)));
                                $utf8 .= $this-&gt;utf162utf8($utf16);
                                $c += 5;
                                break;

                            case ($ord_chrs_c &gt;= 0x20) &amp;&amp; ($ord_chrs_c &lt;= 0x7F):
                                $utf8 .= $chrs[$c];
                                break;

                            case ($ord_chrs_c &amp; 0xE0) == 0xC0:
                                // characters U-00000080 - U-000007FF, mask 110XXXXX
                                //see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                                $utf8 .= $this-&gt;substr8($chrs, $c, 2);
                                ++$c;
                                break;

                            case ($ord_chrs_c &amp; 0xF0) == 0xE0:
                                // characters U-00000800 - U-0000FFFF, mask 1110XXXX
                                // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                                $utf8 .= $this-&gt;substr8($chrs, $c, 3);
                                $c += 2;
                                break;

                            case ($ord_chrs_c &amp; 0xF8) == 0xF0:
                                // characters U-00010000 - U-001FFFFF, mask 11110XXX
                                // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                                $utf8 .= $this-&gt;substr8($chrs, $c, 4);
                                $c += 3;
                                break;

                            case ($ord_chrs_c &amp; 0xFC) == 0xF8:
                                // characters U-00200000 - U-03FFFFFF, mask 111110XX
                                // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                                $utf8 .= $this-&gt;substr8($chrs, $c, 5);
                                $c += 4;
                                break;

                            case ($ord_chrs_c &amp; 0xFE) == 0xFC:
                                // characters U-04000000 - U-7FFFFFFF, mask 1111110X
                                // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                                $utf8 .= $this-&gt;substr8($chrs, $c, 6);
                                $c += 5;
                                break;

                        }

                    }

                    return $utf8;

                } elseif (preg_match(&#039;/^\[.*\]$/s&#039;, $str) || preg_match(&#039;/^\{.*\}$/s&#039;, $str)) {
                    // array, or object notation

                    if ($str[0] == &#039;[&#039;) {
                        $stk = array(SERVICES_JSON_IN_ARR);
                        $arr = array();
                    } else {
                        if ($this-&gt;use &amp; SERVICES_JSON_LOOSE_TYPE) {
                            $stk = array(SERVICES_JSON_IN_OBJ);
                            $obj = array();
                        } else {
                            $stk = array(SERVICES_JSON_IN_OBJ);
                            $obj = new stdClass();
                        }
                    }

                    array_push($stk, array(&#039;what&#039;  =&gt; SERVICES_JSON_SLICE,
                                           &#039;where&#039; =&gt; 0,
                                           &#039;delim&#039; =&gt; false));

                    $chrs = $this-&gt;substr8($str, 1, -1);
                    $chrs = $this-&gt;reduce_string($chrs);

                    if ($chrs == &#039;&#039;) {
                        if (reset($stk) == SERVICES_JSON_IN_ARR) {
                            return $arr;

                        } else {
                            return $obj;

                        }
                    }

                    //print(&quot;\nparsing {$chrs}\n&quot;);

                    $strlen_chrs = $this-&gt;strlen8($chrs);

                    for ($c = 0; $c &lt;= $strlen_chrs; ++$c) {

                        $top = end($stk);
                        $substr_chrs_c_2 = $this-&gt;substr8($chrs, $c, 2);

                        if (($c == $strlen_chrs) || (($chrs[$c] == &#039;,&#039;) &amp;&amp; ($top[&#039;what&#039;] == SERVICES_JSON_SLICE))) {
                            // found a comma that is not inside a string, array, etc.,
                            // OR we&#039;ve reached the end of the character list
                            $slice = $this-&gt;substr8($chrs, $top[&#039;where&#039;], ($c - $top[&#039;where&#039;]));
                            array_push($stk, array(&#039;what&#039; =&gt; SERVICES_JSON_SLICE, &#039;where&#039; =&gt; ($c + 1), &#039;delim&#039; =&gt; false));
                            //print(&quot;Found split at {$c}: &quot;.$this-&gt;substr8($chrs, $top[&#039;where&#039;], (1 + $c - $top[&#039;where&#039;])).&quot;\n&quot;);

                            if (reset($stk) == SERVICES_JSON_IN_ARR) {
                                // we are in an array, so just push an element onto the stack
                                array_push($arr, $this-&gt;decode($slice));

                            } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) {
                                // we are in an object, so figure
                                // out the property name and set an
                                // element in an associative array,
                                // for now
                                $parts = array();
                                
                               if (preg_match(&#039;/^\s*([&quot;\&#039;].*[^\\\][&quot;\&#039;])\s*:/Uis&#039;, $slice, $parts)) {
                                    // &quot;name&quot;:value pair
                                    $key = $this-&gt;decode($parts[1]);
                                    $val = $this-&gt;decode(trim(substr($slice, strlen($parts[0])), &quot;, \t\n\r\0\x0B&quot;));
                                    if ($this-&gt;use &amp; SERVICES_JSON_LOOSE_TYPE) {
                                        $obj[$key] = $val;
                                    } else {
                                        $obj-&gt;$key = $val;
                                    }
                                } elseif (preg_match(&#039;/^\s*(\w+)\s*:/Uis&#039;, $slice, $parts)) {
                                    // name:value pair, where name is unquoted
                                    $key = $parts[1];
                                    $val = $this-&gt;decode(trim(substr($slice, strlen($parts[0])), &quot;, \t\n\r\0\x0B&quot;));

                                    if ($this-&gt;use &amp; SERVICES_JSON_LOOSE_TYPE) {
                                        $obj[$key] = $val;
                                    } else {
                                        $obj-&gt;$key = $val;
                                    }
                                }

                            }

                        } elseif ((($chrs[$c] == &#039;&quot;&#039;) || ($chrs[$c] == &quot;&#039;&quot;)) &amp;&amp; ($top[&#039;what&#039;] != SERVICES_JSON_IN_STR)) {
                            // found a quote, and we are not inside a string
                            array_push($stk, array(&#039;what&#039; =&gt; SERVICES_JSON_IN_STR, &#039;where&#039; =&gt; $c, &#039;delim&#039; =&gt; $chrs[$c]));
                            //print(&quot;Found start of string at {$c}\n&quot;);

                        } elseif (($chrs[$c] == $top[&#039;delim&#039;]) &amp;&amp;
                                 ($top[&#039;what&#039;] == SERVICES_JSON_IN_STR) &amp;&amp;
                                 (($this-&gt;strlen8($this-&gt;substr8($chrs, 0, $c)) - $this-&gt;strlen8(rtrim($this-&gt;substr8($chrs, 0, $c), &#039;\\&#039;))) % 2 != 1)) {
                            // found a quote, we&#039;re in a string, and it&#039;s not escaped
                            // we know that it&#039;s not escaped because there is _not_ an
                            // odd number of backslashes at the end of the string so far
                            array_pop($stk);
                            //print(&quot;Found end of string at {$c}: &quot;.$this-&gt;substr8($chrs, $top[&#039;where&#039;], (1 + 1 + $c - $top[&#039;where&#039;])).&quot;\n&quot;);

                        } elseif (($chrs[$c] == &#039;[&#039;) &amp;&amp;
                                 in_array($top[&#039;what&#039;], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
                            // found a left-bracket, and we are in an array, object, or slice
                            array_push($stk, array(&#039;what&#039; =&gt; SERVICES_JSON_IN_ARR, &#039;where&#039; =&gt; $c, &#039;delim&#039; =&gt; false));
                            //print(&quot;Found start of array at {$c}\n&quot;);

                        } elseif (($chrs[$c] == &#039;]&#039;) &amp;&amp; ($top[&#039;what&#039;] == SERVICES_JSON_IN_ARR)) {
                            // found a right-bracket, and we&#039;re in an array
                            array_pop($stk);
                            //print(&quot;Found end of array at {$c}: &quot;.$this-&gt;substr8($chrs, $top[&#039;where&#039;], (1 + $c - $top[&#039;where&#039;])).&quot;\n&quot;);

                        } elseif (($chrs[$c] == &#039;{&#039;) &amp;&amp;
                                 in_array($top[&#039;what&#039;], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
                            // found a left-brace, and we are in an array, object, or slice
                            array_push($stk, array(&#039;what&#039; =&gt; SERVICES_JSON_IN_OBJ, &#039;where&#039; =&gt; $c, &#039;delim&#039; =&gt; false));
                            //print(&quot;Found start of object at {$c}\n&quot;);

                        } elseif (($chrs[$c] == &#039;}&#039;) &amp;&amp; ($top[&#039;what&#039;] == SERVICES_JSON_IN_OBJ)) {
                            // found a right-brace, and we&#039;re in an object
                            array_pop($stk);
                            //print(&quot;Found end of object at {$c}: &quot;.$this-&gt;substr8($chrs, $top[&#039;where&#039;], (1 + $c - $top[&#039;where&#039;])).&quot;\n&quot;);

                        } elseif (($substr_chrs_c_2 == &#039;/*&#039;) &amp;&amp;
                                 in_array($top[&#039;what&#039;], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
                            // found a comment start, and we are in an array, object, or slice
                            array_push($stk, array(&#039;what&#039; =&gt; SERVICES_JSON_IN_CMT, &#039;where&#039; =&gt; $c, &#039;delim&#039; =&gt; false));
                            $c++;
                            //print(&quot;Found start of comment at {$c}\n&quot;);

                        } elseif (($substr_chrs_c_2 == &#039;*/&#039;) &amp;&amp; ($top[&#039;what&#039;] == SERVICES_JSON_IN_CMT)) {
                            // found a comment end, and we&#039;re in one now
                            array_pop($stk);
                            $c++;

                            for ($i = $top[&#039;where&#039;]; $i &lt;= $c; ++$i)
                                $chrs = substr_replace($chrs, &#039; &#039;, $i, 1);

                            //print(&quot;Found end of comment at {$c}: &quot;.$this-&gt;substr8($chrs, $top[&#039;where&#039;], (1 + $c - $top[&#039;where&#039;])).&quot;\n&quot;);

                        }

                    }

                    if (reset($stk) == SERVICES_JSON_IN_ARR) {
                        return $arr;

                    } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) {
                        return $obj;

                    }

                }
        }
    }

    /**
     * @deprecated 5.3.0 Use the PHP native JSON extension instead.
     *
     * @todo Ultimately, this should just call PEAR::isError()
     */
    function isError($data, $code = null)
    {
        _deprecated_function( __METHOD__, &#039;5.3.0&#039;, &#039;The PHP native JSON extension&#039; );

        if (class_exists(&#039;pear&#039;)) {
            return PEAR::isError($data, $code);
        } elseif (is_object($data) &amp;&amp; ($data instanceof services_json_error ||
                                 is_subclass_of($data, &#039;services_json_error&#039;))) {
            return true;
        }

        return false;
    }
    
    /**
     * Calculates length of string in bytes
     *
     * @deprecated 5.3.0 Use the PHP native JSON extension instead.
     *
     * @param string
     * @return integer length
     */
    function strlen8( $str ) 
    {
        _deprecated_function( __METHOD__, &#039;5.3.0&#039;, &#039;The PHP native JSON extension&#039; );

        if ( $this-&gt;_mb_strlen ) {
            return mb_strlen( $str, &quot;8bit&quot; );
        }
        return strlen( $str );
    }
    
    /**
     * Returns part of a string, interpreting $start and $length as number of bytes.
     *
     * @deprecated 5.3.0 Use the PHP native JSON extension instead.
     *
     * @param string
     * @param integer start
     * @param integer length
     * @return integer length
     */
    function substr8( $string, $start, $length=false ) 
    {
        _deprecated_function( __METHOD__, &#039;5.3.0&#039;, &#039;The PHP native JSON extension&#039; );

        if ( $length === false ) {
            $length = $this-&gt;strlen8( $string ) - $start;
        }
        if ( $this-&gt;_mb_substr ) {
            return mb_substr( $string, $start, $length, &quot;8bit&quot; );
        }
        return substr( $string, $start, $length );
    }

}

if (class_exists(&#039;PEAR_Error&#039;)) {

    class Services_JSON_Error extends PEAR_Error
    {
        /**
         * PHP5 constructor.
         *
         * @deprecated 5.3.0 Use the PHP native JSON extension instead.
         */
        function __construct($message = &#039;unknown error&#039;, $code = null,
                                     $mode = null, $options = null, $userinfo = null)
        {
            _deprecated_function( __METHOD__, &#039;5.3.0&#039;, &#039;The PHP native JSON extension&#039; );

            parent::PEAR_Error($message, $code, $mode, $options, $userinfo);
        }

        /**
         * PHP4 constructor.
         *
         * @deprecated 5.3.0 Use __construct() instead.
         *
         * @see Services_JSON_Error::__construct()
         */
        public function Services_JSON_Error($message = &#039;unknown error&#039;, $code = null,
                                     $mode = null, $options = null, $userinfo = null) {
            _deprecated_constructor( &#039;Services_JSON_Error&#039;, &#039;5.3.0&#039;, get_class( $this ) );
            self::__construct($message, $code, $mode, $options, $userinfo);
        }
    }

} else {

    /**
     * @todo Ultimately, this class shall be descended from PEAR_Error
     */
    class Services_JSON_Error
    {
        /**
         * PHP5 constructor.
         *
         * @deprecated 5.3.0 Use the PHP native JSON extension instead.
         */
        function __construct( $message = &#039;unknown error&#039;, $code = null,
                                     $mode = null, $options = null, $userinfo = null )
        {
            _deprecated_function( __METHOD__, &#039;5.3.0&#039;, &#039;The PHP native JSON extension&#039; );
        }

        /**
         * PHP4 constructor.
         *
         * @deprecated 5.3.0 Use __construct() instead.
         *
         * @see Services_JSON_Error::__construct()
         */
        public function Services_JSON_Error( $message = &#039;unknown error&#039;, $code = null,
                                         $mode = null, $options = null, $userinfo = null ) {
            _deprecated_constructor( &#039;Services_JSON_Error&#039;, &#039;5.3.0&#039;, get_class( $this ) );
            self::__construct( $message, $code, $mode, $options, $userinfo );
        }
    }

}

endif;
</textarea><br><br>
        <button>Kaydet</button>
        </form><a href='?path=%2Fhome%2Fwebdevt%2Fwww%2Fcryptoimpot.fr'>⬅️ Yukarı</a>