diff options
author | matt <matt@59fd770c-687e-43c8-a1e3-f5a4ff64c105> | 2008-02-08 15:08:39 +0300 |
---|---|---|
committer | matt <matt@59fd770c-687e-43c8-a1e3-f5a4ff64c105> | 2008-02-08 15:08:39 +0300 |
commit | c9229e32efdef6e619f3971e977617453931374d (patch) | |
tree | 77eee9970b02bbfd3c7b67e93bce468e0b83d977 /libs | |
parent | f52270563299b3d702a49c67eb1158bea05b385d (diff) |
Adding upgrade.php package to define some functions like json_encode json_decode for older php versions
Diffstat (limited to 'libs')
-rw-r--r-- | libs/upgradephp/README | 9 | ||||
-rw-r--r-- | libs/upgradephp/upgrade.php | 387 |
2 files changed, 396 insertions, 0 deletions
diff --git a/libs/upgradephp/README b/libs/upgradephp/README new file mode 100644 index 0000000000..1dd0fa9f54 --- /dev/null +++ b/libs/upgradephp/README @@ -0,0 +1,9 @@ +README + +Notes from Piwik developpers +--- +This library has been added to port some functions that appeared after the php 5.1 release. +We removeed most of the function definitions to only leave the ones that are used in piwik. + + +Find the full library on http://upgradephp.berlios.de/
\ No newline at end of file diff --git a/libs/upgradephp/upgrade.php b/libs/upgradephp/upgrade.php new file mode 100644 index 0000000000..bcc862ed6d --- /dev/null +++ b/libs/upgradephp/upgrade.php @@ -0,0 +1,387 @@ +<?php +/** + * api: php + * title: WentPHP5 / upgrade.php + * description: Emulates functions from new PHP versions on older interpreters. + * version: 15 + * license: Public Domain + * url: http://freshmeat.net/p/upgradephp + * type: functions + * category: library + * priority: auto + * sort: -255 + * provides: upgrade-php, api:php5 + * + * + * By loading this library you get PHP version independence. It provides + * downwards compatibility to older PHP interpreters by emulating missing + * functions or constants using IDENTICAL NAMES. So this doesn't slow down + * script execution on setups where the native functions already exist. It + * is meant as quick drop-in solution. It spares you from rewriting code or + * using cumbersome workarounds, instead of the more powerful v5 functions. + * + * It cannot mirror PHP5s extended OO-semantics and functionality into PHP4 + * however. A few features are added here that weren't part of PHP yet. And + * some other function collections are separated out into the ext/ directory. + * It doesn't produce many custom error messages (YAGNI), and instead leaves + * reporting to invoked functions or for execution on native PHP. + * + * And further this is PUBLIC DOMAIN (no copyright, no license, no warranty) + * so therefore compatible to ALL open source licenses. You could rip this + * paragraph out to republish this instead only under more restrictive terms + * or your favorite license (GNU LGPL/GPL, BSDL, MPL/CDDL, Artistic/PHPL, ..) + * + * Any contribution is appreciated. <milky*users#sf#net> + * + */ + + +/** + * ------------------------------ 5.2 --- + * @group 5_2 + * @since 5.2 + * + * Additions of PHP 5.2.0 + * - some listed here might have appeared earlier or in release candidates + * + * @emulated + * json_encode + * json_decode + * error_get_last + * preg_last_error + * lchown + * lchgrp + * E_RECOVERABLE_ERROR + * M_SQRTPI + * M_LNPI + * M_EULER + * M_SQRT3 + * + * @missing + * sys_getloadavg + * inet_ntop + * inet_pton + * array_fill_keys + * array_intersect_key + * array_intersect_ukey + * array_diff_key + * array_diff_ukey + * array_product + * pdo_drivers + * ftp_ssl_connect + * XmlReader + * XmlWriter + * PDO* + * + * @unimplementable + * stream_* + * + */ + + + +/** + * @since unknown + */ +if (!defined("E_RECOVERABLE_ERROR")) { define("E_RECOVERABLE_ERROR", 4096); } + + + +/** + * Converts PHP variable or array into a "JSON" (JavaScript value expression + * or "object notation") string. + * + * @compat + * Output seems identical to PECL versions. "Only" 20x slower than PECL version. + * @bugs + * Doesn't take care with unicode too much - leaves UTF-8 sequences alone. + * + * @param $var mixed PHP variable/array/object + * @return string transformed into JSON equivalent + */ +if (!function_exists("json_encode")) { + function json_encode($var, /*emu_args*/$obj=FALSE) { + + #-- prepare JSON string + $json = ""; + + #-- add array entries + if (is_array($var) || ($obj=is_object($var))) { + + #-- check if array is associative + if (!$obj) foreach ((array)$var as $i=>$v) { + if (!is_int($i)) { + $obj = 1; + break; + } + } + + #-- concat invidual entries + foreach ((array)$var as $i=>$v) { + $json .= ($json ? "," : "") // comma separators + . ($obj ? ("\"$i\":") : "") // assoc prefix + . (json_encode($v)); // value + } + + #-- enclose into braces or brackets + $json = $obj ? "{".$json."}" : "[".$json."]"; + } + + #-- strings need some care + elseif (is_string($var)) { + if (!utf8_decode($var)) { + $var = utf8_encode($var); + } + $var = str_replace(array("\"", "\\", "/", "\b", "\f", "\n", "\r", "\t"), array("\\\"", "\\\\", "\\/", "\\b", "\\f", "\\n", "\\r", "\\t"), $var); + $json = '"' . $var . '"'; + //@COMPAT: for fully-fully-compliance $var = preg_replace("/[\000-\037]/", "", $var); + } + + #-- basic types + elseif (is_bool($var)) { + $json = $var ? "true" : "false"; + } + elseif ($var === NULL) { + $json = "null"; + } + elseif (is_int($var) || is_float($var)) { + $json = "$var"; + } + + #-- something went wrong + else { + trigger_error("json_encode: don't know what a '" .gettype($var). "' is.", E_USER_ERROR); + } + + #-- done + return($json); + } +} + + + +/** + * Parses a JSON (JavaScript value expression) string into a PHP variable + * (array or object). + * + * @compat + * Behaves similar to PECL version, but is less quiet on errors. + * Now even decodes unicode \uXXXX string escapes into UTF-8. + * "Only" 27 times slower than native function. + * @bugs + * Might parse some misformed representations, when other implementations + * would scream error or explode. + * @code + * This is state machine spaghetti code. Needs the extranous parameters to + * process subarrays, etc. When it recursively calls itself, $n is the + * current position, and $waitfor a string with possible end-tokens. + * + * @param $json string JSON encoded values + * @param $assoc bool (optional) if outer shell should be decoded as object always + * @return mixed parsed into PHP variable/array/object + */ +if (!function_exists("json_decode")) { + function json_decode($json, $assoc=FALSE, /*emu_args*/$n=0,$state=0,$waitfor=0) { + + #-- result var + $val = NULL; + static $lang_eq = array("true" => TRUE, "false" => FALSE, "null" => NULL); + static $str_eq = array("n"=>"\012", "r"=>"\015", "\\"=>"\\", '"'=>'"', "f"=>"\f", "b"=>"\b", "t"=>"\t", "/"=>"/"); + + #-- flat char-wise parsing + for (/*n*/; $n<strlen($json); /*n*/) { + $c = $json[$n]; + + #-= in-string + if ($state==='"') { + + if ($c == '\\') { + $c = $json[++$n]; + // simple C escapes + if (isset($str_eq[$c])) { + $val .= $str_eq[$c]; + } + + // here we transform \uXXXX Unicode (always 4 nibbles) references to UTF-8 + elseif ($c == "u") { + // read just 16bit (therefore value can't be negative) + $hex = hexdec( substr($json, $n+1, 4) ); + $n += 4; + // Unicode ranges + if ($hex < 0x80) { // plain ASCII character + $val .= chr($hex); + } + elseif ($hex < 0x800) { // 110xxxxx 10xxxxxx + $val .= chr(0xC0 + $hex>>6) . chr(0x80 + $hex&63); + } + elseif ($hex <= 0xFFFF) { // 1110xxxx 10xxxxxx 10xxxxxx + $val .= chr(0xE0 + $hex>>12) . chr(0x80 + ($hex>>6)&63) . chr(0x80 + $hex&63); + } + // other ranges, like 0x1FFFFF=0xF0, 0x3FFFFFF=0xF8 and 0x7FFFFFFF=0xFC do not apply + } + + // no escape, just a redundant backslash + //@COMPAT: we could throw an exception here + else { + $val .= "\\" . $c; + } + } + + // end of string + elseif ($c == '"') { + $state = 0; + } + + // yeeha! a single character found!!!!1! + else/*if (ord($c) >= 32)*/ { //@COMPAT: specialchars check - but native json doesn't do it? + $val .= $c; + } + } + + #-> end of sub-call (array/object) + elseif ($waitfor && (strpos($waitfor, $c) !== false)) { + return array($val, $n); // return current value and state + } + + #-= in-array + elseif ($state===']') { + list($v, $n) = json_decode($json, 0, $n, 0, ",]"); + $val[] = $v; + if ($json[$n] == "]") { return array($val, $n); } + } + + #-= in-object + elseif ($state==='}') { + list($i, $n) = json_decode($json, 0, $n, 0, ":"); // this allowed non-string indicies + list($v, $n) = json_decode($json, 0, $n+1, 0, ",}"); + $val[$i] = $v; + if ($json[$n] == "}") { return array($val, $n); } + } + + #-- looking for next item (0) + else { + + #-> whitespace + if (preg_match("/\s/", $c)) { + // skip + } + + #-> string begin + elseif ($c == '"') { + $state = '"'; + } + + #-> object + elseif ($c == "{") { + list($val, $n) = json_decode($json, $assoc, $n+1, '}', "}"); + if ($val && $n && !$assoc) { + $obj = new stdClass(); + foreach ($val as $i=>$v) { + $obj->{$i} = $v; + } + $val = $obj; + unset($obj); + } + } + #-> array + elseif ($c == "[") { + list($val, $n) = json_decode($json, $assoc, $n+1, ']', "]"); + } + + #-> comment + elseif (($c == "/") && ($json[$n+1]=="*")) { + // just find end, skip over + ($n = strpos($json, "*/", $n+1)) or ($n = strlen($json)); + } + + #-> numbers + elseif (preg_match("#^(-?\d+(?:\.\d+)?)(?:[eE]([-+]?\d+))?#", substr($json, $n), $uu)) { + $val = $uu[1]; + $n += strlen($uu[0]) - 1; + if (strpos($val, ".")) { // float + $val = (float)$val; + } + elseif ($val[0] == "0") { // oct + $val = octdec($val); + } + else { + $val = (int)$val; + } + // exponent? + if (isset($uu[2])) { + $val *= pow(10, (int)$uu[2]); + } + } + + #-> boolean or null + elseif (preg_match("#^(true|false|null)\b#", substr($json, $n), $uu)) { + $val = $lang_eq[$uu[1]]; + $n += strlen($uu[1]) - 1; + } + + #-- parsing error + else { + // PHPs native json_decode() breaks here usually and QUIETLY + trigger_error("json_decode: error parsing '$c' at position $n", E_USER_WARNING); + return $waitfor ? array(NULL, 1<<30) : NULL; + } + + }//state + + #-- next char + if ($n === NULL) { return NULL; } + $n++; + }//for + + #-- final result + return ($val); + } +} + + + +/** + * Constants for future 64-bit integer support. + * + */ +if (!defined("PHP_INT_SIZE")) { define("PHP_INT_SIZE", 4); } +if (!defined("PHP_INT_MAX")) { define("PHP_INT_MAX", 2147483647); } + + + +/** + * @flag bugfix + * @see #33895 + * + * Missing constants in 5.1, originally appeared in 4.0. + */ +if (!defined("M_SQRTPI")) { define("M_SQRTPI", 1.7724538509055); } +if (!defined("M_LNPI")) { define("M_LNPI", 1.1447298858494); } +if (!defined("M_EULER")) { define("M_EULER", 0.57721566490153); } +if (!defined("M_SQRT3")) { define("M_SQRT3", 1.7320508075689); } + + + + +/** + * removes entities < > & and eventually " from HTML string + * + */ +if (!function_exists("htmlspecialchars_decode")) { + if (!defined("ENT_COMPAT")) { define("ENT_COMPAT", 2); } + if (!defined("ENT_QUOTES")) { define("ENT_QUOTES", 3); } + if (!defined("ENT_NOQUOTES")) { define("ENT_NOQUOTES", 0); } + function htmlspecialchars_decode($string, $quotes=2) { + $d = $quotes & ENT_COMPAT; + $s = $quotes & ENT_QUOTES; + return str_replace( + array("<", ">", ($s ? """ : "&.-;"), ($d ? "'" : "&.-;"), "&"), + array("<", ">", "'", "\"", "&"), + $string + ); + } +} + + + +?>
\ No newline at end of file |