json.lib.php

Go to the documentation of this file.

<?php
/* Copyright (C) 2011-2012  Laurent Destailleur <eldy@users.sourceforge.net>
 * Copyright (C) 2011-2012  Regis Houssin   <regis.houssin@inodbox.com>
 * Copyright (C) 2024   MDW             <mdeweerd@users.noreply.github.com>
 * Copyright (C) 2024       Frédéric France             <frederic.france@free.fr>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 * or see https://www.gnu.org/
 */
 
if (!function_exists('json_encode') || defined('PHPUNIT_MODE')) {
  function dol_json_encode($elements)
  {
    dol_syslog("For better performance, enable the native json in your PHP", LOG_WARNING);
 
    $num = 0;
    if (is_object($elements)) { // Count number of properties for an object
      foreach ($elements as $key => $value) {
        $num++;
      }
    } else {
      if (is_countable($elements)) {
        $num = count($elements);
      }
    }
 
    // determine type
    if (is_numeric($elements)) {
      return $elements;
    } elseif (is_string($elements)) {
      return '"'.$elements.'"';
    }
    if (is_numeric(key($elements)) && key($elements) == 0) {
      // indexed (list)
      $keysofelements = array_keys($elements); // Elements array must have key that does not start with 0 and end with num-1, so we will use this later.
      $output = '[';
      for ($i = 0, $last = ($num - 1); $i < $num; $i++) {
        if (!isset($elements[$keysofelements[$i]])) {
          continue;
        }
        if (is_array($elements[$keysofelements[$i]]) || is_object($elements[$keysofelements[$i]])) {
          $output .= json_encode($elements[$keysofelements[$i]]);
        } else {
          $output .= _val($elements[$keysofelements[$i]]);
        }
        if ($i !== $last) {
          $output .= ',';
        }
      }
      $output .= ']';
    } else {
      // associative (object)
      $output = '{';
      $last = $num - 1;
      $i = 0;
      $tmpelements = array();
      if (is_array($elements)) {
        $tmpelements = $elements;
      }
      if (is_object($elements)) {
        $tmpelements = get_object_vars($elements);
      }
      foreach ($tmpelements as $key => $value) {
        $output .= '"'.$key.'":';
        if (is_array($value)) {
          $output .= json_encode($value);
        } else {
          $output .= _val($value);
        }
        if ($i !== $last) {
          $output .= ',';
        }
        ++$i;
      }
      $output .= '}';
    }
 
    // return
    return $output;
  }
 
  function _val($val)
  {
    if (is_string($val)) {
      // STRINGS ARE EXPECTED TO BE IN ASCII OR UTF-8 FORMAT
      $ascii = '';
      $strlen_var = strlen($val);
 
      /*
       * Iterate over every character in the string,
       * escaping with a slash or encoding to UTF-8 where necessary
       */
      for ($c = 0; $c < $strlen_var; ++$c) {
        $ord_var_c = ord($val[$c]);
 
        switch (true) {
          case $ord_var_c == 0x08:
            $ascii .= '\b';
            break;
          case $ord_var_c == 0x09:
            $ascii .= '\t';
            break;
          case $ord_var_c == 0x0A:
            $ascii .= '\n';
            break;
          case $ord_var_c == 0x0C:
            $ascii .= '\f';
            break;
          case $ord_var_c == 0x0D:
            $ascii .= '\r';
            break;
 
          case $ord_var_c == 0x22:
          case $ord_var_c == 0x2F:
          case $ord_var_c == 0x5C:
            // double quote, slash, slosh
            $ascii .= '\\'.$val[$c];
            break;
 
          case (($ord_var_c >= 0x20) && ($ord_var_c <= 0x7F)):
            // characters U-00000000 - U-0000007F (same as ASCII)
            $ascii .= $val[$c];
            break;
 
          case (($ord_var_c & 0xE0) == 0xC0):
            // characters U-00000080 - U-000007FF, mask 110XXXXX
            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
            $char = pack('C*', $ord_var_c, ord($val[$c + 1]));
            $c += 1;
            $utf16 = utf82utf16($char);
            $ascii .= sprintf('\u%04s', bin2hex($utf16));
            break;
 
          case (($ord_var_c & 0xF0) == 0xE0):
            // characters U-00000800 - U-0000FFFF, mask 1110XXXX
            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
            $char = pack('C*', $ord_var_c, ord($val[$c + 1]), ord($val[$c + 2]));
            $c += 2;
            $utf16 = utf82utf16($char);
            $ascii .= sprintf('\u%04s', bin2hex($utf16));
            break;
 
          case (($ord_var_c & 0xF8) == 0xF0):
            // characters U-00010000 - U-001FFFFF, mask 11110XXX
            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
            $char = pack('C*', $ord_var_c, ord($val[$c + 1]), ord($val[$c + 2]), ord($val[$c + 3]));
            $c += 3;
            $utf16 = utf82utf16($char);
            $ascii .= sprintf('\u%04s', bin2hex($utf16));
            break;
 
          case (($ord_var_c & 0xFC) == 0xF8):
            // characters U-00200000 - U-03FFFFFF, mask 111110XX
            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
            $char = pack('C*', $ord_var_c, ord($val[$c + 1]), ord($val[$c + 2]), ord($val[$c + 3]), ord($val[$c + 4]));
            $c += 4;
            $utf16 = utf82utf16($char);
            $ascii .= sprintf('\u%04s', bin2hex($utf16));
            break;
 
          case (($ord_var_c & 0xFE) == 0xFC):
            // characters U-04000000 - U-7FFFFFFF, mask 1111110X
            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
            $char = pack('C*', $ord_var_c, ord($val[$c + 1]), ord($val[$c + 2]), ord($val[$c + 3]), ord($val[$c + 4]), ord($val[$c + 5]));
            $c += 5;
            $utf16 = utf82utf16($char);
            $ascii .= sprintf('\u%04s', bin2hex($utf16));
            break;
        }
      }
 
      return '"'.$ascii.'"';
    } elseif (is_int($val)) {
      return sprintf('%d', $val);
    } elseif (is_float($val)) {
      return sprintf('%F', $val);
    } elseif (is_bool($val)) {
      return ($val ? 'true' : 'false');
    } else {
      return 'null';
    }
  }
 
 
  function utf82utf16($utf8)
  {
    // oh please oh please oh please oh please oh please
    if (function_exists('mb_convert_encoding')) {
      return mb_convert_encoding($utf8, 'UTF-16', 'UTF-8');
    }
 
    switch (strlen($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 & (ord($utf8[0]) >> 2)).chr((0xC0 & (ord($utf8[0]) << 6)) | (0x3F & 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 & (ord($utf8[0]) << 4)) | (0x0F & (ord($utf8[1]) >> 2))).chr((0xC0 & (ord($utf8[1]) << 6)) | (0x7F & ord($utf8[2])));
    }
 
    // ignoring UTF-32 for now, sorry
    return '';
  }
}
 
if (!function_exists('json_encode')) {
  function json_encode($elements)
  {
    // @phan-suppress-next-line PhanDeprecatedFunction
    return dol_json_encode($elements);
  }
}
 
 
if (!function_exists('json_decode') || defined('PHPUNIT_MODE')) {
  function dol_json_decode($json, $assoc = false)
  {
    dol_syslog("For better performance and security, enable the native json in your PHP", LOG_WARNING);
 
    $comment = false;
 
    $out = '';
    $strLength = strlen($json); // Must stay strlen and not dol_strlen because we want technical length, not visible length
 
    if (is_numeric($json)) {
      return $json;
    }
 
    for ($i = 0; $i < $strLength; $i++) {
      if (!$comment) {
        if ($i == 0 && !in_array($json[$i], array('{', '[', '"', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'))) {
          // Not a json format
          return false;
        }
        if (($json[$i] == '{') || ($json[$i] == '[')) {
          $out .= 'array(';
        } elseif (($json[$i] == '}') || ($json[$i] == ']')) {
          $out .= ')';
        } elseif ($json[$i] == ':') {
          $out .= ' => ';
        } else {
          $out .= $json[$i];
        }
      } else {
        $out .= $json[$i];
      }
      // @phan-suppress-next-line PhanCompatibleNegativeStringOffset
      if ($i >= 1 && $json[$i] == '"' && $json[$i - 1] != "\\") {
        $comment = !$comment;
      }
    }
 
    $out = _unval($out);
 
    $array = array();
 
    // Return an array
    if ($out != '') {
      try {
        // @phan-suppress-next-line PhanPluginUnsafeEval
        eval('$array = '.$out.';');   // not secured but this is no mode used as php json lib is always expected to be loaded now.
      } catch (Exception $e) {
        $array = array();
      }
    }
 
    // Return an object
    if (!$assoc) {
      if (!empty($array)) {
        $object = false;
        if (count($array) > 0) {
          $object = (object) array();
        }
        foreach ($array as $key => $value) {
          if ($key) {
            $object->{$key} = $value;
          }
        }
 
        return $object;
      }
 
      return false;
    }
 
    return $array;
  }
 
  function _unval($val)
  {
    $reg = array();
    while (preg_match('/\\\u([0-9A-F]{2})([0-9A-F]{2})/i', $val, $reg)) {
      // single, escaped unicode character
      $utf16 = chr(hexdec($reg[1])).chr(hexdec($reg[2]));
      $utf8  = utf162utf8($utf16);
      $val = preg_replace('/\\\u'.$reg[1].$reg[2].'/i', $utf8, $val);
    }
    return $val;
  }
 
  function utf162utf8($utf16)
  {
    // oh please oh please oh please oh please oh please
    if (function_exists('mb_convert_encoding')) {
      return mb_convert_encoding($utf16, 'UTF-8', 'UTF-16');
    }
 
    $bytes = (ord($utf16[0]) << 8) | ord($utf16[1]);
 
    switch (true) {
      case ((0x7F & $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($bytes);
 
      case (0x07FF & $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 >> 6) & 0x1F))
        . chr(0x80 | ($bytes & 0x3F));
 
      case (0xFFFF & $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 >> 12) & 0x0F))
        . chr(0x80 | (($bytes >> 6) & 0x3F))
        . chr(0x80 | ($bytes & 0x3F));
    }
 
    // ignoring UTF-32 for now, sorry
    return '';
  }
}
 
if (!function_exists('json_decode')) {
  function json_decode($json, $assoc = false)
  {
    // @phan-suppress-next-line PhanDeprecatedFunction
    return dol_json_decode($json, $assoc);
  }
}