some more replacements

* origin/master:
  Patches #67739
  PHP_INT_MIN and _MAX tests
  NEWS and UPGRADING
  Added PHP_INT_MIN

Conflicts:
	main/main.c

.gitattributes

@@ -22,6 +22,10 @@ sapi/nsapi/nsapi.c              ident
 sapi/continuity/capi.c          ident
 Zend/RFCs/002.txt               ident
 Zend/RFCs/003.txt               ident
+ext/exif/exif.c                 ident
+ext/ldap/ldap.c                 ident
+ext/pdo_pgsql/pdo_pgsql.c       ident
+ext/tidy/tidy.c                 ident
 NEWS                            merge=NEWS
 UPGRADING                       merge=NEWS
 UPGRADING.INTERNALS             merge=NEWS

.gitignore

@@ -246,6 +246,8 @@ sapi/fpm/php-fpm.1
 sapi/fpm/init.d.php-fpm
 sapi/fpm/php-fpm.conf
 sapi/fpm/fpm/php-cgi
+sapi/phpdbg/phpdbg_parser.c
+sapi/phpdbg/phpdbg_parser.h
 sapi/phpdbg/phpdbg
 scripts/php-config
 scripts/phpize

.travis.yml

@@ -5,7 +5,11 @@ php:
     - 5.4
 
 notifications:
-    email: false
+    email: 
+       on_failure: change
+
+cache: 
+    - apt
 
 env:
     global:
@@ -15,8 +19,16 @@ env:
       - PDO_MYSQL_TEST_USER=travis
       - PDO_MYSQL_TEST_PASS=
       - PDO_MYSQL_TEST_HOST=127.0.0.1
-    matrix:
       - REPORT_EXIT_STATUS=1
+    matrix:
+      - ENABLE_MAINTAINER_ZTS=0 ENABLE_DEBUG=0
+      - ENABLE_MAINTAINER_ZTS=1 ENABLE_DEBUG=1
+
+before_install:
+    - sudo apt-get update -qq
+    - sudo apt-get install -y libenchant-dev libaspell-dev libpspell-dev librecode-dev
+    - sudo cp ./travis/de /var/lib/locales/supported.d/de
+    - sudo dpkg-reconfigure locales
 
 before_script:
     # Compile PHP
@@ -29,4 +41,6 @@ before_script:
     - . ./travis/ext/pdo_pgsql/setup.sh
 
 # Run PHPs run-tests.php 
-script: ./sapi/cli/php run-tests.php -p `pwd`/sapi/cli/php -g "FAIL,XFAIL,BORK,WARN,LEAK,SKIP" --show-diff --set-timeout 120
+script:
+    - ./sapi/cli/php run-tests.php -p `pwd`/sapi/cli/php -g "FAIL,XFAIL,BORK,WARN,LEAK,SKIP" --show-diff --set-timeout 120
+    - ./sapi/cli/php sapi/phpdbg/tests/run-tests.php -diff2stdout --phpdbg sapi/phpdbg/phpdbg

LICENSE

@@ -1,6 +1,6 @@
 -------------------------------------------------------------------- 
                   The PHP License, version 3.01
-Copyright (c) 1999 - 2012 The PHP Group. All rights reserved.
+Copyright (c) 1999 - 2014 The PHP Group. All rights reserved.
 -------------------------------------------------------------------- 
 
 Redistribution and use in source and binary forms, with or without

Makefile.gcov

@@ -14,7 +14,7 @@ php_lcov.info: lcov-test
 	@rm -rf lcov_data/
 	@$(mkinstalldirs) lcov_data/
 	@echo
-	-@files=`find . -name \*.gcda -o -name \*.gcno -o -name \*.da -o -name \*.c -o -name \*.h | sed -e 's/^\.\///' | sed -e 's/\.gcda//g' -e 's/\.gcno//g' -e 's/\.da//g' | $(EGREP) $(LCOV_INCLUDE) | uniq` ;\
+	-@files=`find . -name \*.gcda -o -name \*.gcno -o -name \*.da -o -name \*.c -o -name \*.h | sed -e 's/^\.\///' | sed -e 's/\.gcda//g' -e 's/\.gcno//g' -e 's/\.da//g' | $(EGREP) $(LCOV_INCLUDE) | sed -e 's/.libs/zzzz/g' | sort | sed -e 's/zzzz/.libs/g' | uniq` ;\
 	for x in $$files; do \
 		echo -n . ;\
 		y=`echo $$x | sed -e 's!\.libs/!!'`; \

Makefile.global

@@ -115,7 +115,6 @@ clean:
 	find . -name \*.la -o -name \*.a | xargs rm -f 
 	find . -name \*.so | xargs rm -f
 	find . -name .libs -a -type d|xargs rm -rf
-	find . -name \*.1 | xargs rm -f
 	rm -f libphp$(PHP_MAJOR_VERSION).la $(SAPI_CLI_PATH) $(SAPI_CGI_PATH) $(SAPI_MILTER_PATH) $(SAPI_LITESPEED_PATH) $(SAPI_FPM_PATH) $(OVERALL_TARGET) modules/* libs/*
 
 distclean: clean

NEWS

@@ -1,136 +1,23 @@
 PHP                                                                        NEWS
 |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
-?? ??? 2014, PHP 5.6.0 Alpha 3
+?? ??? 20??, PHP 5.7.0 
 
-13 Feb 2014, PHP 5.6.0 Alpha 2
-- Core:
-  . Added T_POW (**) operator
-    (RFC: https://wiki.php.net/rfc/pow-operator). (Tjerk Meesters)
-
-- mysqli
-  . Added new function mysqli_get_links_stats() as well as new INI variable
-    mysqli.rollback_on_cached_plink of type bool (Andrey)
-
-- PCRE:
-  . Upgraded to PCRE 8.34. (Anatol)
-
-
-23 Jan 2014, PHP 5.6.0 Alpha 1
 - CLI server:
-  . Added some MIME types to the CLI web server. (Chris Jones)
+  . Refactor MIME type handling to use a hash table instead of linear search.
+    (Adam)
+  . Update the MIME type list from the one shipped by Apache HTTPD. (Adam)
 
 - Core:
-  . Improved IS_VAR operands fetching. (Laruence, Dmitry)
-  . Improved empty string handling. Now ZE uses an interned string instead of
-    allocation new empty string each time. (Laruence, Dmitry)
-  . Implemented internal operator overloading
-    (RFC: https://wiki.php.net/rfc/operator_overloading_gmp). (Nikita)
-  . Made calls from incompatible context issue an E_DEPRECATED warning instead
-    of E_STRICT (phase 1 of RFC: https://wiki.php.net/rfc/incompat_ctx).
-	(Gustavo)
-  . Uploads equal or greater than 2GB in size are now accepted.
-    (Ralf Lang, Mike)
-  . Reduced POST data memory usage by 200-300%. Changed INI setting
-    always_populate_raw_post_data to throw a deprecation warning when enabling
-	and to accept -1 for never populating the $HTTP_RAW_POST_DATA global 
-	variable, which will be the default in future PHP versions. (Mike)
-  . Implemented dedicated syntax for variadic functions
-    (RFC: https://wiki.php.net/rfc/variadics). (Nikita)
-  . Fixed bug #50333 Improving multi-threaded scalability by using
-    emalloc/efree/estrdup (Anatol, Dmitry)
-  . Implemented constant scalar expressions (with support for constants)
-    (RFC: https://wiki.php.net/rfc/const_scalar_exprs). (Bob)
-  . Fixed bug #65784 (Segfault with finally). (Laruence, Dmitry)
-  . Fixed bug #66509 (copy() arginfo has changed starting from 5.4). (willfitch)
+  . Added PHP_INT_MIN constant. (Andrea)
 
-- cURL:
-  . Implemented FR #65646 (re-enable CURLOPT_FOLLOWLOCATION with open_basedir
-    or safe_mode). (Adam)
-
-- GMP:
-  . Moved GMP to use object as the underlying structure and implemented various
-    improvements based on this.
-    (RFC: https://wiki.php.net/rfc/operator_overloading_gmp). (Nikita)
-  . Added gmp_root() and gmp_rootrem() functions for calculating nth roots.
-    (Nikita)
-
-- Hash:
-  . Added gost-crypto (CryptoPro S-box) GOST hash algo. (Manuel Mausz)
-
-- JSON:
-  . Fixed case part of bug #64874 ("json_decode handles whitespace and
-    case-sensitivity incorrectly")
-
-- mysqlnd:
-  . Disabled flag for SP OUT variables for 5.5+ servers as they are not natively
-    supported by the overlying APIs. (Andrey)
-
-- OPcache:
-  . Added an optimization of class constants and constant calls to some
-    internal functions (Laruence, Dmitry)
-  . Added an optimization pass to convert FCALL_BY_NAME into DO_FCALL.
-    (Laruence, Dmitry)
-  . Added an optimization pass to merged identical constants (and related
-    cache_slots) in op_array->literals table. (Laruence, Dmitry)
-  . Added script level constant replacement optimization pass. (Dmitry)
-
-- Openssl:
-  . Added crypto_method option for the ssl stream context. (Martin Jansen)
-  . Added certificate fingerprint support. (Tjerk Meesters)
-  . Added explicit TLSv1.1 and TLSv1.2 stream transports. (Daniel Lowrey)
-  . Fixed bug #65729 (CN_match gives false positive). (Tjerk Meesters)
-  . Peer name verification matches SAN DNS names for certs using
-    the Subject Alternative Name x509 extension. (Daniel Lowrey)
-  . Fixed segfault when built against OpenSSL>=1.0.1 (Daniel Lowrey)
-  . Peer certificates now verified by default in client socket operations
-    (RFC: https://wiki.php.net/rfc/tls-peer-verification). (Daniel Lowrey)
-  . Added SPKAC support. (Jason Gerfen)
-
-- PDO_pgsql:
-  . Fixed Bug #42614 (PDO_pgsql: add pg_get_notify support). (Matteo)
-  . Fixed Bug #63657 (pgsqlCopyFromFile, pgsqlCopyToArray use Postgres < 7.3
-    syntax). (Matteo)
-
-- phpdbg:
-  . Included phpdbg sapi (RFC: https://wiki.php.net/rfc/phpdbg).
-    (Felipe Pena, Joe Watkins and Bob Weinand)
-
-- pgsql:
-  . pg_version() returns full report which obtained by PQparameterStatus().
-    (Yasuo)
-  . Added pg_lo_truncate(). (Yasuo)
-  . Added 64bit large object support for PostgreSQL 9.3 and later. (Yasuo)
-
-- Session:
-  . Fixed Bug #65315 (session.hash_function silently fallback to default md5)
-    (Yasuo)
-  . Implemented Request #54649 (Create session_serializer_name()). (Yasuo)
-  . Implemented Request #17860 (Session write short circuit). (Yasuo)
-  . Implemented Request #20421 (session_abort() and session_reset() function).
-    (Yasuo)
-  . Implemented Request #11100 (session_gc() function). (Yasuo)
+- DBA:
+  . Fixed bug #62490 (dba_delete returns true on missing item (inifile)). (Mike)
 
 - Standard:
-  . Implemented FR #65634 (HTTP wrapper is very slow with protocol_version
-    1.1). (Adam)
-  . Implemented Change crypt() behavior w/o salt RFC. (Yasuo)
-    https://wiki.php.net/rfc/crypt_function_salt
-  . Implemented request #49824 (Change array_fill() to allow creating empty
-    array). (Nikita)
+  . Removed call_user_method() and call_user_method_array() functions. (Kalle)
+  . Fix user session handlers (See rfc:session.user.return-value). (Sara)
 
-- XMLReader:
-  . Fixed bug #55285 (XMLReader::getAttribute/No/Ns methods inconsistency). 
-    (Mike)
-
-- Zip:
-  . update libzip to version 1.11.2.
-    PHP don't use any ilibzip private symbol anymore.  (Pierre, Remi)
-  . new method ZipArchive::setPassword($password). (Pierre)
-  . add --with-libzip option to build with system libzip. (Remi)
-  . new methods:
-    ZipArchive::setExternalAttributesName($name, $opsys, $attr [, $flags])
-    ZipArchive::setExternalAttributesIndex($idx, $opsys, $attr [, $flags])
-    ZipArchive::getExternalAttributesName($name, &$opsys, &$attr [, $flags])
-    ZipArchive::getExternalAttributesIndex($idx, &$opsys, &$attr [, $flags])
+- XSL:
+  . Fixed bug #64776 (The XSLT extension is not thread safe). (Mike)
 
 <<< NOTE: Insert NEWS from last stable release here prior to actual release! >>>

README.PARAMETER_PARSING_API

@@ -58,13 +58,14 @@ Type specifiers
       zend_fcall_info and zend_fcall_info_cache)
  h  - array (returned as HashTable*)
  H  - array or HASH_OF(object) (returned as HashTable*)
- l  - long (long)
- L  - long, limits out-of-range numbers to LONG_MAX/LONG_MIN (long)
+ i  - php_int_t (zend_int_t), platform dependent
+ I  - php_int_t, limits out-of-range numbers to ZEND_INT_MAX/ZEND_INT_MIN (zend_int_t),
+      platform dependent
  o  - object of any type (zval*)
  O  - object of specific type given by class entry (zval*, zend_class_entry)
- p  - valid path (string without null bytes in the middle) and its length (char*, int)
+ P  - valid path (string without null bytes in the middle) and its length (char*, php_size_t)
  r  - resource (zval*)
- s  - string (with possible null bytes) and its length (char*, int)
+ S  - string (with possible null bytes) and its length (char*, php_size_t)
  z  - the actual zval (zval*)
  Z  - the actual zval (zval**)
  *  - variable arguments list (0 or more)
@@ -79,30 +80,33 @@ Type specifiers
     ! - the parameter it follows can be of specified type or NULL. If NULL is
 		passed and the output for such type is a pointer, then the output
 		pointer is set to a native NULL pointer.
-		For 'b', 'l' and 'd', an extra argument of type zend_bool* must be
-		passed after the corresponding bool*, long* or double* arguments,
+		For 'b', 'i' and 'd', an extra argument of type zend_bool* must be
+		passed after the corresponding bool*, php_int_t* or double* arguments,
 		respectively. A non-zero value will be written to the zend_bool iif a
 		PHP NULL is passed.
 
 
 Note on 64bit compatibility
 ---------------------------
-Please do not forget that int and long are two different things on 64bit 
-OSes (int is 4 bytes and long is 8 bytes), so make sure you pass longs to "l" 
-and ints to strings length (i.e. for "s" you need to pass char * and int), 
-not the other way round!
-Remember: "l" is the only case when you need to pass long (and that's why 
-it's "l", not "i" btw).
+Please do not forget that php_int_t and php_size_t are platform dependent,
+you can consult Zend/zend_int.h for which type exactly these are mapped to.
+In previous versions, long was used for integers and int for string
+sizes. Now make sure you pass php_int_t to "i" and php_size_t to strings length
+(i.e. for "S" you need to pass char * and php_size_t), not the other way round!
+Remember: "i" is the only case when you need to pass platform depnedent integer
+(and that's why it's "i", not "l" anymore). The old formats 'l' and 's' aren't
+supported anymore. Passing int instead of php_size_t, or long instead of
+php_int_t is wrong.
 
 Both mistakes cause memory corruptions and segfaults on 64bit OSes:
 1)
   char *str;
-  long str_len; /* XXX THIS IS WRONG!! Use int instead. */
-  zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len)
+  int str_len; /* XXX THIS IS WRONG!! Use php_size_t instead. */
+  zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &str, &str_len)
 
 2)
-  int num; /* XXX THIS IS WRONG!! Use long instead. */
-  zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &num)
+  long num; /* XXX THIS IS WRONG!! Use php_int_t instead. */
+  zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &num)
 
 If you're in doubt, use check_parameters.php script to the parameters 
 and their types (it can be found in ./scripts/dev/ directory of PHP sources):
@@ -112,12 +116,12 @@ and their types (it can be found in ./scripts/dev/ directory of PHP sources):
 
 Examples
 --------
-/* Gets a long, a string and its length, and a zval */
-long l;
+/* Gets a php_int_t, a string and its length, and a zval */
+php_int_t i;
 char *s;
-int s_len;
+php_size_t s_len;
 zval *param;
-if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lsz",
+if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "iSz",
                           &l, &s, &s_len, &param) == FAILURE) {
     return;
 }
@@ -150,8 +154,8 @@ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/!",
     return;
 }
 
-/* Get either a set of 3 longs or a string. */
-long l1, l2, l3;
+/* Get either a set of 3 php_int_t vars or a string. */
+php_int_t i1, i2, i3;
 char *s;
 /* 
  * The function expects a pointer to a integer in this case, not a long
@@ -160,13 +164,13 @@ char *s;
  * properly, leading to random crashes on platforms like
  * Tru64 or Linux/Alpha.
  */
-int length;
+php_size_t length;
 
 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC,
-                             "lll", &l1, &l2, &l3) == SUCCESS) {
-    /* manipulate longs */
+                             "iii", &i1, &i2, &i3) == SUCCESS) {
+    /* manipulate php_int_t */
 } else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC,
-                                    "s", &s, &length) == SUCCESS) {
+                                    "S", &s, &length) == SUCCESS) {
     /* manipulate string */
 } else {
     /* output error */
@@ -197,11 +201,11 @@ if (varargs) {
 /* Function that accepts a string, followed by varargs (1 or more) */
 
 char *str;
-int str_len;
+php_size_t str_len;
 int i, num_varargs;
 zval ***varargs = NULL;
 
-if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s+", &str, &str_len, &varargs, &num_varargs) == FAILURE) {
+if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S+", &str, &str_len, &varargs, &num_varargs) == FAILURE) {
     return;
 }
 
@@ -214,13 +218,13 @@ if (varargs) {
 }
 
 
-/* Function that takes an array, followed by varargs, and ending with a long */
-long num;
+/* Function that takes an array, followed by varargs, and ending with a php_int_t */
+php_int_t num;
 zval *array;
 int i, num_varargs;
 zval ***varargs = NULL;
 
-if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a*l", &array, &varargs, &num_varargs, &num) == FAILURE) {
+if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a*i", &array, &varargs, &num_varargs, &num) == FAILURE) {
     return;
 }
 

README.RELEASE_PROCESS

@@ -11,17 +11,27 @@ because the sysadmins can not upgrade stuff then.
 2. Package two days before a release. So if the release is to be on Thursday,
 package on Tuesday. Think about timezones as well.
 
-3. Ensure that Windows builds will work before packaging
+3. Ensure that the tests on Travis CI are green.
+See: https://travis-ci.org/php/php-src/builds
+It is recommended to do so a couple of days before the packaging day, to
+have enough time to investigate failures, communicate with the authors and
+commit the fixes.
+The RM for the branch is also responsible for keeping the CI green on
+ongoing bases between the releases. Check the CI status for your branch
+periodically and resolve the failures ASAP. See more in:
+https://wiki.php.net/rfc/travis_ci
 
-4. Follow all steps to the letter. When unclear ask previous RM's (David/Julien/
+4. Ensure that Windows builds will work before packaging
+
+5. Follow all steps to the letter. When unclear ask previous RM's (David/Julien/
 Johannes/Stas/Derick/Ilia) before proceeding. Ideally make sure that for the
 first releases one of the previous RM's is around to answer questions. For the
 steps related to the php/QA/bug websites try to have someone from the webmaster
 team (Bjori) on hand.
 
-5. Verify the tags to be extra sure everything was tagged properly.
+6. Verify the tags to be extra sure everything was tagged properly.
 
-6. Moving extensions from/to PECL requires write acces to the destination.
+7. Moving extensions from/to PECL requires write acces to the destination.
 Most developers should have this. 
 
 Moving extensions from php-src to PECL
@@ -48,47 +58,49 @@ Rolling a non stable release (alpha/beta/RC)
 
 1. Check windows snapshot builder logs (http://windows.php.net/downloads/snaps/ the last revision)
 
-2. run the "scripts/dev/credits" script in php-src and commit the changes in the
+2. Check the tests at https://travis-ci.org/php/php-src/builds
+
+3. run the "scripts/dev/credits" script in php-src and commit the changes in the
 credits files in ext/standard.
 
-3. Checkout the release branch for this release (e.g., PHP-5.4.2) from the main branch.
+4. Checkout the release branch for this release (e.g., PHP-5.4.2) from the main branch.
 
-4. Bump the version numbers in ``main/php_version.h``, ``configure.in`` and possibly ``NEWS``.
+5. Bump the version numbers in ``main/php_version.h``, ``configure.in`` and possibly ``NEWS``.
 Do not use abbreviations for alpha and beta. Do not use dashes, you should
 ``#define PHP_VERSION "5.4.22RC1"`` and not ``#define PHP_VERSION "5.4.22-RC1"``
 
-5. Compile and make test, with and without ZTS, using the right Bison version
+6. Compile and make test, with and without ZTS, using the right Bison version
 (for example, for 5.5, Bison 2.4.1 is used)
 
-6. Check ./sapi/cli/php -v output for version matching.
+7. Check ./sapi/cli/php -v output for version matching.
 
-7. If all is right, commit the changes to the release branch with ``git commit -a``.
+8. If all is right, commit the changes to the release branch with ``git commit -a``.
 
-8. Tag the repository release branch with the version, e.g.: 
+9. Tag the repository release branch with the version, e.g.:
 ``git tag -u YOURKEYID php-5.4.2RC2``
 
-9. Bump the version numbers in ``main/php_version.h``, ``configure.in`` and ``NEWS``
+10. Bump the version numbers in ``main/php_version.h``, ``configure.in`` and ``NEWS``
 in the *main* branch (PHP-5.4 for example) to prepare for the **next** version.
 F.e. if the RC is "5.4.1RC1" then the new one should be "5.4.2-dev" - regardless if we get
 a new RC or not. This is to make sure ``version_compare()`` can correctly work.
 Commit the changes to the main branch.
 
-10. Push the changes to the main repo, the tag, the main branch and the release branch :
+11. Push the changes to the main repo, the tag, the main branch and the release branch :
 ``git push --tags origin HEAD``
 ``git push origin {main branch}``
 ``git push origin {release branch}``
 
-11. run: ``PHPROOT=. ./makedist 5.4.2RC2``, this will export the tree, create configure
+12. run: ``PHPROOT=. ./makedist 5.4.2RC2``, this will export the tree, create configure
 and build three tarballs (gz, bz2 and xz).
 
-12. Copy those tarballs (scp, rsync) to downloads.php.net, in your homedir there should be a
+13. Copy those tarballs (scp, rsync) to downloads.php.net, in your homedir there should be a
 directory "downloads/". Copy them into there, so that the system can generate
 MD5 sums. If you do not have this directory, talk to Derick or Dan.
 
-13. Now the RC can be found on http://downloads.php.net/yourname,
+14. Now the RC can be found on http://downloads.php.net/yourname,
 f.e. http://downloads.php.net/derick/
 
-14. Once the release has been tagged, contact the PHP Windows development team
+15. Once the release has been tagged, contact the PHP Windows development team
 (internals-win@lists.php.net) so that Windows binaries can be created. Once
 those are made, they should be placed into the same directory as the source snapshots.
 
@@ -139,12 +151,13 @@ Rolling a stable release
 1. Checkout your release branch, you should have created when releasing previous RC
 and bump the version numbers in ``main/php_version.h``, ``configure.in`` and possibly ``NEWS``.
 
-2. If a CVE commit needs to be merged to the release, then have it commited to
+2. If a CVE commit needs to be merged to the release, then have it committed to
 the base branches and merged upwards as usual (f.e commit the CVE fix to 5.3,
 merge to 5.4, 5.5 etc...). Then you can cherry-pick it in your release branch.
 Don't forget to update NEWS manually in an extra commit then.
 
-3. Commit those changes
+3. Commit those changes. Ensure the tests at https://travis-ci.org/php/php-src/builds are
+still passing.
 
 4. run the "scripts/dev/credits" script in php-src and commit the changes in the
 credits files in ext/standard.
@@ -154,7 +167,7 @@ credits files in ext/standard.
 
 6. Check ./sapi/cli/php -v output for version matching.
 
-7. tag the repository with the version f.e. "``git tag -s php-5.4.1``"
+7. tag the repository with the version f.e. "``git tag -u YOURKEYID -s php-5.4.1``"
 
 8. Push the tag f.e. "``git push origin php-5.4.1``"
 

TSRM/TSRM.h

@@ -64,7 +64,7 @@ typedef int ts_rsrc_id;
 
 /* Define THREAD_T and MUTEX_T */
 #ifdef TSRM_WIN32
-# define THREAD_T DWORD
+# define THREAD_T UINT_PTR
 # define MUTEX_T CRITICAL_SECTION *
 #elif defined(GNUPTH)
 # define THREAD_T pth_t

TSRM/tsrm_config_common.h

@@ -2,7 +2,7 @@
 #define TSRM_CONFIG_COMMON_H
 
 #ifndef __CYGWIN__
-# if WINNT|WIN32
+# ifdef _WIN32
 #  define TSRM_WIN32
 # endif
 #endif

UPGRADING

@@ -4,181 +4,81 @@ PHP X.Y UPGRADE NOTES
 
 1. Backward Incompatible Changes
 2. New Features
-2. Changes in SAPI modules
-3. Deprecated Functionality
-4. Changed Functions
-5. New Functions
-6. New Classes and Interfaces
-7. Removed Extensions
-8. Other Changes to Extensions
-9. New Global Constants
-10. Changes to INI File Handling
-11. Other Changes
+3. Changes in SAPI modules
+4. Deprecated Functionality
+5. Changed Functions
+6. New Functions
+7. New Classes and Interfaces
+8. Removed Extensions
+9. Other Changes to Extensions
+10. New Global Constants
+11. Changes to INI File Handling
+12. Other Changes
 
 
 ========================================
 1. Backward Incompatible Changes
 ========================================
 
-- JSON:
-  json_decode() no longer accepts non-lowercase variants of lone JSON true,
-  false or null values. For example, True or FALSE will now cause json_decode to
-  return NULL and set an error value you can fetch with json_last_error().
-  This affects JSON texts consisting solely of true, false or null. Text
-  containing non-lowercase values inside JSON arrays or objects has never been
-  accepted.
-
-- openssl:
-  To prevent Man-in-the-Middle attacks against encrypted transfers client
-  streams now verify peer certificates by default. Previous versions
-  required users to manually enable peer verification. As a result of this
-  change, existing code using ssl:// or tls:// stream wrappers (e.g.
-  file_get_contents(), fsockopen(), stream_socket_client()) may no longer
-  connect successfully without manually disabling peer verification via the
-  stream context's "verify_peer" setting. Encrypted transfers delegate to
-  operating system certificate stores by default, so many/most users *should*
-  be unaffected by this transparent security enhancement.
+- DBA
+  . dba_delete() now returns false if the key was not found for the inifile 
+    handler, too.
 
 ========================================
 2. New Features
 ========================================
 
-- Added constant scalar expressions syntax.
-  (https://wiki.php.net/rfc/const_scalar_exprs)
-
-- Added dedicated syntax for variadic functions.
-  (https://wiki.php.net/rfc/variadics)
-
-- Added support for argument unpacking to complement the variadic syntax.
-  (https://wiki.php.net/rfc/argument_unpacking)
-
-- Added T_POW (**) operator.
-  (https://wiki.php.net/rfc/pow-operator)
-
-- The php://input stream is now re-usable and can be used concurrently with 
-  enable_post_data_reading=0.
-
-- Added gost-crypto (CryptoPro S-box) hash algo.
-
-- Added openssl certificate fingerprint support (inclusive stream context 
-  option).
-
-- Added openssl crypto method stream context option.
-
-- Added openssl peer verification support for SAN x509 extension
-
-- Added use function and use const.
-  (https://wiki.php.net/rfc/use_function)
 
 ========================================
-2. Changes in SAPI modules
-========================================
-
-- Added phpdbg sapi.
-  (https://wiki.php.net/rfc/phpdbg)
-
-========================================
-3. Deprecated Functionality
-========================================
-
-- Incompatible context calls:
-  Instance calls from an incompatible context are now deprecated and issue
-  E_DEPRECATED instead of E_STRICT. See https://wiki.php.net/rfc/incompat_ctx
-
-========================================
-4. Changed Functions
-========================================
-
-- cURL:
-  CURLOPT_SAFE_UPLOAD is now turned on by default and uploads with @file 
-  do not work unless it is explicitly set to false.
-
-- Crypt:
-  crypt() will now raise an E_NOTICE error if the salt parameter is omitted.
-  See: https://wiki.php.net/rfc/crypt_function_salt
-
-- XMLReader:
-  XMLReader::getAttributeNs and XMLReader::getAttributeNo now return NULL if
-  the attribute could not be found, just like XMLReader::getAttribute.
-
-========================================
-5. New Functions
-========================================
-
-- GMP:
-  Added gmp_root($a, $nth) and gmp_rootrem($a, $nth) for calculating nth roots.
-
-- Openssl:
-  Added string openssl_x509_fingerprint($x509, $type, $binary).
-  Added string openssl_spki_new($private_key, $challenge, $algorithm)
-  Added bool openssl_spki_verify($spkac)
-  Added string openssl_spki_export($spkac)
-  Added string openssl_spki_export_challenge($spkac)
-
-- LDAP:
-  Added ldap_escape($value, $ignore = "", $flags = 0).
-
-- Zip:
-  Added ZipArchive::setPassword($password)
-
-========================================
-6. New Classes and Interfaces
+3. Changes in SAPI modules
 ========================================
 
 
 ========================================
-7. Removed Extensions
+4. Deprecated Functionality
 ========================================
 
 
 ========================================
-8. Other Changes to Extensions
+5. Changed Functions
 ========================================
 
-- GMP:
-  The GMP extension now uses objects as the underlying data structure, rather
-  than resources. GMP instances now support dumping, serialization, cloning,
-  casts to primitive types and have overloaded operators.
-  (RFC: https://wiki.php.net/rfc/operator_overloading_gmp)
-
-- OCI8:
-  - Added Implicit Result Set support for Oracle Database 12c with a
-    new oci_get_implicit_resultset() function.
-  - Using 'oci_execute($s, OCI_NO_AUTO_COMMIT)' for a SELECT no longer
-    unnecessarily initiates an internal ROLLBACK during connection
-    close.
-  - Added DTrace probes enabled with PHP's generic --enable-dtrace
-  - The oci_internal_debug() function is now a no-op.
-  - The phpinfo() output format for OCI8 has changed.
 
 ========================================
-9. New Global Constants
+6. New Functions
 ========================================
 
-- LDAP:
-  LDAP_ESCAPE_FILTER int(1)
-  LDAP_ESCAPE_DN     int(2)
 
 ========================================
-10. Changes to INI File Handling
+7. New Classes and Interfaces
 ========================================
 
-- Core:
-  Changed always_populate_raw_post_data to throw a deprecation warning when
-  enabled and to recognize ohe value -1 for never populating the global 
-  $HTTP_RAW_POST_DATA variable, which will be default in future PHP versions.
 
 ========================================
-11. Other Changes
+8. Removed Extensions
 ========================================
 
-- File upload:
-  Uploads equal or greater than 2GB in size are now accepted.
 
-- HTTP stream wrapper:
-  HTTP 1.1 requests now include a Connection: close header unless explicitly
-  overridden by setting a Connection header via the header context option.
+========================================
+9. Other Changes to Extensions
+========================================
 
-- Zip:
-  New --with-libzip option allow to use system libzip. Version > 0.11 required,
-  Version >= 0.11.2 recommended for all features.
+
+========================================
+10. New Global Constants
+========================================
+
+- Core
+  , PHP_INT_MIN added.
+
+========================================
+11. Changes to INI File Handling
+========================================
+
+
+========================================
+12. Other Changes
+========================================
+
+- Standard
+  . call_user_method() and call_user_method_array() no longer exists.

UPGRADING.INTERNALS

@@ -17,108 +17,11 @@ UPGRADE NOTES - PHP X.Y
 1. Internal API changes
 ========================
 
-  a. Addition of do_operation and compare object handlers
+  a. zend_set_memory_limit() now takes the TSRMLS_CC macro as its last argument
 
-  Two new object handlers have been added:
-
-    do_operation:
-    typedef int (*zend_object_do_operation_t)(
-        zend_uchar opcode, zval *result, zval *op1, zval *op2 TSRMLS_DC
-    );
-
-    compare:
-    typedef int (*zend_object_compare_zvals_t)(
-        zval *result, zval *op1, zval *op2 TSRMLS_DC
-    );
-
-  The first handler is used to overload arithmetic operations. The first
-  argument specifies the opcode of the operator, result is the target zval,
-  op1 the first operand and op2 the second operand. For unary operations
-  op2 is NULL. If the handler returns FAILURE PHP falls back to the default
-  behavior for the operation.
-
-  The second handler is used to perform comparison operations with
-  non-objects. The value written into result must be an IS_LONG with value
-  -1 (smaller), 0 (equal) or 1 (greater). The return value is a SUCCESS/FAILURE
-  return code. The difference between this handler and compare_objects is
-  that it will be triggered for comparisons with non-objects and objects of
-  different types. It takes precedence over compare_objects.
-
-  Further docs in the RFC: https://wiki.php.net/rfc/operator_overloading_gmp
-
-  b. return_value_ptr now always available, RETVAL_ZVAL_FAST macros
-
-  The return_value_ptr argument to internal functions is now always set.
-  Previously it was only available for functions returning by-reference.
-  return_value_ptr can now be used to return zvals without copying them.
-  For this purpose two new macros are provided:
-
-      RETVAL_ZVAL_FAST(zv); /* analog to RETVAL_ZVAL(zv, 1, 0) */
-      RETURN_ZVAL_FAST(zv); /* analog to RETURN_ZVAL(zv, 1, 0) */
-
-  The macros behave similarly to the non-FAST variants with copy=1 and
-  dtor=0, but will try to return the zval without making a copy by utilizing
-  return_value_ptr.
-  
-  c. POST data handling
-  
-  The sapi_request_info's members post_data, post_data_len and raw_post_data as 
-  well as raw_post_data_len have been replaced with a temp PHP stream 
-  request_body.
-  
-  The recommended way to access raw POST data is to open and use a php://input 
-  stream wrapper.  It is safe to be used concurrently and more than once. 
-
-  d. Arginfo changes
-
-  The pass_rest_by_reference argument of the ZEND_BEGIN_ARG_INFO and
-  ZEND_BEGIN_ARG_INFO_EX() is no longer used. The value passed to it is ignored.
-
-  Instead a variadic argument is created using ZEND_ARG_VARIADIC_INFO():
-
-      ZEND_ARG_VARIADIC_INFO(0, name) /* pass rest by value */
-      ZEND_ARG_VARIADIC_INFO(1, name) /* pass rest by reference */
-      ZEND_ARG_VARIADIC_INFO(ZEND_SEND_PREFER_REF, name)
-          /* pass rest by prefer-ref */
-
-  ZEND_ARG_VARIADIC_INFO() should only be used for the last argument.
-
-  The following changes were applied to the zend_arg_info struct:
-
-       typedef struct _zend_arg_info {
-           const char *class_name;
-           zend_uint class_name_len;
-           zend_uchar type_hint;
-      +    zend_uchar pass_by_reference;
-           zend_bool allow_null;
-      -    zend_bool pass_by_reference;
-      +    zend_bool is_variadic;
-       } zend_arg_info;
-
-  The following changes were applied to the zend_internal_function_info struct:
-
-       typedef struct _zend_internal_function_info {
-           zend_uint required_num_args;
-           zend_uchar _type_hint;
-           zend_bool return_reference;
-      -    zend_bool pass_rest_by_reference;
-      +    zend_bool _allow_null;
-      +    zend_bool _is_variadic;
-       } zend_internal_function_info;
-
-  The CHECK_ARG_SEND_TYPE(), ARG_MUST_BE_SENT_BY_REF(),
-  ARG_SHOULD_BE_SENT_BY_REF() and ARG_MAY_BE_SENT_BY_REF() macros now assume
-  that the argument passed to them is a zend_function* and that it is non-NULL.
 
 ========================
 2. Build system changes
 ========================
 
-  a. Unix build system changes
-    - The bison version check is now a blacklist instead of a whitelist.
-    - The bison binary can be specified through the YACC environment/configure
-      variable. Previously `bison` was assumed to be in $PATH. 
-
-  b. Windows build system changes
-    - 
   

Zend/Zend.dsp

@@ -375,6 +375,10 @@ SOURCE=.\zend_istdiostream.h
 # End Source File
 # Begin Source File
 
+SOURCE=.\zend_int.h
+# End Source File
+# Begin Source File
+
 SOURCE=".\zend_language_parser.h"
 # End Source File
 # Begin Source File

Zend/Zend.m4

@@ -130,7 +130,7 @@ int main()
 	exit(1);
 }
 ], [
-  AC_DEFINE([ZEND_DVAL_TO_LVAL_CAST_OK], 1, [Define if double cast to long preserves least significant bits])
+  AC_DEFINE([ZEND_DVAL_TO_IVAL_CAST_OK], 1, [Define if double cast to long preserves least significant bits])
   AC_MSG_RESULT(yes)
 ], [
   AC_MSG_RESULT(no)

Zend/ZendTS.dsp

@@ -405,6 +405,10 @@ SOURCE=.\zend_iterators.h
 # End Source File
 # Begin Source File
 
+SOURCE=.\zend_int.h
+# End Source File
+# Begin Source File
+
 SOURCE=".\zend_language_parser.h"
 # End Source File
 # Begin Source File

Zend/tests/67468.phpt

@@ -0,0 +1,11 @@
+--TEST--
+Bug #67468 (Segfault in highlight_file()/highlight_string())
+--SKIPIF--
+<?php if(!function_exists("leak")) print "skip only for debug builds"; ?>
+--FILE--
+<?php
+highlight_string("<?php __CLASS__;", true);
+echo "done";
+?>
+--EXPECT--
+done

Zend/tests/arg_unpack/basic.phpt

@@ -30,12 +30,12 @@ test(...getArray([1, 2, 3]));
 test(...arrayGen([]));
 test(...arrayGen([1, 2, 3]));
 
-test(1, ...[2, 3], ...[4, 5], 6);
-test(1, ...getArray([2, 3]), ...arrayGen([4, 5]), 6);
+test(1, ...[2, 3], ...[4, 5]);
+test(1, ...getArray([2, 3]), ...arrayGen([4, 5]));
 
 test2(...[1, 2]);
 test2(...[1, 2, 3]);
-test2(...[1], ...[], ...[], ...[2, 3], 4, ...[5, 6]);
+test2(...[1], ...[], ...[], ...[2, 3], ...[4, 5]);
 
 ?>
 --EXPECT--
@@ -75,7 +75,7 @@ array(3) {
   [2]=>
   int(3)
 }
-array(6) {
+array(5) {
   [0]=>
   int(1)
   [1]=>
@@ -86,10 +86,8 @@ array(6) {
   int(4)
   [4]=>
   int(5)
-  [5]=>
-  int(6)
 }
-array(6) {
+array(5) {
   [0]=>
   int(1)
   [1]=>
@@ -100,8 +98,6 @@ array(6) {
   int(4)
   [4]=>
   int(5)
-  [5]=>
-  int(6)
 }
 int(1)
 int(2)

Zend/tests/arg_unpack/by_ref.phpt

@@ -17,46 +17,37 @@ $array = [1, 2, 3];
 test1(...$array);
 var_dump($array);
 
-$array1 = [1, 2]; $val2 = 3; $array2 = [4, 5];
-test1(...$array1, $val2, ...$array2);
-var_dump($array1, $val2, $array2);
+$array1 = [1, 2]; $array2 = [3, 4];
+test1(...$array1, ...$array2);
+var_dump($array1, $array2);
 
 function test2($val1, &$ref1, $val2, &$ref2) {
     $ref1++;
     $ref2++;
 }
 
-$array = [1, 2, 3, 4];
+$array = [0, 0, 0, 0];
 test2(...$array);
 var_dump($array);
 
+$array1 = [1, 2]; $array2 = [4, 5];
+test1(...$array1, ...$array2);
+var_dump($array1, $array2);
+
 $a = $b = $c = $d = 0;
+$array = [0, 0, 0, 0];
 
-$array = [];
-test2(...$array, $a, $b, $c, $d);
-var_dump($array, $a, $b, $c, $d);
+test2($a, ...$array);
+var_dump($a, $array);
 
-$array = [1];
-test2(...$array, $a, $b, $c, $d);
-var_dump($array, $a, $b, $c, $d);
+test2($a, $b, ...$array);
+var_dump($a, $b, $array);
 
-$array = [1, 2];
-test2(...$array, $a, $b, $c, $d);
-var_dump($array, $a, $b, $c, $d);
+test2($a, $b, $c, ...$array);
+var_dump($a, $b, $c, $array);
 
-$array = [1, 2, 3];
-test2(...$array, $a, $b, $c, $d);
-var_dump($array, $a, $b, $c, $d);
-
-$vars = [];
-$array = [];
-test2(...$array, $vars['a'], $vars['b'], $vars['c'], $vars['d']);
-var_dump($vars);
-
-$vars = [];
-$array = [1];
-test2(...$array, $vars['a'], $vars['b'], $vars['c'], $vars['d']);
-var_dump($vars);
+test2($a, $b, $c, $d, ...$array);
+var_dump($a, $b, $c, $d, $array);
 
 ?>
 --EXPECTF--
@@ -74,76 +65,81 @@ array(2) {
   [1]=>
   int(3)
 }
-int(4)
+array(2) {
+  [0]=>
+  int(4)
+  [1]=>
+  int(5)
+}
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(0)
+  [3]=>
+  int(1)
+}
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+}
 array(2) {
   [0]=>
   int(5)
   [1]=>
   int(6)
 }
+int(0)
 array(4) {
   [0]=>
   int(1)
   [1]=>
-  int(3)
+  int(0)
   [2]=>
-  int(3)
+  int(1)
   [3]=>
-  int(5)
-}
-array(0) {
+  int(0)
 }
 int(0)
 int(1)
-int(0)
-int(1)
-array(1) {
-  [0]=>
-  int(1)
-}
-int(1)
-int(1)
-int(1)
-int(1)
-array(2) {
+array(4) {
   [0]=>
   int(1)
   [1]=>
-  int(3)
-}
-int(1)
-int(2)
-int(1)
-int(1)
-array(3) {
-  [0]=>
   int(1)
-  [1]=>
-  int(3)
   [2]=>
-  int(3)
+  int(1)
+  [3]=>
+  int(0)
 }
+int(0)
 int(2)
-int(2)
-int(1)
-int(1)
-
-Notice: Undefined index: a in %s on line %d
-
-Notice: Undefined index: c in %s on line %d
-array(2) {
-  ["b"]=>
+int(0)
+array(4) {
+  [0]=>
+  int(2)
+  [1]=>
   int(1)
-  ["d"]=>
+  [2]=>
   int(1)
+  [3]=>
+  int(0)
 }
-
-Notice: Undefined index: b in %s on line %d
-
-Notice: Undefined index: d in %s on line %d
-array(2) {
-  ["a"]=>
+int(0)
+int(3)
+int(0)
+int(1)
+array(4) {
+  [0]=>
+  int(2)
+  [1]=>
   int(1)
-  ["c"]=>
+  [2]=>
   int(1)
+  [3]=>
+  int(0)
 }

Zend/tests/arg_unpack/dynamic.phpt

@@ -9,7 +9,7 @@ $fn = function(...$args) {
 
 $fn(...[]);
 $fn(...[1, 2, 3]);
-$fn(1, ...[2, 3], ...[], 4, 5);
+$fn(1, ...[2, 3], ...[], ...[4, 5]);
 
 ?>
 --EXPECT--

Zend/tests/arg_unpack/invalid_type.phpt

@@ -12,7 +12,7 @@ test(...42);
 test(...new stdClass);
 
 test(1, 2, 3, ..."foo", ...[4, 5]);
-test(1, 2, ...new StdClass, 3, ...3.14, ...[4, 5]);
+test(1, 2, 3, ...new StdClass, ...3.14, ...[4, 5]);
 
 ?>
 --EXPECTF--

Zend/tests/arg_unpack/method.phpt

@@ -14,8 +14,7 @@ class Foo {
 }
 
 $foo = new Foo;
-$foo->test(...[1, 2], 3, 4, ...[], 5);
-Foo::test2(1, 2, ...[3, 4], ...[], 5);
+Foo::test2(1, 2, ...[3, 4], ...[], ...[5]);
 
 ?>
 --EXPECT--
@@ -31,15 +30,3 @@ array(5) {
   [4]=>
   int(5)
 }
-array(5) {
-  [0]=>
-  int(1)
-  [1]=>
-  int(2)
-  [2]=>
-  int(3)
-  [3]=>
-  int(4)
-  [4]=>
-  int(5)
-}

Zend/tests/arg_unpack/new.phpt

@@ -11,7 +11,7 @@ class Foo {
 
 new Foo(...[]);
 new Foo(...[1, 2, 3]);
-new Foo(...[1], 2, ...[], ...[3, 4], 5);
+new Foo(...[1], ...[], ...[2, 3]);
 
 ?>
 --EXPECT--
@@ -25,15 +25,11 @@ array(3) {
   [2]=>
   int(3)
 }
-array(5) {
+array(3) {
   [0]=>
   int(1)
   [1]=>
   int(2)
   [2]=>
   int(3)
-  [3]=>
-  int(4)
-  [4]=>
-  int(5)
 }

Zend/tests/arg_unpack/positional_arg_after_unpack_error.phpt

@@ -0,0 +1,10 @@
+--TEST--
+Positional arguments cannot be used after argument unpacking
+--FILE--
+<?php
+
+var_dump(...[1, 2, 3], 4);
+
+?>
+--EXPECTF--
+Fatal error: Cannot use positional argument after argument unpacking in %s on line %d

Zend/tests/arg_unpack/traversable_throwing_exception.phpt

@@ -20,11 +20,11 @@ function gen() {
 }
 
 try {
-    test(1, 2, ...new Foo, 3, 4);
+    test(1, 2, ...new Foo, ...[3, 4]);
 } catch (Exception $e) { var_dump($e->getMessage()); }
 
 try {
-    test(1, 2, ...gen(), 3, 4);
+    test(1, 2, ...gen(), ...[3, 4]);
 } catch (Exception $e) { var_dump($e->getMessage()); }
 
 ?>

Zend/tests/arg_unpack/traversable_with_by_ref_parameters.phpt

@@ -13,8 +13,6 @@ function gen($array) {
     }
 }
 
-test(...gen([1, 2, 3]), $a);
-var_dump($a);
 test(1, 2, 3, $b, ...gen([4, 5, 6]));
 var_dump($b);
 
@@ -25,7 +23,6 @@ test(...gen([1, 2]), ...gen([3, 4]));
 ?>
 --EXPECTF--
 int(42)
-int(42)
 
 Warning: Cannot pass by-reference argument 4 of test() by unpacking a Traversable, passing by-value instead in %s on line %d
 

Zend/tests/bug66015.phpt

@@ -0,0 +1,30 @@
+--TEST--
+Bug #66015 (wrong array indexing in class's static property)
+--FILE--
+<?php
+class Test
+{
+   const FIRST = 1;
+   const SECOND = 2;
+   const THIRD = 3;
+
+   protected static $array = [
+       self::FIRST => 'first',
+       'second',
+       'third'
+   ];
+
+   public function __construct()
+   {
+       var_export(self::$array);
+   }
+}
+
+$test = new Test();
+?>
+--EXPECTF--
+array (
+  1 => 'first',
+  2 => 'second',
+  3 => 'third',
+)

Zend/tests/bug66608.phpt

@@ -0,0 +1,73 @@
+--TEST--
+Bug #66608 (Incorrect behavior with nested "finally" blocks)
+--FILE--
+<?php
+function bar() {
+	try {
+		echo "1\n";
+		try {
+		} finally {
+			try {
+			} finally {
+			}
+			echo "2\n";
+		}
+	} finally {
+		try {
+			throw new Exception ("");
+		} catch (Exception $ab) {
+			echo "3\n";
+		} finally {
+			try {
+			} finally {
+				echo "4\n";
+				try  {
+				} finally {
+				}
+				echo "5\n";
+			}
+		}
+		echo "6\n";
+		try {
+		} finally {
+			while (1) {
+				try {
+					echo "7\n";
+					break;
+				} finally {
+					echo "8\n";
+				}
+				echo "bad";
+			}
+			echo "9\n";
+			while (1) {
+				try {
+					throw new Exception("");
+				} catch(Exception $e) {
+					echo "10\n";
+					break;
+				} finally {
+					echo "11\n";
+				}
+				echo "bak\n";
+			}
+		}
+		echo "12\n";
+	}
+	echo "13\n";
+}
+bar();
+--EXPECT--
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13

Zend/tests/bug66660.phpt

@@ -0,0 +1,13 @@
+--TEST--
+Bug #66660 (Composer.phar install/update fails)
+--STDIN--
+<?php __CLASS__ ?>
+--FILE--
+<?php
+file_put_contents(__DIR__."/bug66660.tmp.php", "<?php __CLASS__ ?>");
+echo php_strip_whitespace(__DIR__."/bug66660.tmp.php");
+?>
+--CLEAN--
+<?php unlink(__DIR__."/bug66660.tmp.php"); ?>
+--EXPECT--
+<?php __CLASS__ ?>

Zend/tests/bug67169.phpt

@@ -0,0 +1,26 @@
+--TEST--
+Bug #67169: array_splice all elements, then []= gives wrong index
+--FILE--
+<?php
+
+$array = array('a', 'b');
+array_splice($array, 0, 2);
+$array[] = 'c';
+var_dump($array);
+
+$array = array('a', 'b');
+array_shift($array);
+array_shift($array);
+$array[] = 'c';
+var_dump($array);
+
+?>
+--EXPECT--
+array(1) {
+  [0]=>
+  string(1) "c"
+}
+array(1) {
+  [0]=>
+  string(1) "c"
+}

Zend/tests/bug67368.phpt

@@ -0,0 +1,12 @@
+--TEST--
+Bug #67368 (Memory leak with immediately dereferenced array in class constant)
+--INI--
+report_memleaks=1
+--FILE--
+<?php
+class FooBar {
+		const bar = ["bar" => 3]["bar"];
+}
+echo "okey";
+--EXPECTF--
+okey

Zend/tests/bug67436/a.php

@@ -0,0 +1,10 @@
+<?php
+
+class a {
+	public function test($arg = c::TESTCONSTANT) {
+		echo __METHOD__ . "($arg)\n";
+	}
+
+	static public function staticTest() {
+  	}
+}

Zend/tests/bug67436/b.php

@@ -0,0 +1,8 @@
+<?php
+
+class b extends a {
+	public function test() {
+		echo __METHOD__ . "()\n";
+		parent::test();
+	}
+}

Zend/tests/bug67436/bug67436.phpt

@@ -0,0 +1,26 @@
+--TEST--
+bug67436: Autoloader isn't called if user defined error handler is present
+
+--INI--
+error_reporting=
+
+--FILE--
+<?php
+
+spl_autoload_register(function($classname) {
+	if (in_array($classname, array('a','b','c'))) {
+		require_once ($classname . '.php');
+	}
+});
+
+set_error_handler(function ($errno, $errstr, $errfile, $errline) {
+}, error_reporting());
+
+a::staticTest();
+
+$b = new b();
+$b->test();
+
+--EXPECT--
+b::test()
+a::test(c::TESTCONSTANT)

Zend/tests/bug67436/bug67436_nohandler.phpt

@@ -0,0 +1,24 @@
+--TEST--
+bug67436: E_STRICT instead of custom error handler
+
+--INI--
+error_reporting=-1
+
+--FILE--
+<?php
+
+spl_autoload_register(function($classname) {
+	if (in_array($classname, array('a','b','c'))) {
+		require_once ($classname . '.php');
+	}
+});
+
+a::staticTest();
+
+$b = new b();
+$b->test();
+
+--EXPECTF--
+Strict Standards: Declaration of b::test() should be compatible with a::test($arg = c::TESTCONSTANT) in %s/bug67436/b.php on line %d
+b::test()
+a::test(c::TESTCONSTANT)

Zend/tests/bug67436/c.php

@@ -0,0 +1,5 @@
+<?php
+
+class c {
+	const TESTCONSTANT = "c::TESTCONSTANT";
+}

Zend/tests/closure_049.phpt

@@ -0,0 +1,22 @@
+--TEST--
+Closure 049: static::class in static closure in non-static method.
+
+--FILE--
+<?php
+
+class A {
+    function foo() {
+        $f = static function() {
+            return static::class;
+        };
+        return $f();
+    }
+}
+
+class B extends A {}
+
+$b = new B;
+
+var_dump($b->foo());
+--EXPECT--
+string(1) "B"

Zend/tests/closure_050.phpt

@@ -0,0 +1,22 @@
+--TEST--
+Closure 050: static::class in non-static closure in non-static method.
+
+--FILE--
+<?php
+
+class A {
+    function foo() {
+        $f = function() {
+            return static::class;
+        };
+        return $f();
+    }
+}
+
+class B extends A {}
+
+$b = new B;
+var_dump($b->foo());
+
+--EXPECT--
+string(1) "B"

Zend/tests/closure_051.phpt

@@ -0,0 +1,21 @@
+--TEST--
+Closure 051: static::class in static closure in static method.
+
+--FILE--
+<?php
+
+class A {
+    static function foo() {
+        $f = static function() {
+            return static::class;
+        };
+        return $f();
+    }
+}
+
+class B extends A {}
+
+var_dump(B::foo());
+
+--EXPECT--
+string(1) "B"

Zend/tests/closure_052.phpt

@@ -0,0 +1,21 @@
+--TEST--
+Closure 052: static::class in non-static closure in static method.
+
+--FILE--
+<?php
+
+class A {
+    static function foo() {
+        $f = function() {
+            return static::class;
+        };
+        return $f();
+    }
+}
+
+class B extends A {}
+
+var_dump(B::foo());
+
+--EXPECT--
+string(1) "B"

Zend/tests/closure_053.phpt

@@ -0,0 +1,22 @@
+--TEST--
+Closure 053: self::class in static closure in non-static method.
+
+--FILE--
+<?php
+
+class A {
+    function foo() {
+        $f = static function() {
+            return self::class;
+        };
+        return $f();
+    }
+}
+
+class B extends A {}
+
+$b = new B;
+var_dump($b->foo());
+
+--EXPECT--
+string(1) "A"

Zend/tests/closure_054.phpt

@@ -0,0 +1,22 @@
+--TEST--
+Closure 054: self::class in non-static closure in non-static method.
+
+--FILE--
+<?php
+
+class A {
+    function foo() {
+        $f = function() {
+            return self::class;
+        };
+        return $f();
+    }
+}
+
+class B extends A {}
+
+$b = new B;
+var_dump($b->foo());
+
+--EXPECT--
+string(1) "A"

Zend/tests/closure_055.phpt

@@ -0,0 +1,21 @@
+--TEST--
+Closure 055: self::class in static closure in static method.
+
+--FILE--
+<?php
+
+class A {
+    static function foo() {
+        $f = static function() {
+            return self::class;
+        };
+        return $f();
+    }
+}
+
+class B extends A {}
+
+var_dump(B::foo());
+
+--EXPECT--
+string(1) "A"

Zend/tests/closure_056.phpt

@@ -0,0 +1,21 @@
+--TEST--
+Closure 056: self::class in non-static closure in static method.
+
+--FILE--
+<?php
+
+class A {
+    static function foo() {
+        $f = function() {
+            return self::class;
+        };
+        return $f();
+    }
+}
+
+class B extends A {}
+
+var_dump(B::foo());
+
+--EXPECT--
+string(1) "A"

Zend/tests/closure_bug66622.phpt

@@ -0,0 +1,37 @@
+--TEST--
+Bug 66622: Closures do not correctly capture the late bound class (static::) in some cases
+
+--FILE--
+<?php
+class A {
+    static function name() { return 'A'; }
+    function foo() {
+        $fn = function() { return static::name(); };
+        echo static::name() . ' vs ' . $fn() . "\n";
+    }
+    function bar() {
+        $fn = static function() { return static::name(); };
+        echo static::name() . ' vs ' . $fn() . "\n";
+    }
+    static function baz() {
+        $fn = function() { return static::name(); };
+        echo static::name() . ' vs ' . $fn() . "\n";
+    }
+}
+class B extends A {
+    static function name() { return 'B'; }
+}
+
+function test() {
+    (new B)->foo();
+    (new B)->bar();
+    (new B)->baz();
+    B::baz();
+}
+test();
+
+--EXPECT--
+B vs B
+B vs B
+B vs B
+B vs B

Zend/tests/constant_expressions.phpt

@@ -35,6 +35,9 @@ const T_25 = 1 + 2 * 3;
 // Test for memory leaks
 const T_26 = "1" + 2 + "3";
 
+// Allow T_POW
+const T_27 = 2 ** 3;
+
 var_dump(T_1);
 var_dump(T_2);
 var_dump(T_3);
@@ -61,6 +64,7 @@ var_dump(T_23);
 var_dump(T_24);
 var_dump(T_25);
 var_dump(T_26);
+var_dump(T_27);
 ?>
 --EXPECT--
 int(2)
@@ -89,3 +93,4 @@ bool(false)
 bool(true)
 int(7)
 int(6)
+int(8)

Zend/tests/constant_expressions_arrays.phpt

@@ -0,0 +1,66 @@
+--TEST--
+Constant expressions with arrays
+--FILE--
+<?php
+const a = [1,2,[3,[4]]];
+const b = a[0];
+const c = a[2][0];
+const d = a[2];
+const e = ["string" => [1]]["string"][0];
+
+var_dump(b, c, e);
+
+function test ($a = d[1][0]) {
+	var_dump($a);
+}
+
+test();
+
+class foo {
+	const bar = [1][0];
+}
+
+var_dump(foo::bar);
+
+var_dump(a, a[0], a[2], a[2][1], a[3]);
+
+?>
+--EXPECTF--
+int(1)
+int(3)
+int(1)
+int(4)
+int(1)
+
+Notice: Undefined offset: 3 in %s on line %d
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  array(2) {
+    [0]=>
+    int(3)
+    [1]=>
+    array(1) {
+      [0]=>
+      int(4)
+    }
+  }
+}
+int(1)
+array(2) {
+  [0]=>
+  int(3)
+  [1]=>
+  array(1) {
+    [0]=>
+    int(4)
+  }
+}
+array(1) {
+  [0]=>
+  int(4)
+}
+NULL

Zend/tests/constant_expressions_self_referencing_array.phpt

@@ -0,0 +1,13 @@
+--TEST--
+Self-referencing constant expression (part of a constant AST)
+--FILE--
+<?php
+class A {
+   const FOO = [self::BAR];
+   const BAR = [self::FOO];
+}
+var_dump(A::FOO);
+?>
+--EXPECTF--
+Fatal error: Cannot declare self-referencing constant 'self::FOO' in %s on line %d
+

Zend/tests/debug_info-error-0.0.phpt

@@ -0,0 +1,19 @@
+--TEST--
+Testing __debugInfo() magic method with bad returns ZERO (float)
+--FILE--
+<?php
+
+class C {
+  public $val;
+  public function __debugInfo() {
+    return $this->val;
+  }
+  public function __construct($val) {
+    $this->val = $val;
+  }
+}
+
+$c = new C(0.0);
+var_dump($c);
+--EXPECTF--
+Fatal error: __debuginfo() must return an array in %s%eZend%etests%edebug_info-error-0.0.php on line %d

Zend/tests/debug_info-error-0.phpt

@@ -0,0 +1,19 @@
+--TEST--
+Testing __debugInfo() magic method with bad returns ZERO
+--FILE--
+<?php
+
+class C {
+  public $val;
+  public function __debugInfo() {
+    return $this->val;
+  }
+  public function __construct($val) {
+    $this->val = $val;
+  }
+}
+
+$c = new C(0);
+var_dump($c);
+--EXPECTF--
+Fatal error: __debuginfo() must return an array in %s%eZend%etests%edebug_info-error-0.php on line %d

Zend/tests/debug_info-error-1.0.phpt

@@ -0,0 +1,19 @@
+--TEST--
+Testing __debugInfo() magic method with bad returns ONE (float)
+--FILE--
+<?php
+
+class C {
+  public $val;
+  public function __debugInfo() {
+    return $this->val;
+  }
+  public function __construct($val) {
+    $this->val = $val;
+  }
+}
+
+$c = new C(1.0);
+var_dump($c);
+--EXPECTF--
+Fatal error: __debuginfo() must return an array in %s%eZend%etests%edebug_info-error-1.0.php on line %d

Zend/tests/debug_info-error-1.phpt

@@ -0,0 +1,19 @@
+--TEST--
+Testing __debugInfo() magic method with bad returns ONE
+--FILE--
+<?php
+
+class C {
+  public $val;
+  public function __debugInfo() {
+    return $this->val;
+  }
+  public function __construct($val) {
+    $this->val = $val;
+  }
+}
+
+$c = new C(1);
+var_dump($c);
+--EXPECTF--
+Fatal error: __debuginfo() must return an array in %s%eZend%etests%edebug_info-error-1.php on line %d

Zend/tests/debug_info-error-empty_str.phpt

@@ -0,0 +1,19 @@
+--TEST--
+Testing __debugInfo() magic method with bad returns EMPTY STRING
+--FILE--
+<?php
+
+class C {
+  public $val;
+  public function __debugInfo() {
+    return $this->val;
+  }
+  public function __construct($val) {
+    $this->val = $val;
+  }
+}
+
+$c = new C("");
+var_dump($c);
+--EXPECTF--
+Fatal error: __debuginfo() must return an array in %s%eZend%etests%edebug_info-error-empty_str.php on line %d

Zend/tests/debug_info-error-false.phpt

@@ -0,0 +1,19 @@
+--TEST--
+Testing __debugInfo() magic method with bad returns FALSE
+--FILE--
+<?php
+
+class C {
+  public $val;
+  public function __debugInfo() {
+    return $this->val;
+  }
+  public function __construct($val) {
+    $this->val = $val;
+  }
+}
+
+$c = new C(false);
+var_dump($c);
+--EXPECTF--
+Fatal error: __debuginfo() must return an array in %s%eZend%etests%edebug_info-error-false.php on line %d

Zend/tests/debug_info-error-object.phpt

@@ -0,0 +1,19 @@
+--TEST--
+Testing __debugInfo() magic method with bad returns OBJECT
+--FILE--
+<?php
+
+class C {
+  public $val;
+  public function __debugInfo() {
+    return $this->val;
+  }
+  public function __construct($val) {
+    $this->val = $val;
+  }
+}
+
+$c = new C(new stdClass);
+var_dump($c);
+--EXPECTF--
+Fatal error: __debuginfo() must return an array in %s%eZend%etests%edebug_info-error-object.php on line %d

Zend/tests/debug_info-error-resource.phpt

@@ -0,0 +1,19 @@
+--TEST--
+Testing __debugInfo() magic method with bad returns RESOURCE
+--FILE--
+<?php
+
+class C {
+  public $val;
+  public function __debugInfo() {
+    return $this->val;
+  }
+  public function __construct($val) {
+    $this->val = $val;
+  }
+}
+
+$c = new C(fopen("data:text/plain,Foo", 'r'));
+var_dump($c);
+--EXPECTF--
+Fatal error: __debuginfo() must return an array in %s%eZend%etests%edebug_info-error-resource.php on line %d

Zend/tests/debug_info-error-str.phpt

@@ -0,0 +1,19 @@
+--TEST--
+Testing __debugInfo() magic method with bad returns STRING
+--FILE--
+<?php
+
+class C {
+  public $val;
+  public function __debugInfo() {
+    return $this->val;
+  }
+  public function __construct($val) {
+    $this->val = $val;
+  }
+}
+
+$c = new C("foo");
+var_dump($c);
+--EXPECTF--
+Fatal error: __debuginfo() must return an array in %s%eZend%etests%edebug_info-error-str.php on line %d

Zend/tests/debug_info-error-true.phpt

@@ -0,0 +1,19 @@
+--TEST--
+Testing __debugInfo() magic method with bad returns TRUE
+--FILE--
+<?php
+
+class C {
+  public $val;
+  public function __debugInfo() {
+    return $this->val;
+  }
+  public function __construct($val) {
+    $this->val = $val;
+  }
+}
+
+$c = new C(true);
+var_dump($c);
+--EXPECTF--
+Fatal error: __debuginfo() must return an array in %s%eZend%etests%edebug_info-error-true.php on line %d

Zend/tests/debug_info.phpt

@@ -0,0 +1,39 @@
+--TEST--
+Testing __debugInfo() magic method
+--FILE--
+<?php
+
+class Foo {
+  public $d = 4;
+  protected $e = 5;
+  private $f = 6;
+
+  public function __debugInfo() {
+    return ['a'=>1, "\0*\0b"=>2, "\0Foo\0c"=>3];
+  }
+}
+
+class Bar {
+  public $val = 123;
+
+  public function __debugInfo() {
+    return null;
+  }
+}
+
+$f = new Foo;
+var_dump($f);
+
+$b = new Bar;
+var_dump($b);
+--EXPECTF--
+object(Foo)#%d (3) {
+  ["a"]=>
+  int(1)
+  ["b":protected]=>
+  int(2)
+  ["c":"Foo":private]=>
+  int(3)
+}
+object(Bar)#%d (0) {
+}

Zend/tests/dereference_002.phpt

@@ -76,4 +76,4 @@ NULL
 
 Notice: Undefined offset: 3 in %s on line %d
 
-Fatal error: Call to a member function bar() on a non-object in %s on line %d
+Fatal error: Call to a member function bar() on null in %s on line %d

Zend/tests/errmsg_040.phpt

@@ -7,7 +7,17 @@ class test {
 	const TEST = array(1,2,3);
 }
 
+var_dump(test::TEST);
+
 echo "Done\n";
 ?>
 --EXPECTF--	
-Fatal error: Arrays are not allowed in class constants in %s on line %d
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+Done

Zend/tests/generators/bug67497.phpt

@@ -0,0 +1,19 @@
+--TEST--
+Bug #67467: eval with parse error causes segmentation fault in generator
+--FILE--
+<?php
+
+function gen() {
+    $a = 1;
+    yield $a;
+}
+
+@eval('abc');
+
+$values = gen();
+$values->next();
+
+?>
+===DONE===
+--EXPECT--
+===DONE===

Zend/tests/generators/errors/serialize_unserialize_error.phpt

@@ -32,12 +32,11 @@ Stack trace:
 #0 %s(%d): serialize(Object(Generator))
 #1 {main}
 
-exception 'Exception' with message 'Unserialization of 'Generator' is not allowed' in %s:%d
-Stack trace:
-#0 [internal function]: Generator->__wakeup()
-#1 %s(%d): unserialize('O:9:"Generator"...')
-#2 {main}
 
+Warning: Erroneous data format for unserializing 'Generator' in %sserialize_unserialize_error.php on line %d
+
+Notice: unserialize(): Error at offset 19 of 20 bytes in %sserialize_unserialize_error.php on line %s
+bool(false)
 exception 'Exception' with message 'Unserialization of 'Generator' is not allowed' in %s:%d
 Stack trace:
 #0 %s(%d): unserialize('C:9:"Generator"...')

Zend/tests/ns_059.phpt

@@ -3,6 +3,9 @@
 --FILE--
 <?php
 const C = array();
---EXPECTF--
-Fatal error: Arrays are not allowed as constants in %sns_059.php on line 2
 
+var_dump(C);
+?>
+--EXPECTF--
+array(0) {
+}

Zend/tests/try_finally_011.phpt

@@ -0,0 +1,15 @@
+--TEST--
+Try finally (segfault with empty break)
+--FILE--
+<?php
+function foo () {
+	try {
+		break;
+	} finally {
+	}
+}
+
+foo();
+?>
+--EXPECTF--
+Fatal error: Cannot break/continue 1 level in %stry_finally_011.php on line %d

Zend/zend.c

@@ -46,22 +46,22 @@
 
 /* true multithread-shared globals */
 ZEND_API zend_class_entry *zend_standard_class_def = NULL;
-ZEND_API int (*zend_printf)(const char *format, ...);
+ZEND_API zend_size_t (*zend_printf)(const char *format, ...);
 ZEND_API zend_write_func_t zend_write;
 ZEND_API FILE *(*zend_fopen)(const char *filename, char **opened_path TSRMLS_DC);
 ZEND_API int (*zend_stream_open_function)(const char *filename, zend_file_handle *handle TSRMLS_DC);
 ZEND_API void (*zend_block_interruptions)(void);
 ZEND_API void (*zend_unblock_interruptions)(void);
-ZEND_API void (*zend_ticks_function)(int ticks);
-ZEND_API void (*zend_error_cb)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args);
-int (*zend_vspprintf)(char **pbuf, size_t max_len, const char *format, va_list ap);
+ZEND_API void (*zend_ticks_function)(int ticks TSRMLS_DC);
+ZEND_API void (*zend_error_cb)(int type, const char *error_filename, const zend_size_t error_lineno, const char *format, va_list args);
+zend_size_t (*zend_vspprintf)(char **pbuf, zend_size_t max_len, const char *format, va_list ap);
 ZEND_API char *(*zend_getenv)(char *name, size_t name_len TSRMLS_DC);
-ZEND_API char *(*zend_resolve_path)(const char *filename, int filename_len TSRMLS_DC);
+ZEND_API char *(*zend_resolve_path)(const char *filename, zend_size_t filename_len TSRMLS_DC);
 
 void (*zend_on_timeout)(int seconds TSRMLS_DC);
 
-static void (*zend_message_dispatcher_p)(long message, const void *data TSRMLS_DC);
-static int (*zend_get_configuration_directive_p)(const char *name, uint name_length, zval *contents);
+static void (*zend_message_dispatcher_p)(zend_int_t message, const void *data TSRMLS_DC);
+static int (*zend_get_configuration_directive_p)(const char *name, zend_size_t name_length, zval *contents);
 
 static ZEND_INI_MH(OnUpdateErrorReporting) /* {{{ */
 {
@@ -127,7 +127,7 @@ ZEND_API zval zval_used_for_init; /* True global variable */
 
 /* version information */
 static char *zend_version_info;
-static uint zend_version_info_length;
+static zend_size_t zend_version_info_length;
 #define ZEND_CORE_VERSION_INFO	"Zend Engine v" ZEND_VERSION ", Copyright (c) 1998-2014 Zend Technologies\n"
 #define PRINT_ZVAL_INDENT 4
 
@@ -136,8 +136,8 @@ static void print_hash(zend_write_func_t write_func, HashTable *ht, int indent,
 	zval **tmp;
 	char *string_key;
 	HashPosition iterator;
-	ulong num_key;
-	uint str_len;
+	zend_uint_t num_key;
+	zend_size_t str_len;
 	int i;
 
 	for (i = 0; i < indent; i++) {
@@ -155,8 +155,8 @@ static void print_hash(zend_write_func_t write_func, HashTable *ht, int indent,
 			case HASH_KEY_IS_STRING:
 				if (is_object) {
 					const char *prop_name, *class_name;
-					int prop_len;
-					int mangled = zend_unmangle_property_name_ex(string_key, str_len - 1, &class_name, &prop_name, &prop_len);
+					zend_size_t prop_len;
+					zend_size_t mangled = zend_unmangle_property_name_ex(string_key, str_len - 1, &class_name, &prop_name, &prop_len);
 
 					ZEND_WRITE_EX(prop_name, prop_len);
 					if (class_name && mangled == SUCCESS) {
@@ -172,10 +172,10 @@ static void print_hash(zend_write_func_t write_func, HashTable *ht, int indent,
 					ZEND_WRITE_EX(string_key, str_len-1);
 				}
 				break;
-			case HASH_KEY_IS_LONG:
+			case HASH_KEY_IS_INT:
 				{
 					char key[25];
-					snprintf(key, sizeof(key), "%ld", num_key);
+					snprintf(key, sizeof(key), ZEND_INT_FMT, num_key);
 					ZEND_PUTS_EX(key);
 				}
 				break;
@@ -198,8 +198,8 @@ static void print_flat_hash(HashTable *ht TSRMLS_DC) /* {{{ */
 	zval **tmp;
 	char *string_key;
 	HashPosition iterator;
-	ulong num_key;
-	uint str_len;
+	zend_uint_t num_key;
+	zend_size_t str_len;
 	int i = 0;
 
 	zend_hash_internal_pointer_reset_ex(ht, &iterator);
@@ -212,8 +212,8 @@ static void print_flat_hash(HashTable *ht TSRMLS_DC) /* {{{ */
 			case HASH_KEY_IS_STRING:
 				ZEND_PUTS(string_key);
 				break;
-			case HASH_KEY_IS_LONG:
-				zend_printf("%ld", num_key);
+			case HASH_KEY_IS_INT:
+				zend_printf(ZEND_INT_FMT, num_key);
 				break;
 		}
 		ZEND_PUTS("] => ");
@@ -231,26 +231,26 @@ ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_cop
 	}
 	switch (Z_TYPE_P(expr)) {
 		case IS_NULL:
-			Z_STRLEN_P(expr_copy) = 0;
+			Z_STRSIZE_P(expr_copy) = 0;
 			Z_STRVAL_P(expr_copy) = STR_EMPTY_ALLOC();
 			break;
 		case IS_BOOL:
-			if (Z_LVAL_P(expr)) {
-				Z_STRLEN_P(expr_copy) = 1;
+			if (Z_IVAL_P(expr)) {
+				Z_STRSIZE_P(expr_copy) = 1;
 				Z_STRVAL_P(expr_copy) = estrndup("1", 1);
 			} else {
-				Z_STRLEN_P(expr_copy) = 0;
+				Z_STRSIZE_P(expr_copy) = 0;
 				Z_STRVAL_P(expr_copy) = STR_EMPTY_ALLOC();
 			}
 			break;
 		case IS_RESOURCE:
-			Z_STRVAL_P(expr_copy) = (char *) emalloc(sizeof("Resource id #") - 1 + MAX_LENGTH_OF_LONG);
-			Z_STRLEN_P(expr_copy) = snprintf(Z_STRVAL_P(expr_copy), sizeof("Resource id #") - 1 + MAX_LENGTH_OF_LONG, "Resource id #%ld", Z_LVAL_P(expr));
+			Z_STRVAL_P(expr_copy) = (char *) emalloc(sizeof("Resource id #") - 1 + MAX_LENGTH_OF_ZEND_INT);
+			Z_STRSIZE_P(expr_copy) = snprintf(Z_STRVAL_P(expr_copy), sizeof("Resource id #") - 1 + MAX_LENGTH_OF_ZEND_INT, "Resource id #" ZEND_INT_FMT, Z_IVAL_P(expr));
 			break;
 		case IS_ARRAY:
 			zend_error(E_NOTICE, "Array to string conversion");
-			Z_STRLEN_P(expr_copy) = sizeof("Array") - 1;
-			Z_STRVAL_P(expr_copy) = estrndup("Array", Z_STRLEN_P(expr_copy));
+			Z_STRSIZE_P(expr_copy) = sizeof("Array") - 1;
+			Z_STRVAL_P(expr_copy) = estrndup("Array", Z_STRSIZE_P(expr_copy));
 			break;
 		case IS_OBJECT:
 			{
@@ -288,7 +288,7 @@ ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_cop
 					zval_ptr_dtor(&z);
 				}
 				zend_error(EG(exception) ? E_ERROR : E_RECOVERABLE_ERROR, "Object of class %s could not be converted to string", Z_OBJCE_P(expr)->name);
-				Z_STRLEN_P(expr_copy) = 0;
+				Z_STRSIZE_P(expr_copy) = 0;
 				Z_STRVAL_P(expr_copy) = STR_EMPTY_ALLOC();
 			}
 			break;
@@ -308,13 +308,13 @@ ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_cop
 }
 /* }}} */
 
-ZEND_API int zend_print_zval(zval *expr, int indent) /* {{{ */
+ZEND_API zend_size_t zend_print_zval(zval *expr, int indent) /* {{{ */
 {
 	return zend_print_zval_ex(zend_write, expr, indent);
 }
 /* }}} */
 
-ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent) /* {{{ */
+ZEND_API zend_size_t zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent) /* {{{ */
 {
 	zval expr_copy;
 	int use_copy;
@@ -323,17 +323,17 @@ ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int in
 	if (use_copy) {
 		expr = &expr_copy;
 	}
-	if (Z_STRLEN_P(expr) == 0) { /* optimize away empty strings */
+	if (Z_STRSIZE_P(expr) == 0) { /* optimize away empty strings */
 		if (use_copy) {
 			zval_dtor(expr);
 		}
 		return 0;
 	}
-	write_func(Z_STRVAL_P(expr), Z_STRLEN_P(expr));
+	write_func(Z_STRVAL_P(expr), Z_STRSIZE_P(expr));
 	if (use_copy) {
 		zval_dtor(expr);
 	}
-	return Z_STRLEN_P(expr);
+	return Z_STRSIZE_P(expr);
 }
 /* }}} */
 
@@ -355,7 +355,7 @@ ZEND_API void zend_print_flat_zval_r(zval *expr TSRMLS_DC) /* {{{ */
 		{
 			HashTable *properties = NULL;
 			const char *class_name = NULL;
-			zend_uint clen;
+			zend_size_t clen;
 
 			if (Z_OBJ_HANDLER_P(expr, get_class_name)) {
 				Z_OBJ_HANDLER_P(expr, get_class_name)(expr, &class_name, &clen, 0 TSRMLS_CC);
@@ -413,7 +413,7 @@ ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int
 			{
 				HashTable *properties;
 				const char *class_name = NULL;
-				zend_uint clen;
+				zend_size_t clen;
 				int is_temp;
 
 				if (Z_OBJ_HANDLER_P(expr, get_class_name)) {
@@ -621,7 +621,7 @@ static void php_scanner_globals_ctor(zend_php_scanner_globals *scanner_globals_p
 
 void zend_init_opcodes_handlers(void);
 
-static zend_bool php_auto_globals_create_globals(const char *name, uint name_len TSRMLS_DC) /* {{{ */
+static zend_bool php_auto_globals_create_globals(const char *name, zend_size_t name_len TSRMLS_DC) /* {{{ */
 {
 	zval *globals;
 
@@ -870,7 +870,7 @@ void zenderror(const char *error) /* {{{ */
 /* }}} */
 
 BEGIN_EXTERN_C()
-ZEND_API void _zend_bailout(char *filename, uint lineno) /* {{{ */
+ZEND_API void _zend_bailout(char *filename, zend_size_t lineno) /* {{{ */
 {
 	TSRMLS_FETCH();
 
@@ -890,7 +890,7 @@ END_EXTERN_C()
 void zend_append_version_info(const zend_extension *extension) /* {{{ */
 {
 	char *new_info;
-	uint new_info_length;
+	zend_size_t new_info_length;
 
 	new_info_length = sizeof("    with  v, , by \n")
 						+ strlen(extension->name)
@@ -954,7 +954,7 @@ ZEND_API void zend_deactivate(TSRMLS_D) /* {{{ */
 
 	zend_destroy_rsrc_list(&EG(regular_list) TSRMLS_CC);
 
-#ifdef ZEND_DEBUG
+#if ZEND_DEBUG
 	if (GC_G(gc_enabled) && !CG(unclean_shutdown)) {
 		gc_collect_cycles(TSRMLS_C);
 	}
@@ -981,7 +981,7 @@ ZEND_API void zend_deactivate(TSRMLS_D) /* {{{ */
 /* }}} */
 
 BEGIN_EXTERN_C()
-ZEND_API void zend_message_dispatcher(long message, const void *data TSRMLS_DC) /* {{{ */
+ZEND_API void zend_message_dispatcher(zend_int_t message, const void *data TSRMLS_DC) /* {{{ */
 {
 	if (zend_message_dispatcher_p) {
 		zend_message_dispatcher_p(message, data TSRMLS_CC);
@@ -990,7 +990,7 @@ ZEND_API void zend_message_dispatcher(long message, const void *data TSRMLS_DC)
 /* }}} */
 END_EXTERN_C()
 
-ZEND_API int zend_get_configuration_directive(const char *name, uint name_length, zval *contents) /* {{{ */
+ZEND_API int zend_get_configuration_directive(const char *name, zend_size_t name_length, zval *contents) /* {{{ */
 {
 	if (zend_get_configuration_directive_p) {
 		return zend_get_configuration_directive_p(name, name_length, contents);
@@ -1025,7 +1025,7 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
 	zval *retval;
 	zval *z_error_type, *z_error_message, *z_error_filename, *z_error_lineno, *z_context;
 	const char *error_filename;
-	uint error_lineno;
+	zend_size_t error_lineno;
 	zval *orig_user_error_handler;
 	zend_bool in_compilation;
 	zend_class_entry *saved_class_entry;
@@ -1150,21 +1150,21 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
 # endif
 #endif
 			va_copy(usr_copy, args);
-			Z_STRLEN_P(z_error_message) = zend_vspprintf(&Z_STRVAL_P(z_error_message), 0, format, usr_copy);
+			Z_STRSIZE_P(z_error_message) = zend_vspprintf(&Z_STRVAL_P(z_error_message), 0, format, usr_copy);
 #ifdef va_copy
 			va_end(usr_copy);
 #endif
 			Z_TYPE_P(z_error_message) = IS_STRING;
 
-			Z_LVAL_P(z_error_type) = type;
-			Z_TYPE_P(z_error_type) = IS_LONG;
+			Z_IVAL_P(z_error_type) = type;
+			Z_TYPE_P(z_error_type) = IS_INT;
 
 			if (error_filename) {
 				ZVAL_STRING(z_error_filename, error_filename, 1);
 			}
 
-			Z_LVAL_P(z_error_lineno) = error_lineno;
-			Z_TYPE_P(z_error_lineno) = IS_LONG;
+			Z_IVAL_P(z_error_lineno) = error_lineno;
+			Z_TYPE_P(z_error_lineno) = IS_INT;
 
 			if (!EG(active_symbol_table)) {
 				zend_rebuild_symbol_table(TSRMLS_C);
@@ -1211,7 +1211,7 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
 
 			if (call_user_function_ex(CG(function_table), NULL, orig_user_error_handler, &retval, 5, params, 1, NULL TSRMLS_CC) == SUCCESS) {
 				if (retval) {
-					if (Z_TYPE_P(retval) == IS_BOOL && Z_LVAL_P(retval) == 0) {
+					if (Z_TYPE_P(retval) == IS_BOOL && Z_IVAL_P(retval) == 0) {
 						zend_error_cb(type, error_filename, error_lineno, format, args);
 					}
 					zval_ptr_dtor(&retval);
@@ -1302,7 +1302,7 @@ ZEND_API int zend_execute_scripts(int type TSRMLS_DC, zval **retval, int file_co
 	zend_file_handle *file_handle;
 	zend_op_array *orig_op_array = EG(active_op_array);
 	zval **orig_retval_ptr_ptr = EG(return_value_ptr_ptr);
-    long orig_interactive = CG(interactive);
+	zend_int_t orig_interactive = CG(interactive);
 
 	va_start(files, file_count);
 	for (i = 0; i < file_count; i++) {
@@ -1378,7 +1378,7 @@ ZEND_API int zend_execute_scripts(int type TSRMLS_DC, zval **retval, int file_co
 ZEND_API char *zend_make_compiled_string_description(const char *name TSRMLS_DC) /* {{{ */
 {
 	const char *cur_filename;
-	int cur_lineno;
+	zend_size_t cur_lineno;
 	char *compiled_string_description;
 
 	if (zend_is_compiling(TSRMLS_C)) {

Zend/zend.h

@@ -22,7 +22,7 @@
 #ifndef ZEND_H
 #define ZEND_H
 
-#define ZEND_VERSION "2.6.0-dev"
+#define ZEND_VERSION "2.7.0-dev"
 
 #define ZEND_ENGINE_2
 
@@ -266,14 +266,14 @@ char *alloca ();
 #define LONG_MIN (- LONG_MAX - 1)
 #endif
 
-#if SIZEOF_LONG == 4
-#define MAX_LENGTH_OF_LONG 11
-static const char long_min_digits[] = "2147483648";
-#elif SIZEOF_LONG == 8
-#define MAX_LENGTH_OF_LONG 20
-static const char long_min_digits[] = "9223372036854775808";
+#if SIZEOF_ZEND_INT == 4
+#define MAX_LENGTH_OF_ZEND_INT 11
+static const char int_min_digits[] = "2147483648";
+#elif SIZEOF_ZEND_INT == 8
+#define MAX_LENGTH_OF_ZEND_INT 20
+static const char int_min_digits[] = "9223372036854775808";
 #else
-#error "Unknown SIZEOF_LONG"
+#error "Unknown SIZEOF_ZEND_INT"
 #endif
 
 #define MAX_LENGTH_OF_DOUBLE 32
@@ -320,11 +320,11 @@ typedef struct _zend_object {
 #include "zend_ast.h"
 
 typedef union _zvalue_value {
-	long lval;					/* long value */
+	zend_int_t lval;					/* long value */
 	double dval;				/* double value */
 	struct {
 		char *val;
-		int len;
+		zend_size_t len;
 	} str;
 	HashTable *ht;				/* hash table value */
 	zend_object_value obj;
@@ -443,12 +443,12 @@ typedef struct _zend_unserialize_data zend_unserialize_data;
 
 struct _zend_trait_method_reference {
 	const char* method_name;
-	unsigned int mname_len;
+	zend_size_t mname_len;
 	
 	zend_class_entry *ce;
 	
 	const char* class_name;
-	unsigned int cname_len;
+	zend_size_t cname_len;
 };
 typedef struct _zend_trait_method_reference	zend_trait_method_reference;
 
@@ -466,7 +466,7 @@ struct _zend_trait_alias {
 	* name for method to be added
 	*/
 	const char* alias;
-	unsigned int alias_len;
+	zend_size_t alias_len;
 	
 	/**
 	* modifiers to be set on trait method
@@ -478,7 +478,7 @@ typedef struct _zend_trait_alias zend_trait_alias;
 struct _zend_class_entry {
 	char type;
 	const char *name;
-	zend_uint name_length;
+	zend_size_t name_length;
 	struct _zend_class_entry *parent;
 	int refcount;
 	zend_uint ce_flags;
@@ -502,6 +502,7 @@ struct _zend_class_entry {
 	union _zend_function *__call;
 	union _zend_function *__callstatic;
 	union _zend_function *__tostring;
+	union _zend_function *__debugInfo;
 	union _zend_function *serialize_func;
 	union _zend_function *unserialize_func;
 
@@ -511,11 +512,11 @@ struct _zend_class_entry {
 	zend_object_value (*create_object)(zend_class_entry *class_type TSRMLS_DC);
 	zend_object_iterator *(*get_iterator)(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
 	int (*interface_gets_implemented)(zend_class_entry *iface, zend_class_entry *class_type TSRMLS_DC); /* a class implements this interface */
-	union _zend_function *(*get_static_method)(zend_class_entry *ce, char* method, int method_len TSRMLS_DC);
+	union _zend_function *(*get_static_method)(zend_class_entry *ce, char* method, zend_size_t method_len TSRMLS_DC);
 
 	/* serializer callbacks */
-	int (*serialize)(zval *object, unsigned char **buffer, zend_uint *buf_len, zend_serialize_data *data TSRMLS_DC);
-	int (*unserialize)(zval **object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC);
+	int (*serialize)(zval *object, unsigned char **buffer, zend_size_t *buf_len, zend_serialize_data *data TSRMLS_DC);
+	int (*unserialize)(zval **object, zend_class_entry *ce, const unsigned char *buf, zend_size_t buf_len, zend_unserialize_data *data TSRMLS_DC);
 
 	zend_class_entry **interfaces;
 	zend_uint num_interfaces;
@@ -528,10 +529,10 @@ struct _zend_class_entry {
 	union {
 		struct {
 			const char *filename;
-			zend_uint line_start;
-			zend_uint line_end;
+			zend_size_t line_start;
+			zend_size_t line_end;
 			const char *doc_comment;
-			zend_uint doc_comment_len;
+			zend_size_t doc_comment_len;
 		} user;
 		struct {
 			const struct _zend_function_entry *builtin_functions;
@@ -542,29 +543,29 @@ struct _zend_class_entry {
 
 #include "zend_stream.h"
 typedef struct _zend_utility_functions {
-	void (*error_function)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 4, 0);
-	int (*printf_function)(const char *format, ...) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 1, 2);
-	int (*write_function)(const char *str, uint str_length);
+	void (*error_function)(int type, const char *error_filename, const zend_size_t error_lineno, const char *format, va_list args) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 4, 0);
+	zend_size_t (*printf_function)(const char *format, ...) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 1, 2);
+	zend_size_t (*write_function)(const char *str, zend_size_t str_length);
 	FILE *(*fopen_function)(const char *filename, char **opened_path TSRMLS_DC);
-	void (*message_handler)(long message, const void *data TSRMLS_DC);
+	void (*message_handler)(zend_int_t message, const void *data TSRMLS_DC);
 	void (*block_interruptions)(void);
 	void (*unblock_interruptions)(void);
-	int (*get_configuration_directive)(const char *name, uint name_length, zval *contents);
-	void (*ticks_function)(int ticks);
+	int (*get_configuration_directive)(const char *name, zend_size_t name_length, zval *contents);
+	void (*ticks_function)(int ticks TSRMLS_DC);
 	void (*on_timeout)(int seconds TSRMLS_DC);
 	int (*stream_open_function)(const char *filename, zend_file_handle *handle TSRMLS_DC);
-	int (*vspprintf_function)(char **pbuf, size_t max_len, const char *format, va_list ap);
-	char *(*getenv_function)(char *name, size_t name_len TSRMLS_DC);
-	char *(*resolve_path_function)(const char *filename, int filename_len TSRMLS_DC);
+	zend_size_t (*vspprintf_function)(char **pbuf, zend_size_t max_len, const char *format, va_list ap);
+	char *(*getenv_function)(char *name, zend_size_t name_len TSRMLS_DC);
+	char *(*resolve_path_function)(const char *filename, zend_size_t filename_len TSRMLS_DC);
 } zend_utility_functions;
 
 typedef struct _zend_utility_values {
 	char *import_use_extension;
-	uint import_use_extension_length;
+	zend_size_t import_use_extension_length;
 	zend_bool html_errors;
 } zend_utility_values;
 
-typedef int (*zend_write_func_t)(const char *str, uint str_length);
+typedef int (*zend_write_func_t)(const char *str, zend_size_t str_length);
 
 #undef MIN
 #undef MAX
@@ -580,7 +581,7 @@ typedef int (*zend_write_func_t)(const char *str, uint str_length);
 /* data types */
 /* All data types <= IS_BOOL have their constructor/destructors skipped */
 #define IS_NULL		0
-#define IS_LONG		1
+#define IS_INT		1
 #define IS_DOUBLE	2
 #define IS_BOOL		3
 #define IS_ARRAY	4
@@ -588,14 +589,11 @@ typedef int (*zend_write_func_t)(const char *str, uint str_length);
 #define IS_STRING	6
 #define IS_RESOURCE	7
 #define IS_CONSTANT	8
-#define IS_CONSTANT_ARRAY	9
-#define IS_CONSTANT_AST		10
-#define IS_CALLABLE	11
+#define IS_CONSTANT_AST	9
+#define IS_CALLABLE	10
 
-/* Ugly hack to support constants as static array indices */
 #define IS_CONSTANT_TYPE_MASK		0x00f
 #define IS_CONSTANT_UNQUALIFIED		0x010
-#define IS_CONSTANT_INDEX			0x080
 #define IS_LEXICAL_VAR				0x020
 #define IS_LEXICAL_REF				0x040
 #define IS_CONSTANT_IN_NAMESPACE	0x100
@@ -614,7 +612,7 @@ void zend_post_startup(TSRMLS_D);
 void zend_set_utility_values(zend_utility_values *utility_values);
 
 BEGIN_EXTERN_C()
-ZEND_API void _zend_bailout(char *filename, uint lineno);
+ZEND_API void _zend_bailout(char *filename, zend_size_t lineno);
 END_EXTERN_C()
 
 #define zend_bailout()		_zend_bailout(__FILE__, __LINE__)
@@ -648,8 +646,8 @@ END_EXTERN_C()
 BEGIN_EXTERN_C()
 ZEND_API char *get_zend_version(void);
 ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_copy);
-ZEND_API int zend_print_zval(zval *expr, int indent);
-ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent);
+ZEND_API zend_size_t zend_print_zval(zval *expr, int indent);
+ZEND_API zend_size_t zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent);
 ZEND_API void zend_print_zval_r(zval *expr, int indent TSRMLS_DC);
 ZEND_API void zend_print_flat_zval_r(zval *expr TSRMLS_DC);
 ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int indent TSRMLS_DC);
@@ -697,18 +695,18 @@ END_EXTERN_C()
 #define ZEND_PUTC(c)					zend_write(&(c), 1)
 
 BEGIN_EXTERN_C()
-extern ZEND_API int (*zend_printf)(const char *format, ...) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 1, 2);
+extern ZEND_API zend_size_t (*zend_printf)(const char *format, ...) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 1, 2);
 extern ZEND_API zend_write_func_t zend_write;
 extern ZEND_API FILE *(*zend_fopen)(const char *filename, char **opened_path TSRMLS_DC);
 extern ZEND_API void (*zend_block_interruptions)(void);
 extern ZEND_API void (*zend_unblock_interruptions)(void);
-extern ZEND_API void (*zend_ticks_function)(int ticks);
-extern ZEND_API void (*zend_error_cb)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 4, 0);
+extern ZEND_API void (*zend_ticks_function)(int ticks TSRMLS_DC);
+extern ZEND_API void (*zend_error_cb)(int type, const char *error_filename, const zend_size_t error_lineno, const char *format, va_list args) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 4, 0);
 extern ZEND_API void (*zend_on_timeout)(int seconds TSRMLS_DC);
 extern ZEND_API int (*zend_stream_open_function)(const char *filename, zend_file_handle *handle TSRMLS_DC);
-extern int (*zend_vspprintf)(char **pbuf, size_t max_len, const char *format, va_list ap);
-extern ZEND_API char *(*zend_getenv)(char *name, size_t name_len TSRMLS_DC);
-extern ZEND_API char *(*zend_resolve_path)(const char *filename, int filename_len TSRMLS_DC);
+extern zend_size_t (*zend_vspprintf)(char **pbuf, zend_size_t max_len, const char *format, va_list ap);
+extern ZEND_API char *(*zend_getenv)(char *name, zend_size_t name_len TSRMLS_DC);
+extern ZEND_API char *(*zend_resolve_path)(const char *filename, zend_size_t filename_len TSRMLS_DC);
 
 ZEND_API void zend_error(int type, const char *format, ...) ZEND_ATTRIBUTE_FORMAT(printf, 2, 3);
 
@@ -735,9 +733,9 @@ END_EXTERN_C()
 #endif
 
 BEGIN_EXTERN_C()
-ZEND_API void zend_message_dispatcher(long message, const void *data TSRMLS_DC);
+ZEND_API void zend_message_dispatcher(zend_int_t message, const void *data TSRMLS_DC);
 
-ZEND_API int zend_get_configuration_directive(const char *name, uint name_length, zval *contents);
+ZEND_API int zend_get_configuration_directive(const char *name, zend_size_t name_length, zval *contents);
 END_EXTERN_C()
 
 /* Messages for applications of Zend */

Zend/zend_API.h

@@ -28,7 +28,7 @@
 #include "zend_operators.h"
 #include "zend_variables.h"
 #include "zend_execute.h"
-
+#include "zend_types.h"
 
 BEGIN_EXTERN_C()
 
@@ -171,7 +171,7 @@ typedef struct _zend_fcall_info_cache {
 #define INIT_OVERLOADED_CLASS_ENTRY_EX(class_container, class_name, class_name_len, functions, handle_fcall, handle_propget, handle_propset, handle_propunset, handle_propisset) \
 	{															\
 		const char *cl_name = class_name;								\
-		int _len = class_name_len;								\
+		zend_size_t _len = class_name_len;								\
 		class_container.name = zend_new_interned_string(cl_name, _len+1, 0 TSRMLS_CC);	\
 		if (class_container.name == cl_name) {					\
 			class_container.name = zend_strndup(cl_name, _len);	\
@@ -197,6 +197,7 @@ typedef struct _zend_fcall_info_cache {
 		class_container.__set = handle_propset;					\
 		class_container.__unset = handle_propunset;				\
 		class_container.__isset = handle_propisset;				\
+		class_container.__debugInfo = NULL;					\
 		class_container.serialize_func = NULL;					\
 		class_container.unserialize_func = NULL;				\
 		class_container.serialize = NULL;						\
@@ -266,7 +267,7 @@ ZEND_API int zend_parse_parameter(int flags, int arg_num TSRMLS_DC, zval **arg,
 
 ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_function_entry *functions, HashTable *function_table, int type TSRMLS_DC);
 ZEND_API void zend_unregister_functions(const zend_function_entry *functions, int count, HashTable *function_table TSRMLS_DC);
-ZEND_API int zend_startup_module(zend_module_entry *module_entry);
+ZEND_API int zend_startup_module(zend_module_entry *module_entry TSRMLS_DC);
 ZEND_API zend_module_entry* zend_register_internal_module(zend_module_entry *module_entry TSRMLS_DC);
 ZEND_API zend_module_entry* zend_register_module_ex(zend_module_entry *module TSRMLS_DC);
 ZEND_API int zend_startup_module_ex(zend_module_entry *module TSRMLS_DC);
@@ -280,15 +281,15 @@ ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *cla
 ZEND_API zend_class_entry *zend_register_internal_interface(zend_class_entry *orig_class_entry TSRMLS_DC);
 ZEND_API void zend_class_implements(zend_class_entry *class_entry TSRMLS_DC, int num_interfaces, ...);
 
-ZEND_API int zend_register_class_alias_ex(const char *name, int name_len, zend_class_entry *ce TSRMLS_DC);
+ZEND_API int zend_register_class_alias_ex(const char *name, zend_size_t name_len, zend_class_entry *ce TSRMLS_DC);
 
 #define zend_register_class_alias(name, ce) \
 	zend_register_class_alias_ex(name, sizeof(name)-1, ce TSRMLS_CC)
 #define zend_register_ns_class_alias(ns, name, ce) \
 	zend_register_class_alias_ex(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name))-1, ce TSRMLS_CC)
 
-ZEND_API int zend_disable_function(char *function_name, uint function_name_length TSRMLS_DC);
-ZEND_API int zend_disable_class(char *class_name, uint class_name_length TSRMLS_DC);
+ZEND_API int zend_disable_function(char *function_name, zend_size_t function_name_length TSRMLS_DC);
+ZEND_API int zend_disable_class(char *class_name, zend_size_t class_name_length TSRMLS_DC);
 
 ZEND_API void zend_wrong_param_count(TSRMLS_D);
 
@@ -299,51 +300,51 @@ ZEND_API void zend_wrong_param_count(TSRMLS_D);
 
 #define IS_CALLABLE_STRICT  (IS_CALLABLE_CHECK_IS_STATIC)
 
-ZEND_API zend_bool zend_is_callable_ex(zval *callable, zval *object_ptr, uint check_flags, char **callable_name, int *callable_name_len, zend_fcall_info_cache *fcc, char **error TSRMLS_DC);
+ZEND_API zend_bool zend_is_callable_ex(zval *callable, zval *object_ptr, uint check_flags, char **callable_name, zend_size_t *callable_name_len, zend_fcall_info_cache *fcc, char **error TSRMLS_DC);
 ZEND_API zend_bool zend_is_callable(zval *callable, uint check_flags, char **callable_name TSRMLS_DC);
 ZEND_API zend_bool zend_make_callable(zval *callable, char **callable_name TSRMLS_DC);
 ZEND_API const char *zend_get_module_version(const char *module_name);
 ZEND_API int zend_get_module_started(const char *module_name);
-ZEND_API int zend_declare_property(zend_class_entry *ce, const char *name, int name_length, zval *property, int access_type TSRMLS_DC);
-ZEND_API int zend_declare_property_ex(zend_class_entry *ce, const char *name, int name_length, zval *property, int access_type, const char *doc_comment, int doc_comment_len TSRMLS_DC);
-ZEND_API int zend_declare_property_null(zend_class_entry *ce, const char *name, int name_length, int access_type TSRMLS_DC);
-ZEND_API int zend_declare_property_bool(zend_class_entry *ce, const char *name, int name_length, long value, int access_type TSRMLS_DC);
-ZEND_API int zend_declare_property_long(zend_class_entry *ce, const char *name, int name_length, long value, int access_type TSRMLS_DC);
-ZEND_API int zend_declare_property_double(zend_class_entry *ce, const char *name, int name_length, double value, int access_type TSRMLS_DC);
-ZEND_API int zend_declare_property_string(zend_class_entry *ce, const char *name, int name_length, const char *value, int access_type TSRMLS_DC);
-ZEND_API int zend_declare_property_stringl(zend_class_entry *ce, const char *name, int name_length, const char *value, int value_len, int access_type TSRMLS_DC);
+ZEND_API int zend_declare_property(zend_class_entry *ce, const char *name, zend_size_t name_length, zval *property, int access_type TSRMLS_DC);
+ZEND_API int zend_declare_property_ex(zend_class_entry *ce, const char *name, zend_size_t name_length, zval *property, int access_type, const char *doc_comment, zend_size_t doc_comment_len TSRMLS_DC);
+ZEND_API int zend_declare_property_null(zend_class_entry *ce, const char *name, zend_size_t name_length, int access_type TSRMLS_DC);
+ZEND_API int zend_declare_property_bool(zend_class_entry *ce, const char *name, zend_size_t name_length, zend_int_t value, int access_type TSRMLS_DC);
+ZEND_API int zend_declare_property_int(zend_class_entry *ce, const char *name, zend_size_t name_length, zend_int_t value, int access_type TSRMLS_DC);
+ZEND_API int zend_declare_property_double(zend_class_entry *ce, const char *name, zend_size_t name_length, double value, int access_type TSRMLS_DC);
+ZEND_API int zend_declare_property_string(zend_class_entry *ce, const char *name, zend_size_t name_length, const char *value, int access_type TSRMLS_DC);
+ZEND_API int zend_declare_property_stringl(zend_class_entry *ce, const char *name, zend_size_t name_length, const char *value, zend_size_t value_len, int access_type TSRMLS_DC);
 
-ZEND_API int zend_declare_class_constant(zend_class_entry *ce, const char *name, size_t name_length, zval *value TSRMLS_DC);
-ZEND_API int zend_declare_class_constant_null(zend_class_entry *ce, const char *name, size_t name_length TSRMLS_DC);
-ZEND_API int zend_declare_class_constant_long(zend_class_entry *ce, const char *name, size_t name_length, long value TSRMLS_DC);
-ZEND_API int zend_declare_class_constant_bool(zend_class_entry *ce, const char *name, size_t name_length, zend_bool value TSRMLS_DC);
-ZEND_API int zend_declare_class_constant_double(zend_class_entry *ce, const char *name, size_t name_length, double value TSRMLS_DC);
-ZEND_API int zend_declare_class_constant_stringl(zend_class_entry *ce, const char *name, size_t name_length, const char *value, size_t value_length TSRMLS_DC);
-ZEND_API int zend_declare_class_constant_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value TSRMLS_DC);
+ZEND_API int zend_declare_class_constant(zend_class_entry *ce, const char *name, zend_size_t name_length, zval *value TSRMLS_DC);
+ZEND_API int zend_declare_class_constant_null(zend_class_entry *ce, const char *name, zend_size_t name_length TSRMLS_DC);
+ZEND_API int zend_declare_class_constant_int(zend_class_entry *ce, const char *name, zend_size_t name_length, zend_int_t value TSRMLS_DC);
+ZEND_API int zend_declare_class_constant_bool(zend_class_entry *ce, const char *name, zend_size_t name_length, zend_bool value TSRMLS_DC);
+ZEND_API int zend_declare_class_constant_double(zend_class_entry *ce, const char *name, zend_size_t name_length, double value TSRMLS_DC);
+ZEND_API int zend_declare_class_constant_stringl(zend_class_entry *ce, const char *name, zend_size_t name_length, const char *value, zend_size_t value_length TSRMLS_DC);
+ZEND_API int zend_declare_class_constant_string(zend_class_entry *ce, const char *name, zend_size_t name_length, const char *value TSRMLS_DC);
 
 ZEND_API void zend_update_class_constants(zend_class_entry *class_type TSRMLS_DC);
-ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, const char *name, int name_length, zval *value TSRMLS_DC);
-ZEND_API void zend_update_property_null(zend_class_entry *scope, zval *object, const char *name, int name_length TSRMLS_DC);
-ZEND_API void zend_update_property_bool(zend_class_entry *scope, zval *object, const char *name, int name_length, long value TSRMLS_DC);
-ZEND_API void zend_update_property_long(zend_class_entry *scope, zval *object, const char *name, int name_length, long value TSRMLS_DC);
-ZEND_API void zend_update_property_double(zend_class_entry *scope, zval *object, const char *name, int name_length, double value TSRMLS_DC);
-ZEND_API void zend_update_property_string(zend_class_entry *scope, zval *object, const char *name, int name_length, const char *value TSRMLS_DC);
-ZEND_API void zend_update_property_stringl(zend_class_entry *scope, zval *object, const char *name, int name_length, const char *value, int value_length TSRMLS_DC);
+ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, const char *name, zend_size_t name_length, zval *value TSRMLS_DC);
+ZEND_API void zend_update_property_null(zend_class_entry *scope, zval *object, const char *name, zend_size_t name_length TSRMLS_DC);
+ZEND_API void zend_update_property_bool(zend_class_entry *scope, zval *object, const char *name, zend_size_t name_length, zend_int_t value TSRMLS_DC);
+ZEND_API void zend_update_property_int(zend_class_entry *scope, zval *object, const char *name, zend_size_t name_length, zend_int_t value TSRMLS_DC);
+ZEND_API void zend_update_property_double(zend_class_entry *scope, zval *object, const char *name, zend_size_t name_length, double value TSRMLS_DC);
+ZEND_API void zend_update_property_string(zend_class_entry *scope, zval *object, const char *name, zend_size_t name_length, const char *value TSRMLS_DC);
+ZEND_API void zend_update_property_stringl(zend_class_entry *scope, zval *object, const char *name, zend_size_t name_length, const char *value, zend_size_t value_length TSRMLS_DC);
 
-ZEND_API int zend_update_static_property(zend_class_entry *scope, const char *name, int name_length, zval *value TSRMLS_DC);
-ZEND_API int zend_update_static_property_null(zend_class_entry *scope, const char *name, int name_length TSRMLS_DC);
-ZEND_API int zend_update_static_property_bool(zend_class_entry *scope, const char *name, int name_length, long value TSRMLS_DC);
-ZEND_API int zend_update_static_property_long(zend_class_entry *scope, const char *name, int name_length, long value TSRMLS_DC);
-ZEND_API int zend_update_static_property_double(zend_class_entry *scope, const char *name, int name_length, double value TSRMLS_DC);
-ZEND_API int zend_update_static_property_string(zend_class_entry *scope, const char *name, int name_length, const char *value TSRMLS_DC);
-ZEND_API int zend_update_static_property_stringl(zend_class_entry *scope, const char *name, int name_length, const char *value, int value_length TSRMLS_DC);
+ZEND_API int zend_update_static_property(zend_class_entry *scope, const char *name, zend_size_t name_length, zval *value TSRMLS_DC);
+ZEND_API int zend_update_static_property_null(zend_class_entry *scope, const char *name, zend_size_t name_length TSRMLS_DC);
+ZEND_API int zend_update_static_property_bool(zend_class_entry *scope, const char *name, zend_size_t name_length, zend_int_t value TSRMLS_DC);
+ZEND_API int zend_update_static_property_int(zend_class_entry *scope, const char *name, zend_size_t name_length, zend_int_t value TSRMLS_DC);
+ZEND_API int zend_update_static_property_double(zend_class_entry *scope, const char *name, zend_size_t name_length, double value TSRMLS_DC);
+ZEND_API int zend_update_static_property_string(zend_class_entry *scope, const char *name, zend_size_t name_length, const char *value TSRMLS_DC);
+ZEND_API int zend_update_static_property_stringl(zend_class_entry *scope, const char *name, zend_size_t name_length, const char *value, zend_size_t value_length TSRMLS_DC);
 
-ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, const char *name, int name_length, zend_bool silent TSRMLS_DC);
+ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, const char *name, zend_size_t name_length, zend_bool silent TSRMLS_DC);
 
-ZEND_API zval *zend_read_static_property(zend_class_entry *scope, const char *name, int name_length, zend_bool silent TSRMLS_DC);
+ZEND_API zval *zend_read_static_property(zend_class_entry *scope, const char *name, zend_size_t name_length, zend_bool silent TSRMLS_DC);
 
 ZEND_API zend_class_entry *zend_get_class_entry(const zval *zobject TSRMLS_DC);
-ZEND_API int zend_get_object_classname(const zval *object, const char **class_name, zend_uint *class_name_len TSRMLS_DC);
+ZEND_API int zend_get_object_classname(const zval *object, const char **class_name, zend_size_t *class_name_len TSRMLS_DC);
 ZEND_API char *zend_get_type_by_const(int type);
 
 #define getThis() (this_ptr)
@@ -364,7 +365,7 @@ ZEND_API char *zend_get_type_by_const(int type);
 #define object_init(arg)		_object_init((arg) ZEND_FILE_LINE_CC TSRMLS_CC)
 #define object_init_ex(arg, ce)	_object_init_ex((arg), (ce) ZEND_FILE_LINE_CC TSRMLS_CC)
 #define object_and_properties_init(arg, ce, properties)	_object_and_properties_init((arg), (ce), (properties) ZEND_FILE_LINE_CC TSRMLS_CC)
-ZEND_API int _array_init(zval *arg, uint size ZEND_FILE_LINE_DC);
+ZEND_API int _array_init(zval *arg, zend_uint_t size ZEND_FILE_LINE_DC);
 ZEND_API int _object_init(zval *arg ZEND_FILE_LINE_DC TSRMLS_DC);
 ZEND_API int _object_init_ex(zval *arg, zend_class_entry *ce ZEND_FILE_LINE_DC TSRMLS_DC);
 ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *ce, HashTable *properties ZEND_FILE_LINE_DC TSRMLS_DC);
@@ -375,16 +376,16 @@ ZEND_API void zend_merge_properties(zval *obj, HashTable *properties, int destro
 /* no longer supported */
 ZEND_API int add_assoc_function(zval *arg, const char *key, void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS));
 
-ZEND_API int add_assoc_long_ex(zval *arg, const char *key, uint key_len, long n);
-ZEND_API int add_assoc_null_ex(zval *arg, const char *key, uint key_len);
-ZEND_API int add_assoc_bool_ex(zval *arg, const char *key, uint key_len, int b);
-ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, uint key_len, int r);
-ZEND_API int add_assoc_double_ex(zval *arg, const char *key, uint key_len, double d);
-ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str, int duplicate);
-ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length, int duplicate);
-ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value);
+ZEND_API int add_assoc_int_ex(zval *arg, const char *key, zend_size_t key_len, zend_int_t n);
+ZEND_API int add_assoc_null_ex(zval *arg, const char *key, zend_size_t key_len);
+ZEND_API int add_assoc_bool_ex(zval *arg, const char *key, zend_size_t key_len, int b);
+ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, zend_size_t key_len, int r);
+ZEND_API int add_assoc_double_ex(zval *arg, const char *key, zend_size_t key_len, double d);
+ZEND_API int add_assoc_string_ex(zval *arg, const char *key, zend_size_t key_len, char *str, int duplicate);
+ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, zend_size_t key_len, char *str, zend_size_t length, int duplicate);
+ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, zend_size_t key_len, zval *value);
 
-#define add_assoc_long(__arg, __key, __n) add_assoc_long_ex(__arg, __key, strlen(__key)+1, __n)
+#define add_assoc_int(__arg, __key, __n) add_assoc_int_ex(__arg, __key, strlen(__key)+1, __n)
 #define add_assoc_null(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key) + 1)
 #define add_assoc_bool(__arg, __key, __b) add_assoc_bool_ex(__arg, __key, strlen(__key)+1, __b)
 #define add_assoc_resource(__arg, __key, __r) add_assoc_resource_ex(__arg, __key, strlen(__key)+1, __r)
@@ -399,47 +400,47 @@ ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *v
 #define add_next_index_unset(__arg) add_next_index_null(__arg)
 #define add_property_unset(__arg, __key) add_property_null(__arg, __key)
 
-ZEND_API int add_index_long(zval *arg, ulong idx, long n);
-ZEND_API int add_index_null(zval *arg, ulong idx);
-ZEND_API int add_index_bool(zval *arg, ulong idx, int b);
-ZEND_API int add_index_resource(zval *arg, ulong idx, int r);
-ZEND_API int add_index_double(zval *arg, ulong idx, double d);
-ZEND_API int add_index_string(zval *arg, ulong idx, const char *str, int duplicate);
-ZEND_API int add_index_stringl(zval *arg, ulong idx, const char *str, uint length, int duplicate);
-ZEND_API int add_index_zval(zval *arg, ulong index, zval *value);
+ZEND_API int add_index_int(zval *arg, zend_uint_t idx, zend_int_t n);
+ZEND_API int add_index_null(zval *arg, zend_uint_t idx);
+ZEND_API int add_index_bool(zval *arg, zend_uint_t idx, int b);
+ZEND_API int add_index_resource(zval *arg, zend_uint_t idx, int r);
+ZEND_API int add_index_double(zval *arg, zend_uint_t idx, double d);
+ZEND_API int add_index_string(zval *arg, zend_uint_t idx, const char *str, int duplicate);
+ZEND_API int add_index_stringl(zval *arg, zend_uint_t idx, const char *str, zend_size_t length, int duplicate);
+ZEND_API int add_index_zval(zval *arg, zend_uint_t index, zval *value);
 
-ZEND_API int add_next_index_long(zval *arg, long n);
+ZEND_API int add_next_index_int(zval *arg, zend_int_t n);
 ZEND_API int add_next_index_null(zval *arg);
 ZEND_API int add_next_index_bool(zval *arg, int b);
 ZEND_API int add_next_index_resource(zval *arg, int r);
 ZEND_API int add_next_index_double(zval *arg, double d);
 ZEND_API int add_next_index_string(zval *arg, const char *str, int duplicate);
-ZEND_API int add_next_index_stringl(zval *arg, const char *str, uint length, int duplicate);
+ZEND_API int add_next_index_stringl(zval *arg, const char *str, zend_size_t length, int duplicate);
 ZEND_API int add_next_index_zval(zval *arg, zval *value);
 
-ZEND_API int add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str, void **dest, int duplicate);
-ZEND_API int add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length, void **dest, int duplicate);
+ZEND_API int add_get_assoc_string_ex(zval *arg, const char *key, zend_size_t key_len, const char *str, void **dest, int duplicate);
+ZEND_API int add_get_assoc_stringl_ex(zval *arg, const char *key, zend_size_t key_len, const char *str, zend_size_t length, void **dest, int duplicate);
 
 #define add_get_assoc_string(__arg, __key, __str, __dest, __duplicate) add_get_assoc_string_ex(__arg, __key, strlen(__key)+1, __str, __dest, __duplicate)
 #define add_get_assoc_stringl(__arg, __key, __str, __length, __dest, __duplicate) add_get_assoc_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __dest, __duplicate)
 
-ZEND_API int add_get_index_long(zval *arg, ulong idx, long l, void **dest);
-ZEND_API int add_get_index_double(zval *arg, ulong idx, double d, void **dest);
-ZEND_API int add_get_index_string(zval *arg, ulong idx, const char *str, void **dest, int duplicate);
-ZEND_API int add_get_index_stringl(zval *arg, ulong idx, const char *str, uint length, void **dest, int duplicate);
+ZEND_API int add_get_index_int(zval *arg, zend_uint_t idx, zend_int_t l, void **dest);
+ZEND_API int add_get_index_double(zval *arg, zend_uint_t idx, double d, void **dest);
+ZEND_API int add_get_index_string(zval *arg, zend_uint_t idx, const char *str, void **dest, int duplicate);
+ZEND_API int add_get_index_stringl(zval *arg, zend_uint_t idx, const char *str, zend_size_t length, void **dest, int duplicate);
 
 ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value);
 
-ZEND_API int add_property_long_ex(zval *arg, const char *key, uint key_len, long l TSRMLS_DC);
-ZEND_API int add_property_null_ex(zval *arg, const char *key, uint key_len TSRMLS_DC);
-ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, int b TSRMLS_DC);
-ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len, long r TSRMLS_DC);
-ZEND_API int add_property_double_ex(zval *arg, const char *key, uint key_len, double d TSRMLS_DC);
-ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str, int duplicate TSRMLS_DC);
-ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len,  const char *str, uint length, int duplicate TSRMLS_DC);
-ZEND_API int add_property_zval_ex(zval *arg, const char *key, uint key_len, zval *value TSRMLS_DC);
+ZEND_API int add_property_int_ex(zval *arg, const char *key, zend_size_t key_len, zend_int_t l TSRMLS_DC);
+ZEND_API int add_property_null_ex(zval *arg, const char *key, zend_size_t key_len TSRMLS_DC);
+ZEND_API int add_property_bool_ex(zval *arg, const char *key, zend_size_t key_len, int b TSRMLS_DC);
+ZEND_API int add_property_resource_ex(zval *arg, const char *key, zend_size_t key_len, zend_int_t r TSRMLS_DC);
+ZEND_API int add_property_double_ex(zval *arg, const char *key, zend_size_t key_len, double d TSRMLS_DC);
+ZEND_API int add_property_string_ex(zval *arg, const char *key, zend_size_t key_len, const char *str, int duplicate TSRMLS_DC);
+ZEND_API int add_property_stringl_ex(zval *arg, const char *key, zend_size_t key_len,  const char *str, zend_size_t length, int duplicate TSRMLS_DC);
+ZEND_API int add_property_zval_ex(zval *arg, const char *key, zend_size_t key_len, zval *value TSRMLS_DC);
 
-#define add_property_long(__arg, __key, __n) add_property_long_ex(__arg, __key, strlen(__key)+1, __n TSRMLS_CC)
+#define add_property_int(__arg, __key, __n) add_property_int_ex(__arg, __key, strlen(__key)+1, __n TSRMLS_CC)
 #define add_property_null(__arg, __key) add_property_null_ex(__arg, __key, strlen(__key) + 1 TSRMLS_CC)
 #define add_property_bool(__arg, __key, __b) add_property_bool_ex(__arg, __key, strlen(__key)+1, __b TSRMLS_CC)
 #define add_property_resource(__arg, __key, __r) add_property_resource_ex(__arg, __key, strlen(__key)+1, __r TSRMLS_CC)
@@ -511,19 +512,19 @@ ZEND_API int zend_fcall_info_call(zend_fcall_info *fci, zend_fcall_info_cache *f
 
 ZEND_API int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TSRMLS_DC);
 
-ZEND_API int zend_set_hash_symbol(zval *symbol, const char *name, int name_length, zend_bool is_ref, int num_symbol_tables, ...);
+ZEND_API int zend_set_hash_symbol(zval *symbol, const char *name, zend_size_t name_length, zend_bool is_ref, int num_symbol_tables, ...);
 
-ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, const char *name, int name_len, ulong hash_value TSRMLS_DC);
+ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, const char *name, zend_size_t name_len, zend_uint_t hash_value TSRMLS_DC);
 
-ZEND_API int zend_delete_global_variable(const char *name, int name_len TSRMLS_DC);
+ZEND_API int zend_delete_global_variable(const char *name, zend_size_t name_len TSRMLS_DC);
 
-ZEND_API int zend_delete_global_variable_ex(const char *name, int name_len, ulong hash_value TSRMLS_DC);
+ZEND_API int zend_delete_global_variable_ex(const char *name, zend_size_t name_len, zend_uint_t hash_value TSRMLS_DC);
 
 ZEND_API void zend_reset_all_cv(HashTable *symbol_table TSRMLS_DC);
 
 ZEND_API void zend_rebuild_symbol_table(TSRMLS_D);
 
-ZEND_API const char* zend_find_alias_name(zend_class_entry *ce, const char *name, zend_uint len);
+ZEND_API const char* zend_find_alias_name(zend_class_entry *ce, const char *name, zend_size_t len);
 ZEND_API const char* zend_resolve_method_name(zend_class_entry *ce, zend_function *f);
 
 #define add_method(arg, key, method)	add_assoc_function((arg), (key), (method))
@@ -534,26 +535,26 @@ END_EXTERN_C()
 
 #if ZEND_DEBUG
 #define CHECK_ZVAL_STRING(z) \
-	if (Z_STRVAL_P(z)[ Z_STRLEN_P(z) ] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s)", Z_STRVAL_P(z)); }
+	if (Z_STRVAL_P(z)[ Z_STRSIZE_P(z) ] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s)", Z_STRVAL_P(z)); }
 #define CHECK_ZVAL_STRING_REL(z) \
-	if (Z_STRVAL_P(z)[ Z_STRLEN_P(z) ] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s) (source: %s:%d)", Z_STRVAL_P(z) ZEND_FILE_LINE_RELAY_CC); }
+	if (Z_STRVAL_P(z)[ Z_STRSIZE_P(z) ] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s) (source: %s:%d)", Z_STRVAL_P(z) ZEND_FILE_LINE_RELAY_CC); }
 #else
 #define CHECK_ZVAL_STRING(z)
 #define CHECK_ZVAL_STRING_REL(z)
 #endif
 
-#define CHECK_ZVAL_NULL_PATH(p) (Z_STRLEN_P(p) != strlen(Z_STRVAL_P(p)))
+#define CHECK_ZVAL_NULL_PATH(p) (Z_STRSIZE_P(p) != strlen(Z_STRVAL_P(p)))
 #define CHECK_NULL_PATH(p, l) (strlen(p) != l)
 
 #define ZVAL_RESOURCE(z, l) do {	\
 		zval *__z = (z);			\
-		Z_LVAL_P(__z) = l;			\
+		Z_IVAL_P(__z) = l;			\
 		Z_TYPE_P(__z) = IS_RESOURCE;\
 	} while (0)
 
 #define ZVAL_BOOL(z, b) do {		\
 		zval *__z = (z);			\
-		Z_LVAL_P(__z) = ((b) != 0);	\
+		Z_IVAL_P(__z) = ((b) != 0);	\
 		Z_TYPE_P(__z) = IS_BOOL;	\
 	} while (0)
 
@@ -561,10 +562,10 @@ END_EXTERN_C()
 		Z_TYPE_P(z) = IS_NULL;		\
 	}
 
-#define ZVAL_LONG(z, l) {			\
+#define ZVAL_INT(z, l) {			\
 		zval *__z = (z);			\
-		Z_LVAL_P(__z) = l;			\
-		Z_TYPE_P(__z) = IS_LONG;	\
+		Z_IVAL_P(__z) = l;			\
+		Z_TYPE_P(__z) = IS_INT;	\
 	}
 
 #define ZVAL_DOUBLE(z, d) {			\
@@ -576,22 +577,22 @@ END_EXTERN_C()
 #define ZVAL_STRING(z, s, duplicate) do {	\
 		const char *__s=(s);				\
 		zval *__z = (z);					\
-		Z_STRLEN_P(__z) = strlen(__s);		\
-		Z_STRVAL_P(__z) = (duplicate?estrndup(__s, Z_STRLEN_P(__z)):(char*)__s);\
+		Z_STRSIZE_P(__z) = (zend_size_t) strlen(__s);		\
+		Z_STRVAL_P(__z) = (duplicate?estrndup(__s, Z_STRSIZE_P(__z)):(char*)__s);\
 		Z_TYPE_P(__z) = IS_STRING;			\
 	} while (0)
 
 #define ZVAL_STRINGL(z, s, l, duplicate) do {	\
-		const char *__s=(s); int __l=l;			\
+		const char *__s=(s); zend_size_t __l= (zend_size_t) (l);			\
 		zval *__z = (z);						\
-		Z_STRLEN_P(__z) = __l;					\
+		Z_STRSIZE_P(__z) = __l;					\
 		Z_STRVAL_P(__z) = (duplicate?estrndup(__s, __l):(char*)__s);\
 		Z_TYPE_P(__z) = IS_STRING;				\
 	} while (0)
 
 #define ZVAL_EMPTY_STRING(z) do {	\
 		zval *__z = (z);			\
-		Z_STRLEN_P(__z) = 0;		\
+		Z_STRSIZE_P(__z) = 0;		\
 		Z_STRVAL_P(__z) = STR_EMPTY_ALLOC();\
 		Z_TYPE_P(__z) = IS_STRING;	\
 	} while (0)
@@ -617,7 +618,7 @@ END_EXTERN_C()
 #define RETVAL_RESOURCE(l)				ZVAL_RESOURCE(return_value, l)
 #define RETVAL_BOOL(b)					ZVAL_BOOL(return_value, b)
 #define RETVAL_NULL() 					ZVAL_NULL(return_value)
-#define RETVAL_LONG(l) 					ZVAL_LONG(return_value, l)
+#define RETVAL_INT(l) 					ZVAL_INT(return_value, l)
 #define RETVAL_DOUBLE(d) 				ZVAL_DOUBLE(return_value, d)
 #define RETVAL_STRING(s, duplicate) 		ZVAL_STRING(return_value, s, duplicate)
 #define RETVAL_STRINGL(s, l, duplicate) 	ZVAL_STRINGL(return_value, s, l, duplicate)
@@ -629,7 +630,7 @@ END_EXTERN_C()
 #define RETURN_RESOURCE(l) 				{ RETVAL_RESOURCE(l); return; }
 #define RETURN_BOOL(b) 					{ RETVAL_BOOL(b); return; }
 #define RETURN_NULL() 					{ RETVAL_NULL(); return;}
-#define RETURN_LONG(l) 					{ RETVAL_LONG(l); return; }
+#define RETURN_INT(l) 					{ RETVAL_INT(l); return; }
 #define RETURN_DOUBLE(d) 				{ RETVAL_DOUBLE(d); return; }
 #define RETURN_STRING(s, duplicate) 	{ RETVAL_STRING(s, duplicate); return; }
 #define RETURN_STRINGL(s, l, duplicate) { RETVAL_STRINGL(s, l, duplicate); return; }
@@ -668,11 +669,11 @@ END_EXTERN_C()
 									}													\
 								}
 
-#define SET_VAR_LONG(n, v)	{															\
+#define SET_VAR_INT(n, v)	{															\
 								{														\
 									zval *var;											\
 									ALLOC_ZVAL(var);									\
-									ZVAL_LONG(var, v);									\
+									ZVAL_INT(var, v);									\
 									ZEND_SET_GLOBAL_VAR(n, var);						\
 								}														\
 							}
@@ -728,7 +729,7 @@ END_EXTERN_C()
 #define ZEND_DEFINE_PROPERTY(class_ptr, name, value, mask)							\
 {																					\
 	char *_name = (name);															\
-	int namelen = strlen(_name);													\
+	zend_size_t namelen = strlen(_name);													\
 	zend_declare_property(class_ptr, _name, namelen, value, mask TSRMLS_CC);		\
 }
 

Zend/zend_alloc.c

@@ -433,7 +433,7 @@ struct _zend_mm_heap {
 	int                 overflow;
 	int                 internal;
 #if ZEND_MM_CACHE
-	unsigned int        cached;
+	size_t              cached;
 	zend_mm_free_block *cache[ZEND_MM_NUM_BUCKETS];
 #endif
 	zend_mm_free_block *free_buckets[ZEND_MM_NUM_BUCKETS*2];
@@ -488,16 +488,16 @@ static unsigned int _zend_mm_cookie = 0;
 #define ZEND_MM_RESERVE_SIZE            (8*1024)
 
 #ifdef _WIN64
-# define ZEND_MM_LONG_CONST(x)	(x##i64)
+# define ZEND_MM_INT_CONST(x)	(x##i64)
 #else
-# define ZEND_MM_LONG_CONST(x)	(x##L)
+# define ZEND_MM_INT_CONST(x)	(x##L)
 #endif
 
-#define ZEND_MM_TYPE_MASK		ZEND_MM_LONG_CONST(0x3)
+#define ZEND_MM_TYPE_MASK		ZEND_MM_INT_CONST(0x3)
 
-#define ZEND_MM_FREE_BLOCK		ZEND_MM_LONG_CONST(0x0)
-#define ZEND_MM_USED_BLOCK		ZEND_MM_LONG_CONST(0x1)
-#define ZEND_MM_GUARD_BLOCK		ZEND_MM_LONG_CONST(0x3)
+#define ZEND_MM_FREE_BLOCK		ZEND_MM_INT_CONST(0x0)
+#define ZEND_MM_USED_BLOCK		ZEND_MM_INT_CONST(0x1)
+#define ZEND_MM_GUARD_BLOCK		ZEND_MM_INT_CONST(0x3)
 
 #define ZEND_MM_BLOCK(b, type, size)	do { \
 											size_t _size = (size); \
@@ -615,11 +615,11 @@ static unsigned int _zend_mm_cookie = 0;
 # define END_MAGIC_SIZE sizeof(unsigned int)
 
 # define ZEND_MM_SET_BLOCK_SIZE(block, __size) do { \
-		char *p; \
+		char *__p; \
 		((zend_mm_block*)(block))->debug.size = (__size); \
-		p = ZEND_MM_END_MAGIC_PTR(block); \
+		__p = ZEND_MM_END_MAGIC_PTR(block); \
 		((zend_mm_block*)(block))->debug.start_magic = _mem_block_start_magic; \
-		memcpy(p, &_mem_block_end_magic, END_MAGIC_SIZE); \
+		memcpy(__p, &_mem_block_end_magic, END_MAGIC_SIZE); \
 	} while (0)
 
 static unsigned int _mem_block_start_magic = 0;
@@ -742,7 +742,7 @@ static inline void zend_mm_add_to_free_list(zend_mm_heap *heap, zend_mm_free_blo
 			*p = mm_block;
 			mm_block->parent = p;
 			mm_block->prev_free_block = mm_block->next_free_block = mm_block;
-			heap->large_free_bitmap |= (ZEND_MM_LONG_CONST(1) << index);
+			heap->large_free_bitmap |= (ZEND_MM_INT_CONST(1) << index);
 		} else {
 			size_t m;
 
@@ -775,7 +775,7 @@ static inline void zend_mm_add_to_free_list(zend_mm_heap *heap, zend_mm_free_blo
 
 		prev = ZEND_MM_SMALL_FREE_BUCKET(heap, index);
 		if (prev->prev_free_block == prev) {
-			heap->free_bitmap |= (ZEND_MM_LONG_CONST(1) << index);
+			heap->free_bitmap |= (ZEND_MM_INT_CONST(1) << index);
 		}
 		next = prev->next_free_block;
 
@@ -809,7 +809,7 @@ static inline void zend_mm_remove_from_free_list(zend_mm_heap *heap, zend_mm_fre
 			ZEND_MM_CHECK_TREE(mm_block);
 			*mm_block->parent = NULL;
 			if (mm_block->parent == &heap->large_free_buckets[index]) {
-				heap->large_free_bitmap &= ~(ZEND_MM_LONG_CONST(1) << index);
+				heap->large_free_bitmap &= ~(ZEND_MM_INT_CONST(1) << index);
 		    }
 		} else {
 			while (*(cp = &(prev->child[prev->child[1] != NULL])) != NULL) {
@@ -847,7 +847,7 @@ subst_block:
 				size_t index = ZEND_MM_BUCKET_INDEX(ZEND_MM_FREE_BLOCK_SIZE(mm_block));
 
 				if (EXPECTED(heap->free_buckets[index*2] == heap->free_buckets[index*2+1])) {
-					heap->free_bitmap &= ~(ZEND_MM_LONG_CONST(1) << index);
+					heap->free_bitmap &= ~(ZEND_MM_INT_CONST(1) << index);
 				}
 			}
 		} else if (UNEXPECTED(mm_block->parent == ZEND_MM_REST_BLOCK)) {
@@ -1116,7 +1116,7 @@ ZEND_API zend_mm_heap *zend_mm_startup_ex(const zend_mm_mem_handlers *handlers,
 	heap->real_size = 0;
 	heap->overflow = 0;
 	heap->real_peak = 0;
-	heap->limit = ZEND_MM_LONG_CONST(1)<<(ZEND_MM_NUM_BUCKETS-2);
+	heap->limit = ZEND_MM_INT_CONST(1)<<(ZEND_MM_NUM_BUCKETS-2);
 	heap->size = 0;
 	heap->peak = 0;
 	heap->internal = internal;
@@ -1231,9 +1231,9 @@ ZEND_API zend_mm_heap *zend_mm_startup(void)
 }
 
 #if ZEND_DEBUG
-static long zend_mm_find_leaks(zend_mm_segment *segment, zend_mm_block *b)
+static zend_int_t zend_mm_find_leaks(zend_mm_segment *segment, zend_mm_block *b)
 {
-	long leaks = 0;
+	zend_int_t leaks = 0;
 	zend_mm_block *p, *q;
 
 	p = ZEND_MM_NEXT_BLOCK(b);
@@ -1291,7 +1291,7 @@ static void zend_mm_check_leaks(zend_mm_heap *heap TSRMLS_DC)
 		}
 		if (!ZEND_MM_IS_FREE_BLOCK(p)) {
 			if (p->magic == MEM_BLOCK_VALID) {
-				long repeated;
+				zend_int_t repeated;
 				zend_leak_info leak;
 
 				ZEND_MM_SET_MAGIC(p, MEM_BLOCK_LEAK);
@@ -1745,7 +1745,7 @@ static void zend_mm_safe_error(zend_mm_heap *heap,
 	size_t limit,
 #if ZEND_DEBUG
 	const char *filename,
-	uint lineno,
+	zend_uint_t lineno,
 #endif
 	size_t size)
 {
@@ -1791,7 +1791,7 @@ static void zend_mm_safe_error(zend_mm_heap *heap,
 					lineno,
 #endif
 					size);
-				fprintf(stderr, " in %s on line %d\n", error_filename, error_lineno);
+				fprintf(stderr, " in %s on line " ZEND_UINT_FMT "\n", error_filename, error_lineno);
 			}
 /* See http://support.microsoft.com/kb/190351 */
 #ifdef PHP_WIN32
@@ -1831,7 +1831,7 @@ static zend_mm_free_block *zend_mm_search_large_block(zend_mm_heap *heap, size_t
 				best_size = ZEND_MM_FREE_BLOCK_SIZE(p);
 				best_fit = p;
 			}
-			if ((m & (ZEND_MM_LONG_CONST(1) << (ZEND_MM_NUM_BUCKETS-1))) == 0) {
+			if ((m & (ZEND_MM_INT_CONST(1) << (ZEND_MM_NUM_BUCKETS-1))) == 0) {
 				if (p->child[1]) {
 					rst = p->child[1];
 				}
@@ -1973,9 +1973,9 @@ static void *_zend_mm_alloc_int(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_D
 #endif
 			HANDLE_UNBLOCK_INTERRUPTIONS();
 #if ZEND_DEBUG
-			zend_mm_safe_error(heap, "Allowed memory size of %ld bytes exhausted at %s:%d (tried to allocate %lu bytes)", heap->limit, __zend_filename, __zend_lineno, size);
+			zend_mm_safe_error(heap, "Allowed memory size of " ZEND_INT_FMT " bytes exhausted at %s:%d (tried to allocate " ZEND_UINT_FMT " bytes)", heap->limit, __zend_filename, __zend_lineno, size);
 #else
-			zend_mm_safe_error(heap, "Allowed memory size of %ld bytes exhausted (tried to allocate %lu bytes)", heap->limit, size);
+			zend_mm_safe_error(heap, "Allowed memory size of " ZEND_INT_FMT " bytes exhausted (tried to allocate " ZEND_UINT_FMT " bytes)", heap->limit, size);
 #endif
 		}
 
@@ -2286,9 +2286,9 @@ realloc_segment:
 #endif
 			HANDLE_UNBLOCK_INTERRUPTIONS();
 #if ZEND_DEBUG
-			zend_mm_safe_error(heap, "Allowed memory size of %ld bytes exhausted at %s:%d (tried to allocate %ld bytes)", heap->limit, __zend_filename, __zend_lineno, size);
+			zend_mm_safe_error(heap, "Allowed memory size of " ZEND_INT_FMT " bytes exhausted at %s:%d (tried to allocate " ZEND_UINT_FMT " bytes)", heap->limit, __zend_filename, __zend_lineno, size);
 #else
-			zend_mm_safe_error(heap, "Allowed memory size of %ld bytes exhausted (tried to allocate %ld bytes)", heap->limit, size);
+			zend_mm_safe_error(heap, "Allowed memory size of " ZEND_INT_FMT " bytes exhausted (tried to allocate " ZEND_UINT_FMT " bytes)", heap->limit, size);
 #endif
 			return NULL;
 		}
@@ -2619,7 +2619,7 @@ ZEND_API void *_ecalloc(size_t nmemb, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LI
 
 ZEND_API char *_estrdup(const char *s ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 {
-	int length;
+	zend_size_t length;
 	char *p;
 #ifdef ZEND_SIGNALS
 	TSRMLS_FETCH();
@@ -2638,7 +2638,7 @@ ZEND_API char *_estrdup(const char *s ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 	return p;
 }
 
-ZEND_API char *_estrndup(const char *s, uint length ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
+ZEND_API char *_estrndup(const char *s, zend_size_t length ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 {
 	char *p;
 #ifdef ZEND_SIGNALS
@@ -2659,7 +2659,7 @@ ZEND_API char *_estrndup(const char *s, uint length ZEND_FILE_LINE_DC ZEND_FILE_
 }
 
 
-ZEND_API char *zend_strndup(const char *s, uint length)
+ZEND_API char *zend_strndup(const char *s, zend_size_t length)
 {
 	char *p;
 #ifdef ZEND_SIGNALS
@@ -2682,10 +2682,8 @@ ZEND_API char *zend_strndup(const char *s, uint length)
 }
 
 
-ZEND_API int zend_set_memory_limit(size_t memory_limit)
+ZEND_API int zend_set_memory_limit(size_t memory_limit TSRMLS_DC)
 {
-	TSRMLS_FETCH();
-
 	AG(mm_heap)->limit = (memory_limit >= AG(mm_heap)->block_size) ? memory_limit : AG(mm_heap)->block_size;
 
 	return SUCCESS;

Zend/zend_alloc.h

@@ -26,20 +26,21 @@
 
 #include "../TSRM/TSRM.h"
 #include "zend.h"
+#include "zend_types.h"
 
 #ifndef ZEND_MM_ALIGNMENT
-# define ZEND_MM_ALIGNMENT 8
-# define ZEND_MM_ALIGNMENT_LOG2 3
-#elif ZEND_MM_ALIGNMENT < 4
+# define ZEND_MM_ALIGNMENT Z_I(8)
+# define ZEND_MM_ALIGNMENT_LOG2 Z_I(3)
+#elif ZEND_MM_ALIGNMENT < Z_I(4)
 # undef ZEND_MM_ALIGNMENT
 # undef ZEND_MM_ALIGNMENT_LOG2
-# define ZEND_MM_ALIGNMENT 4
-# define ZEND_MM_ALIGNMENT_LOG2 2
+# define ZEND_MM_ALIGNMENT Z_I(4)
+# define ZEND_MM_ALIGNMENT_LOG2 Z_I(2)
 #endif
 
-#define ZEND_MM_ALIGNMENT_MASK ~(ZEND_MM_ALIGNMENT-1)
+#define ZEND_MM_ALIGNMENT_MASK ~(ZEND_MM_ALIGNMENT-Z_I(1))
 
-#define ZEND_MM_ALIGNED_SIZE(size)	(((size) + ZEND_MM_ALIGNMENT - 1) & ZEND_MM_ALIGNMENT_MASK)
+#define ZEND_MM_ALIGNED_SIZE(size)	(((size) + ZEND_MM_ALIGNMENT - Z_I(1)) & ZEND_MM_ALIGNMENT_MASK)
 
 typedef struct _zend_leak_info {
 	void *addr;
@@ -52,7 +53,7 @@ typedef struct _zend_leak_info {
 
 BEGIN_EXTERN_C()
 
-ZEND_API char *zend_strndup(const char *s, unsigned int length) ZEND_ATTRIBUTE_MALLOC;
+ZEND_API char *zend_strndup(const char *s, zend_size_t length) ZEND_ATTRIBUTE_MALLOC;
 
 ZEND_API void *_emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC ZEND_ATTRIBUTE_ALLOC_SIZE(1);
 ZEND_API void *_safe_emalloc(size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC;
@@ -63,7 +64,7 @@ ZEND_API void *_erealloc(void *ptr, size_t size, int allow_failure ZEND_FILE_LIN
 ZEND_API void *_safe_erealloc(void *ptr, size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
 ZEND_API void *_safe_realloc(void *ptr, size_t nmemb, size_t size, size_t offset);
 ZEND_API char *_estrdup(const char *s ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC;
-ZEND_API char *_estrndup(const char *s, unsigned int length ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC;
+ZEND_API char *_estrndup(const char *s, zend_size_t length ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC;
 ZEND_API size_t _zend_mem_block_size(void *ptr TSRMLS_DC ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
 
 /* Standard wrapper macros */
@@ -139,7 +140,7 @@ inline static void * __zend_realloc(void *p, size_t len)
 #define safe_estrdup(ptr)  ((ptr)?(estrdup(ptr)):STR_EMPTY_ALLOC())
 #define safe_estrndup(ptr, len) ((ptr)?(estrndup((ptr), (len))):STR_EMPTY_ALLOC())
 
-ZEND_API int zend_set_memory_limit(size_t memory_limit);
+ZEND_API int zend_set_memory_limit(size_t memory_limit TSRMLS_DC);
 
 ZEND_API void start_memory_manager(TSRMLS_D);
 ZEND_API void shutdown_memory_manager(int silent, int full_shutdown TSRMLS_DC);

Zend/zend_ast.c

@@ -63,6 +63,27 @@ ZEND_API zend_ast* zend_ast_create_ternary(uint kind, zend_ast *op0, zend_ast *o
 	return ast;
 }
 
+ZEND_API zend_ast* zend_ast_create_dynamic(uint kind)
+{
+	zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * 3); /* use 4 children as deafult */
+	ast->kind = kind;
+	ast->children = 0;
+	return ast;
+}
+
+ZEND_API void zend_ast_dynamic_add(zend_ast **ast, zend_ast *op)
+{
+	if ((*ast)->children >= 4 && (*ast)->children == ((*ast)->children & -(*ast)->children)) {
+		*ast = erealloc(*ast, sizeof(zend_ast) + sizeof(zend_ast*) * ((*ast)->children * 2 + 1));
+	}
+	(&(*ast)->u.child)[(*ast)->children++] = op;
+}
+
+ZEND_API void zend_ast_dynamic_shrink(zend_ast **ast)
+{
+	*ast = erealloc(*ast, sizeof(zend_ast) + sizeof(zend_ast*) * ((*ast)->children - 1));
+}
+
 ZEND_API int zend_ast_is_ct_constant(zend_ast *ast)
 {
 	int i;
@@ -107,6 +128,13 @@ ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *s
 			zval_dtor(&op1);
 			zval_dtor(&op2);
 			break;
+		case ZEND_POW:
+			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
+			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+			pow_function(result, &op1, &op2 TSRMLS_CC);
+			zval_dtor(&op1);
+			zval_dtor(&op2);
+			break;
 		case ZEND_DIV:
 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
 			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
@@ -223,17 +251,26 @@ ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *s
 			zval_dtor(&op2);
 			break;
 		case ZEND_CONST:
-			*result = *ast->u.val;
-			zval_copy_ctor(result);
-			if (IS_CONSTANT_TYPE(Z_TYPE_P(result))) {
-				zval_update_constant_ex(&result, (void *) 1, scope TSRMLS_CC);
+			/* class constants may be updated in-place */
+			if (scope) {
+				if (IS_CONSTANT_TYPE(Z_TYPE_P(ast->u.val))) {
+					zval_update_constant_ex(&ast->u.val, 1, scope TSRMLS_CC);
+				}
+				*result = *ast->u.val;
+				zval_copy_ctor(result);
+			} else {
+				*result = *ast->u.val;
+				zval_copy_ctor(result);
+				if (IS_CONSTANT_TYPE(Z_TYPE_P(result))) {
+					zval_update_constant_ex(&result, 1, scope TSRMLS_CC);
+				}
 			}
 			break;
 		case ZEND_BOOL_AND:
 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			if (zend_is_true(&op1)) {
+			if (zend_is_true(&op1 TSRMLS_CC)) {
 				zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-				ZVAL_BOOL(result, zend_is_true(&op2));
+				ZVAL_BOOL(result, zend_is_true(&op2 TSRMLS_CC));
 				zval_dtor(&op2);
 			} else {
 				ZVAL_BOOL(result, 0);
@@ -242,18 +279,18 @@ ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *s
 			break;
 		case ZEND_BOOL_OR:
 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			if (zend_is_true(&op1)) {
+			if (zend_is_true(&op1 TSRMLS_CC)) {
 				ZVAL_BOOL(result, 1);
 			} else {
 				zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-				ZVAL_BOOL(result, zend_is_true(&op2));
+				ZVAL_BOOL(result, zend_is_true(&op2 TSRMLS_CC));
 				zval_dtor(&op2);
 			}
 			zval_dtor(&op1);
 			break;
 		case ZEND_SELECT:
 			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			if (zend_is_true(&op1)) {
+			if (zend_is_true(&op1 TSRMLS_CC)) {
 				if (!(&ast->u.child)[1]) {
 					*result = op1;
 				} else {
@@ -266,17 +303,45 @@ ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *s
 			}
 			break;
 		case ZEND_UNARY_PLUS:
-			ZVAL_LONG(&op1, 0);
+			ZVAL_INT(&op1, 0);
 			zend_ast_evaluate(&op2, (&ast->u.child)[0], scope TSRMLS_CC);
 			add_function(result, &op1, &op2 TSRMLS_CC);
 			zval_dtor(&op2);
 			break;
 		case ZEND_UNARY_MINUS:
-			ZVAL_LONG(&op1, 0);
+			ZVAL_INT(&op1, 0);
 			zend_ast_evaluate(&op2, (&ast->u.child)[0], scope TSRMLS_CC);
 			sub_function(result, &op1, &op2 TSRMLS_CC);
 			zval_dtor(&op2);
 			break;
+		case ZEND_INIT_ARRAY:
+			INIT_PZVAL(result);
+			array_init(result);
+			{
+				int i;
+				zend_bool has_key;
+				for (i = 0; i < ast->children; i+=2) {
+					zval *expr;
+					MAKE_STD_ZVAL(expr);
+					if ((has_key = !!(&ast->u.child)[i])) {
+						zend_ast_evaluate(&op1, (&ast->u.child)[i], scope TSRMLS_CC);
+					}
+					zend_ast_evaluate(expr, (&ast->u.child)[i+1], scope TSRMLS_CC);
+					zend_do_add_static_array_element(result, has_key?&op1:NULL, expr);
+				}
+			}
+			break;
+		case ZEND_FETCH_DIM_R:
+			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
+			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
+			{
+				zval *tmp;
+				zend_fetch_dimension_by_zval(&tmp, &op1, &op2 TSRMLS_CC);
+				ZVAL_ZVAL(result, tmp, 1, 1);
+			}
+			zval_dtor(&op1);
+			zval_dtor(&op2);
+			break;
 		default:
 			zend_error(E_ERROR, "Unsupported constant expression");
 	}
@@ -290,26 +355,17 @@ ZEND_API zend_ast *zend_ast_copy(zend_ast *ast)
 		zend_ast *copy = zend_ast_create_constant(ast->u.val);
 		zval_copy_ctor(copy->u.val);
 		return copy;
-	} else {
-		switch (ast->children) {
-			case 1:
-				return zend_ast_create_unary(
-					ast->kind,
-					zend_ast_copy((&ast->u.child)[0]));
-			case 2:
-				return zend_ast_create_binary(
-					ast->kind,
-					zend_ast_copy((&ast->u.child)[0]),
-					zend_ast_copy((&ast->u.child)[1]));
-			case 3:
-				return zend_ast_create_ternary(
-					ast->kind,
-					zend_ast_copy((&ast->u.child)[0]),
-					zend_ast_copy((&ast->u.child)[1]),
-					zend_ast_copy((&ast->u.child)[2]));
+	} else if (ast->children) {
+		zend_ast *new = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1));
+		int i;
+		new->kind = ast->kind;
+		new->children = ast->children;
+		for (i = 0; i < ast->children; i++) {
+			(&new->u.child)[i] = zend_ast_copy((&ast->u.child)[i]);
 		}
+		return new;
 	}
-	return NULL;
+	return zend_ast_create_dynamic(ast->kind);
 }
 
 ZEND_API void zend_ast_destroy(zend_ast *ast)

Zend/zend_ast.h

@@ -50,6 +50,9 @@ ZEND_API zend_ast *zend_ast_create_constant(zval *zv);
 ZEND_API zend_ast *zend_ast_create_unary(uint kind, zend_ast *op0);
 ZEND_API zend_ast *zend_ast_create_binary(uint kind, zend_ast *op0, zend_ast *op1);
 ZEND_API zend_ast *zend_ast_create_ternary(uint kind, zend_ast *op0, zend_ast *op1, zend_ast *op2);
+ZEND_API zend_ast* zend_ast_create_dynamic(uint kind);
+ZEND_API void zend_ast_dynamic_add(zend_ast **ast, zend_ast *op);
+ZEND_API void zend_ast_dynamic_shrink(zend_ast **ast);
 
 ZEND_API int zend_ast_is_ct_constant(zend_ast *ast);
 

Zend/zend_builtin_functions.c

@@ -245,16 +245,16 @@ static const zend_function_entry builtin_functions[] = { /* {{{ */
 	ZEND_FE(func_num_args,		arginfo_zend__void)
 	ZEND_FE(func_get_arg,		arginfo_func_get_arg)
 	ZEND_FE(func_get_args,		arginfo_zend__void)
-	ZEND_FE(strlen,				arginfo_strlen)
-	ZEND_FE(strcmp,				arginfo_strcmp)
-	ZEND_FE(strncmp,			arginfo_strncmp)
-	ZEND_FE(strcasecmp,			arginfo_strcmp)
+	ZEND_FE(strlen,			arginfo_strlen)
+	ZEND_FE(strcmp,			arginfo_strcmp)
+	ZEND_FE(strncmp,		arginfo_strncmp)
+	ZEND_FE(strcasecmp,		arginfo_strcmp)
 	ZEND_FE(strncasecmp,		arginfo_strncmp)
-	ZEND_FE(each,				arginfo_each)
+	ZEND_FE(each,			arginfo_each)
 	ZEND_FE(error_reporting,	arginfo_error_reporting)
-	ZEND_FE(define,				arginfo_define)
-	ZEND_FE(defined,			arginfo_defined)
-	ZEND_FE(get_class,			arginfo_get_class)
+	ZEND_FE(define,			arginfo_define)
+	ZEND_FE(defined,		arginfo_defined)
+	ZEND_FE(get_class,		arginfo_get_class)
 	ZEND_FE(get_called_class,	arginfo_zend__void)
 	ZEND_FE(get_parent_class,	arginfo_get_class)
 	ZEND_FE(method_exists,		arginfo_method_exists)
@@ -274,13 +274,13 @@ static const zend_function_entry builtin_functions[] = { /* {{{ */
 	ZEND_FE(get_included_files,	arginfo_zend__void)
 	ZEND_FALIAS(get_required_files,	get_included_files,		arginfo_zend__void)
 	ZEND_FE(is_subclass_of,		arginfo_is_subclass_of)
-	ZEND_FE(is_a,				arginfo_is_subclass_of)
+	ZEND_FE(is_a,			arginfo_is_subclass_of)
 	ZEND_FE(get_class_vars,		arginfo_get_class_vars)
 	ZEND_FE(get_object_vars,	arginfo_get_object_vars)
 	ZEND_FE(get_class_methods,	arginfo_get_class_methods)
 	ZEND_FE(trigger_error,		arginfo_trigger_error)
 	ZEND_FALIAS(user_error,		trigger_error,		arginfo_trigger_error)
-	ZEND_FE(set_error_handler,			arginfo_set_error_handler)
+	ZEND_FE(set_error_handler,		arginfo_set_error_handler)
 	ZEND_FE(restore_error_handler,		arginfo_zend__void)
 	ZEND_FE(set_exception_handler,		arginfo_set_exception_handler)
 	ZEND_FE(restore_exception_handler,	arginfo_zend__void)
@@ -288,14 +288,14 @@ static const zend_function_entry builtin_functions[] = { /* {{{ */
 	ZEND_FE(get_declared_traits, 		arginfo_zend__void)
 	ZEND_FE(get_declared_interfaces, 	arginfo_zend__void)
 	ZEND_FE(get_defined_functions, 		arginfo_zend__void)
-	ZEND_FE(get_defined_vars,			arginfo_zend__void)
-	ZEND_FE(create_function,			arginfo_create_function)
-	ZEND_FE(get_resource_type,			arginfo_get_resource_type)
+	ZEND_FE(get_defined_vars,		arginfo_zend__void)
+	ZEND_FE(create_function,		arginfo_create_function)
+	ZEND_FE(get_resource_type,		arginfo_get_resource_type)
 	ZEND_FE(get_loaded_extensions,		arginfo_get_loaded_extensions)
-	ZEND_FE(extension_loaded,			arginfo_extension_loaded)
+	ZEND_FE(extension_loaded,		arginfo_extension_loaded)
 	ZEND_FE(get_extension_funcs,		arginfo_extension_loaded)
 	ZEND_FE(get_defined_constants,		arginfo_get_defined_constants)
-	ZEND_FE(debug_backtrace, 			arginfo_debug_backtrace)
+	ZEND_FE(debug_backtrace, 		arginfo_debug_backtrace)
 	ZEND_FE(debug_print_backtrace, 		arginfo_debug_print_backtrace)
 #if ZEND_DEBUG
 	ZEND_FE(zend_test_func,		NULL)
@@ -305,7 +305,7 @@ static const zend_function_entry builtin_functions[] = { /* {{{ */
 #endif
 	ZEND_FE(gc_collect_cycles, 	arginfo_zend__void)
 	ZEND_FE(gc_enabled, 		arginfo_zend__void)
-	ZEND_FE(gc_enable, 			arginfo_zend__void)
+	ZEND_FE(gc_enable, 		arginfo_zend__void)
 	ZEND_FE(gc_disable, 		arginfo_zend__void)
 	ZEND_FE_END
 };
@@ -358,7 +358,7 @@ ZEND_FUNCTION(zend_version)
    Returns number of freed zvals */
 ZEND_FUNCTION(gc_collect_cycles)
 {
-	RETURN_LONG(gc_collect_cycles(TSRMLS_C));
+	RETURN_INT(gc_collect_cycles(TSRMLS_C));
 }
 /* }}} */
 
@@ -393,10 +393,10 @@ ZEND_FUNCTION(func_num_args)
 	zend_execute_data *ex = EG(current_execute_data)->prev_execute_data;
 
 	if (ex && ex->function_state.arguments) {
-		RETURN_LONG((long)(zend_uintptr_t)*(ex->function_state.arguments));
+		RETURN_INT((long)(zend_uintptr_t)*(ex->function_state.arguments));
 	} else {
 		zend_error(E_WARNING, "func_num_args():  Called from the global scope - no function context");
-		RETURN_LONG(-1);
+		RETURN_INT(-1);
 	}
 }
 /* }}} */
@@ -409,10 +409,10 @@ ZEND_FUNCTION(func_get_arg)
 	void **p;
 	int arg_count;
 	zval *arg;
-	long requested_offset;
+	zend_int_t requested_offset;
 	zend_execute_data *ex = EG(current_execute_data)->prev_execute_data;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &requested_offset) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &requested_offset) == FAILURE) {
 		return;
 	}
 
@@ -430,7 +430,7 @@ ZEND_FUNCTION(func_get_arg)
 	arg_count = (int)(zend_uintptr_t) *p;		/* this is the amount of arguments passed to func_get_arg(); */
 
 	if (requested_offset >= arg_count) {
-		zend_error(E_WARNING, "func_get_arg():  Argument %ld not passed to function", requested_offset);
+		zend_error(E_WARNING, "func_get_arg():  Argument " ZEND_INT_FMT " not passed to function", requested_offset);
 		RETURN_FALSE;
 	}
 
@@ -481,13 +481,13 @@ ZEND_FUNCTION(func_get_args)
 ZEND_FUNCTION(strlen)
 {
 	char *s1;
-	int s1_len;
+	zend_size_t s1_len;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &s1, &s1_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &s1, &s1_len) == FAILURE) {
 		return;
 	}
 
-	RETVAL_LONG(s1_len);
+	RETVAL_INT((zend_int_t) s1_len);
 }
 /* }}} */
 
@@ -497,13 +497,13 @@ ZEND_FUNCTION(strlen)
 ZEND_FUNCTION(strcmp)
 {
 	char *s1, *s2;
-	int s1_len, s2_len;
+	zend_size_t s1_len, s2_len;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &s1, &s1_len, &s2, &s2_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS", &s1, &s1_len, &s2, &s2_len) == FAILURE) {
 		return;
 	}
 
-	RETURN_LONG(zend_binary_strcmp(s1, s1_len, s2, s2_len));
+	RETURN_INT(zend_binary_strcmp(s1, s1_len, s2, s2_len));
 }
 /* }}} */
 
@@ -513,10 +513,10 @@ ZEND_FUNCTION(strcmp)
 ZEND_FUNCTION(strncmp)
 {
 	char *s1, *s2;
-	int s1_len, s2_len;
-	long len;
+	zend_size_t s1_len, s2_len;
+	zend_int_t len;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssl", &s1, &s1_len, &s2, &s2_len, &len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SSi", &s1, &s1_len, &s2, &s2_len, &len) == FAILURE) {
 		return;
 	}
 
@@ -525,7 +525,7 @@ ZEND_FUNCTION(strncmp)
 		RETURN_FALSE;
 	}
 
-	RETURN_LONG(zend_binary_strncmp(s1, s1_len, s2, s2_len, len));
+	RETURN_INT(zend_binary_strncmp(s1, s1_len, s2, s2_len, len));
 }
 /* }}} */
 
@@ -535,13 +535,13 @@ ZEND_FUNCTION(strncmp)
 ZEND_FUNCTION(strcasecmp)
 {
 	char *s1, *s2;
-	int s1_len, s2_len;
+	zend_size_t s1_len, s2_len;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &s1, &s1_len, &s2, &s2_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS", &s1, &s1_len, &s2, &s2_len) == FAILURE) {
 		return;
 	}
 
-	RETURN_LONG(zend_binary_strcasecmp(s1, s1_len, s2, s2_len));
+	RETURN_INT(zend_binary_strcasecmp(s1, s1_len, s2, s2_len));
 }
 /* }}} */
 
@@ -551,10 +551,10 @@ ZEND_FUNCTION(strcasecmp)
 ZEND_FUNCTION(strncasecmp)
 {
 	char *s1, *s2;
-	int s1_len, s2_len;
-	long len;
+	zend_size_t s1_len, s2_len;
+	zend_int_t len;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssl", &s1, &s1_len, &s2, &s2_len, &len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SSi", &s1, &s1_len, &s2, &s2_len, &len) == FAILURE) {
 		return;
 	}
 
@@ -563,7 +563,7 @@ ZEND_FUNCTION(strncasecmp)
 		RETURN_FALSE;
 	}
 
-	RETURN_LONG(zend_binary_strncasecmp(s1, s1_len, s2, s2_len, len));
+	RETURN_INT(zend_binary_strncasecmp(s1, s1_len, s2, s2_len, len));
 }
 /* }}} */
 
@@ -574,8 +574,8 @@ ZEND_FUNCTION(each)
 {
 	zval *array, *entry, **entry_ptr, *tmp;
 	char *string_key;
-	uint string_key_len;
-	ulong num_key;
+	zend_size_t string_key_len;
+	zend_uint_t num_key;
 	zval **inserted_pointer;
 	HashTable *target_hash;
 
@@ -613,8 +613,8 @@ ZEND_FUNCTION(each)
 		case HASH_KEY_IS_STRING:
 			add_get_index_stringl(return_value, 0, string_key, string_key_len-1, (void **) &inserted_pointer, !IS_INTERNED(string_key));
 			break;
-		case HASH_KEY_IS_LONG:
-			add_get_index_long(return_value, 0, num_key, (void **) &inserted_pointer);
+		case HASH_KEY_IS_INT:
+			add_get_index_int(return_value, 0, num_key, (void **) &inserted_pointer);
 			break;
 	}
 	zend_hash_update(return_value->value.ht, "key", sizeof("key"), inserted_pointer, sizeof(zval *), NULL);
@@ -629,10 +629,10 @@ ZEND_FUNCTION(each)
 ZEND_FUNCTION(error_reporting)
 {
 	char *err;
-	int err_len;
+	zend_size_t err_len;
 	int old_error_reporting;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &err, &err_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|S", &err, &err_len) == FAILURE) {
 		return;
 	}
 
@@ -641,7 +641,7 @@ ZEND_FUNCTION(error_reporting)
 		zend_alter_ini_entry("error_reporting", sizeof("error_reporting"), err, err_len, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
 	}
 
-	RETVAL_LONG(old_error_reporting);
+	RETVAL_INT(old_error_reporting);
 }
 /* }}} */
 
@@ -651,14 +651,14 @@ ZEND_FUNCTION(error_reporting)
 ZEND_FUNCTION(define)
 {
 	char *name;
-	int name_len;
+	zend_size_t name_len;
 	zval *val;
 	zval *val_free = NULL;
 	zend_bool non_cs = 0;
 	int case_sensitive = CONST_CS;
 	zend_constant c;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|b", &name, &name_len, &val, &non_cs) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|b", &name, &name_len, &val, &non_cs) == FAILURE) {
 		return;
 	}
 
@@ -674,7 +674,7 @@ ZEND_FUNCTION(define)
 
 repeat:
 	switch (Z_TYPE_P(val)) {
-		case IS_LONG:
+		case IS_INT:
 		case IS_DOUBLE:
 		case IS_STRING:
 		case IS_BOOL:
@@ -729,10 +729,10 @@ repeat:
 ZEND_FUNCTION(defined)
 {
 	char *name;
-	int name_len;
+	zend_size_t name_len;
 	zval c;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &name, &name_len) == FAILURE) {
 		return;
 	}
 	
@@ -752,7 +752,7 @@ ZEND_FUNCTION(get_class)
 {
 	zval *obj = NULL;
 	const char *name = "";
-	zend_uint name_len = 0;
+	zend_size_t name_len = 0;
 	int dup;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|o!", &obj) == FAILURE) {
@@ -800,7 +800,7 @@ ZEND_FUNCTION(get_parent_class)
 	zval *arg;
 	zend_class_entry *ce = NULL;
 	const char *name;
-	zend_uint name_length;
+	zend_size_t name_length;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &arg) == FAILURE) {
 		return;
@@ -825,7 +825,7 @@ ZEND_FUNCTION(get_parent_class)
 	} else if (Z_TYPE_P(arg) == IS_STRING) {
 		zend_class_entry **pce;
 		
-		if (zend_lookup_class(Z_STRVAL_P(arg), Z_STRLEN_P(arg), &pce TSRMLS_CC) == SUCCESS) {
+		if (zend_lookup_class(Z_STRVAL_P(arg), Z_STRSIZE_P(arg), &pce TSRMLS_CC) == SUCCESS) {
 			ce = *pce;
 		}
 	}
@@ -843,13 +843,13 @@ static void is_a_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool only_subclass)
 {
 	zval *obj;
 	char *class_name;
-	int class_name_len;
+	zend_size_t class_name_len;
 	zend_class_entry *instance_ce;
 	zend_class_entry **ce;
 	zend_bool allow_string = only_subclass;
 	zend_bool retval;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs|b", &obj, &class_name, &class_name_len, &allow_string) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zS|b", &obj, &class_name, &class_name_len, &allow_string) == FAILURE) {
 		return;
 	}
 	/*
@@ -861,7 +861,7 @@ static void is_a_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool only_subclass)
 
 	if (allow_string && Z_TYPE_P(obj) == IS_STRING) {
 		zend_class_entry **the_ce;
-		if (zend_lookup_class(Z_STRVAL_P(obj), Z_STRLEN_P(obj), &the_ce TSRMLS_CC) == FAILURE) {
+		if (zend_lookup_class(Z_STRVAL_P(obj), Z_STRSIZE_P(obj), &the_ce TSRMLS_CC) == FAILURE) {
 			RETURN_FALSE;
 		}
 		instance_ce = *the_ce;
@@ -910,8 +910,8 @@ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value
 	zend_property_info *prop_info;
 	zval *prop, *prop_copy;
 	char *key;
-	uint key_len;
-	ulong num_index;
+	zend_size_t key_len;
+	zend_uint_t num_index;
 
 	zend_hash_internal_pointer_reset_ex(&ce->properties_info, &pos);
 	while (zend_hash_get_current_data_ex(&ce->properties_info, (void **) &prop_info, &pos) == SUCCESS) {
@@ -961,10 +961,10 @@ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value
 ZEND_FUNCTION(get_class_vars)
 {
 	char *class_name;
-	int class_name_len;
+	zend_size_t class_name_len;
 	zend_class_entry **pce;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &class_name, &class_name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &class_name, &class_name_len) == FAILURE) {
 		return;
 	}
 
@@ -990,8 +990,8 @@ ZEND_FUNCTION(get_object_vars)
 	HashPosition pos;
 	char *key;
 	const char *prop_name, *class_name;
-	uint key_len, prop_len;
-	ulong num_index;
+	zend_size_t key_len, prop_len;
+	zend_uint_t num_index;
 	zend_object *zobj;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &obj) == FAILURE) {
@@ -1017,7 +1017,7 @@ ZEND_FUNCTION(get_object_vars)
 	while (zend_hash_get_current_data_ex(properties, (void **) &value, &pos) == SUCCESS) {
 		if (zend_hash_get_current_key_ex(properties, &key, &key_len, &num_index, 0, &pos) == HASH_KEY_IS_STRING) {
 			if (zend_check_property_access(zobj, key, key_len-1 TSRMLS_CC) == SUCCESS) {
-				zend_unmangle_property_name_ex(key, key_len - 1, &class_name, &prop_name, (int*) &prop_len);
+				zend_unmangle_property_name_ex(key, key_len - 1, &class_name, &prop_name, &prop_len);
 				/* Not separating references */
 				Z_ADDREF_PP(value);
 				if (IS_INTERNED(key) && prop_name != key) {
@@ -1035,7 +1035,7 @@ ZEND_FUNCTION(get_object_vars)
 }
 /* }}} */
 
-static int same_name(const char *key, const char *name, zend_uint name_len)
+static int same_name(const char *key, const char *name, zend_size_t name_len)
 {
 	char *lcname = zend_str_tolower_dup(name, name_len);
 	int ret = memcmp(lcname, key, name_len) == 0;
@@ -1064,7 +1064,7 @@ ZEND_FUNCTION(get_class_methods)
 		}
 		ce = Z_OBJCE_P(klass);
 	} else if (Z_TYPE_P(klass) == IS_STRING) {
-		if (zend_lookup_class(Z_STRVAL_P(klass), Z_STRLEN_P(klass), &pce TSRMLS_CC) == SUCCESS) {
+		if (zend_lookup_class(Z_STRVAL_P(klass), Z_STRSIZE_P(klass), &pce TSRMLS_CC) == SUCCESS) {
 			ce = *pce;
 		}
 	}
@@ -1084,9 +1084,9 @@ ZEND_FUNCTION(get_class_methods)
 		   || ((mptr->common.fn_flags & ZEND_ACC_PRIVATE) &&
 		       EG(scope) == mptr->common.scope)))) {
 			char *key;
-			uint key_len;
-			ulong num_index;
-			uint len = strlen(mptr->common.function_name);
+			zend_size_t key_len;
+			zend_uint_t num_index;
+			zend_size_t len = strlen(mptr->common.function_name);
 
 			/* Do not display old-style inherited constructors */
 			if (zend_hash_get_current_key_ex(&ce->function_table, &key, &key_len, &num_index, 0, &pos) != HASH_KEY_IS_STRING) {
@@ -1123,17 +1123,17 @@ ZEND_FUNCTION(method_exists)
 {
 	zval *klass; 
 	char *method_name;
-	int method_len;
+	zend_size_t method_len;
 	char *lcname;
 	zend_class_entry * ce, **pce;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &klass, &method_name, &method_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zS", &klass, &method_name, &method_len) == FAILURE) {
 		return;
 	}
 	if (Z_TYPE_P(klass) == IS_OBJECT) {
 		ce = Z_OBJCE_P(klass);
 	} else if (Z_TYPE_P(klass) == IS_STRING) {
-		if (zend_lookup_class(Z_STRVAL_P(klass), Z_STRLEN_P(klass), &pce TSRMLS_CC) == FAILURE) {
+		if (zend_lookup_class(Z_STRVAL_P(klass), Z_STRSIZE_P(klass), &pce TSRMLS_CC) == FAILURE) {
 			RETURN_FALSE;
 		}
 		ce = *pce;
@@ -1180,13 +1180,13 @@ ZEND_FUNCTION(property_exists)
 {
 	zval *object;
 	char *property;
-	int property_len;
+	zend_size_t property_len;
 	zend_class_entry *ce, **pce;
 	zend_property_info *property_info;
 	zval property_z;
-	ulong h;
+	zend_uint_t h;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &object, &property, &property_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zS", &object, &property, &property_len) == FAILURE) {
 		return;
 	}
 
@@ -1195,7 +1195,7 @@ ZEND_FUNCTION(property_exists)
 	}
 
 	if (Z_TYPE_P(object) == IS_STRING) {
-		if (zend_lookup_class(Z_STRVAL_P(object), Z_STRLEN_P(object), &pce TSRMLS_CC) == FAILURE) {
+		if (zend_lookup_class(Z_STRVAL_P(object), Z_STRSIZE_P(object), &pce TSRMLS_CC) == FAILURE) {
 			RETURN_FALSE;
 		}
 		ce = *pce;
@@ -1230,18 +1230,18 @@ ZEND_FUNCTION(class_exists)
 {
 	char *class_name, *lc_name;
 	zend_class_entry **ce;
-	int class_name_len;
+	zend_size_t class_name_len;
 	int found;
 	zend_bool autoload = 1;
 	ALLOCA_FLAG(use_heap)
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &class_name, &class_name_len, &autoload) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|b", &class_name, &class_name_len, &autoload) == FAILURE) {
 		return;
 	}
 
 	if (!autoload) {
 		char *name;
-		int len;
+		zend_size_t len;
 
 		lc_name = do_alloca(class_name_len + 1, use_heap);
 		zend_str_tolower_copy(lc_name, class_name, class_name_len);
@@ -1273,18 +1273,18 @@ ZEND_FUNCTION(interface_exists)
 {
 	char *iface_name, *lc_name;
 	zend_class_entry **ce;
-	int iface_name_len;
+	zend_size_t iface_name_len;
 	int found;
 	zend_bool autoload = 1;
 	ALLOCA_FLAG(use_heap)
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &iface_name, &iface_name_len, &autoload) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|b", &iface_name, &iface_name_len, &autoload) == FAILURE) {
 		return;
 	}
 
 	if (!autoload) {
 		char *name;
-		int len;
+		zend_size_t len;
 		
 		lc_name = do_alloca(iface_name_len + 1, use_heap);
 		zend_str_tolower_copy(lc_name, iface_name, iface_name_len);
@@ -1316,18 +1316,18 @@ ZEND_FUNCTION(trait_exists)
 {
 	char *trait_name, *lc_name;
 	zend_class_entry **ce;
-	int trait_name_len;
+	zend_size_t trait_name_len;
 	int found;
 	zend_bool autoload = 1;
 	ALLOCA_FLAG(use_heap)
   
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &trait_name, &trait_name_len, &autoload) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|b", &trait_name, &trait_name_len, &autoload) == FAILURE) {
 		return;
 	}
   
 	if (!autoload) {
 		char *name;
-		int len;
+		zend_size_t len;
 		
 		lc_name = do_alloca(trait_name_len + 1, use_heap);
 		zend_str_tolower_copy(lc_name, trait_name, trait_name_len);
@@ -1359,12 +1359,12 @@ ZEND_FUNCTION(trait_exists)
 ZEND_FUNCTION(function_exists)
 {
 	char *name;
-	int name_len;
+	zend_size_t name_len;
 	zend_function *func;
 	char *lcname;
 	zend_bool retval;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &name, &name_len) == FAILURE) {
 		return;
 	}
 
@@ -1400,11 +1400,11 @@ ZEND_FUNCTION(class_alias)
 {
 	char *class_name, *alias_name;
 	zend_class_entry **ce;
-	int class_name_len, alias_name_len;
+	zend_size_t class_name_len, alias_name_len;
 	int found;
 	zend_bool autoload = 1;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|b", &class_name, &class_name_len, &alias_name, &alias_name_len, &autoload) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|b", &class_name, &class_name_len, &alias_name, &alias_name_len, &autoload) == FAILURE) {
 		return;
 	}
 
@@ -1434,9 +1434,9 @@ ZEND_FUNCTION(class_alias)
    Cause an intentional memory leak, for testing/debugging purposes */
 ZEND_FUNCTION(leak)
 {
-	long leakbytes=3;
+	zend_int_t leakbytes=3;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &leakbytes) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &leakbytes) == FAILURE) {
 		return;
 	}
 
@@ -1483,7 +1483,7 @@ ZEND_FUNCTION(crash)
 ZEND_FUNCTION(get_included_files)
 {
 	char *entry;
-	uint entry_len;
+	zend_size_t entry_len;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1503,11 +1503,11 @@ ZEND_FUNCTION(get_included_files)
    Generates a user-level error/warning/notice message */
 ZEND_FUNCTION(trigger_error)
 {
-	long error_type = E_USER_NOTICE;
+	zend_int_t error_type = E_USER_NOTICE;
 	char *message;
-	int message_len;
+	zend_size_t message_len;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &message, &message_len, &error_type) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|i", &message, &message_len, &error_type) == FAILURE) {
 		return;
 	}
 
@@ -1535,9 +1535,9 @@ ZEND_FUNCTION(set_error_handler)
 {
 	zval *error_handler;
 	char *error_handler_name = NULL;
-	long error_type = E_ALL;
+	zend_int_t error_type = E_ALL;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &error_handler, &error_type) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|i", &error_handler, &error_type) == FAILURE) {
 		return;
 	}
 
@@ -1797,11 +1797,11 @@ ZEND_FUNCTION(get_defined_vars)
 ZEND_FUNCTION(create_function)
 {
 	char *eval_code, *function_name, *function_args, *function_code;
-	int eval_code_length, function_name_length, function_args_len, function_code_len;
+	zend_size_t eval_code_length, function_name_length, function_args_len, function_code_len;
 	int retval;
 	char *eval_name;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &function_args, &function_args_len, &function_code, &function_code_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS", &function_args, &function_args_len, &function_code, &function_code_len) == FAILURE) {
 		return;
 	}
 
@@ -1841,11 +1841,11 @@ ZEND_FUNCTION(create_function)
 		new_function = *func;
 		function_add_ref(&new_function);
 
-		function_name = (char *) emalloc(sizeof("0lambda_")+MAX_LENGTH_OF_LONG);
+		function_name = (char *) emalloc(sizeof("0lambda_")+MAX_LENGTH_OF_ZEND_INT);
 		function_name[0] = '\0';
 
 		do {
-			function_name_length = 1 + snprintf(function_name + 1, sizeof("lambda_")+MAX_LENGTH_OF_LONG, "lambda_%d", ++EG(lambda_count));
+			function_name_length = 1 + snprintf(function_name + 1, sizeof("lambda_")+MAX_LENGTH_OF_ZEND_INT, "lambda_%d", ++EG(lambda_count));
 		} while (zend_hash_add(EG(function_table), function_name, function_name_length+1, &new_function, sizeof(zend_function), NULL)==FAILURE);
 		zend_hash_del(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME));
 		RETURN_STRINGL(function_name, function_name_length, 0);
@@ -1869,7 +1869,7 @@ ZEND_FUNCTION(zend_test_func)
 #ifdef ZTS
 ZEND_FUNCTION(zend_thread_id)
 {
-	RETURN_LONG((long)tsrm_thread_id());
+	RETURN_INT((long)tsrm_thread_id());
 }
 #endif
 #endif
@@ -1885,7 +1885,7 @@ ZEND_FUNCTION(get_resource_type)
 		return;
 	}
 
-	resource_type = zend_rsrc_list_get_rsrc_type(Z_LVAL_P(z_resource_type) TSRMLS_CC);
+	resource_type = zend_rsrc_list_get_rsrc_type(Z_IVAL_P(z_resource_type) TSRMLS_CC);
 	if (resource_type) {
 		RETURN_STRING(resource_type, 1);
 	} else {
@@ -2070,7 +2070,7 @@ void debug_print_backtrace_args(zval *arg_array TSRMLS_DC)
 ZEND_FUNCTION(debug_print_backtrace)
 {
 	zend_execute_data *ptr, *skip;
-	int lineno, frameno = 0;
+	zend_size_t lineno, frameno = 0;
 	const char *function_name;
 	const char *filename;
 	const char *class_name = NULL;
@@ -2078,10 +2078,10 @@ ZEND_FUNCTION(debug_print_backtrace)
 	const char *include_filename = NULL;
 	zval *arg_array = NULL;
 	int indent = 0;
-	long options = 0;
-	long limit = 0;
+	zend_int_t options = 0;
+	zend_int_t limit = 0;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &options, &limit) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ii", &options, &limit) == FAILURE) {
 		return;
 	}
 
@@ -2130,7 +2130,7 @@ ZEND_FUNCTION(debug_print_backtrace)
 				if (ptr->function_state.function->common.scope) {
 					class_name = ptr->function_state.function->common.scope->name;
 				} else {
-					zend_uint class_name_len;
+					zend_size_t class_name_len;
 					int dup;
 
 					dup = zend_get_object_classname(ptr->object, &class_name, &class_name_len TSRMLS_CC);
@@ -2238,7 +2238,7 @@ ZEND_FUNCTION(debug_print_backtrace)
 ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int options, int limit TSRMLS_DC)
 {
 	zend_execute_data *ptr, *skip;
-	int lineno, frameno = 0;
+	zend_size_t lineno, frameno = 0;
 	const char *function_name;
 	const char *filename;
 	const char *class_name;
@@ -2279,7 +2279,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int
 			filename = skip->op_array->filename;
 			lineno = skip->opline->lineno;
 			add_assoc_string_ex(stack_frame, "file", sizeof("file"), (char*)filename, 1);
-			add_assoc_long_ex(stack_frame, "line", sizeof("line"), lineno);
+			add_assoc_int_ex(stack_frame, "line", sizeof("line"), lineno);
 
 			/* try to fetch args only if an FCALL was just made - elsewise we're in the middle of a function
 			 * and debug_baktrace() might have been called by the error_handler. in this case we don't 
@@ -2296,7 +2296,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int
 				}				    
 				if (prev->op_array) {
 					add_assoc_string_ex(stack_frame, "file", sizeof("file"), (char*)prev->op_array->filename, 1);
-					add_assoc_long_ex(stack_frame, "line", sizeof("line"), prev->opline->lineno);
+					add_assoc_int_ex(stack_frame, "line", sizeof("line"), prev->opline->lineno);
 					break;
 				}
 				prev = prev->prev_execute_data;
@@ -2320,7 +2320,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int
 				if (ptr->function_state.function->common.scope) {
 					add_assoc_string_ex(stack_frame, "class", sizeof("class"), (char*)ptr->function_state.function->common.scope->name, 1);
 				} else {
-					zend_uint class_name_len;
+					zend_size_t class_name_len;
 					int dup;
 
 					dup = zend_get_object_classname(ptr->object, &class_name, &class_name_len TSRMLS_CC);
@@ -2409,10 +2409,10 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int
    Return backtrace as array */
 ZEND_FUNCTION(debug_backtrace)
 {
-	long options = DEBUG_BACKTRACE_PROVIDE_OBJECT;
-	long limit = 0;
+	zend_int_t options = DEBUG_BACKTRACE_PROVIDE_OBJECT;
+	zend_int_t limit = 0;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &options, &limit) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ii", &options, &limit) == FAILURE) {
 		return;
 	}
 
@@ -2425,10 +2425,10 @@ ZEND_FUNCTION(debug_backtrace)
 ZEND_FUNCTION(extension_loaded)
 {
 	char *extension_name;
-	int extension_name_len;
+	zend_size_t extension_name_len;
 	char *lcname;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &extension_name, &extension_name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &extension_name, &extension_name_len) == FAILURE) {
 		return;
 	}
 
@@ -2448,11 +2448,11 @@ ZEND_FUNCTION(extension_loaded)
 ZEND_FUNCTION(get_extension_funcs)
 {
 	char *extension_name, *lcname;
-	int extension_name_len, array;
+	zend_size_t extension_name_len, array;
 	zend_module_entry *module;
 	HashPosition iterator;
 	zend_function *zif;
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &extension_name, &extension_name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &extension_name, &extension_name_len) == FAILURE) {
 		return;
 	}
 	if (strncasecmp(extension_name, "zend", sizeof("zend"))) {

Zend/zend_closures.c

@@ -95,19 +95,19 @@ ZEND_METHOD(Closure, bind)
 			ce = NULL;
 		} else {
 			char *class_name;
-			int class_name_len;
+			zend_size_t class_name_len;
 			zval tmp_zval;
 			INIT_ZVAL(tmp_zval);
 
 			if (Z_TYPE_P(scope_arg) == IS_STRING) {
 				class_name = Z_STRVAL_P(scope_arg);
-				class_name_len = Z_STRLEN_P(scope_arg);
+				class_name_len = Z_STRSIZE_P(scope_arg);
 			} else {
 				tmp_zval = *scope_arg;
 				zval_copy_ctor(&tmp_zval);
 				convert_to_string(&tmp_zval);
 				class_name = Z_STRVAL(tmp_zval);
-				class_name_len = Z_STRLEN(tmp_zval);
+				class_name_len = Z_STRSIZE(tmp_zval);
 			}
 
 			if ((class_name_len == sizeof("static") - 1) &&
@@ -174,7 +174,7 @@ ZEND_API zval* zend_get_closure_this_ptr(zval *obj TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-static zend_function *zend_closure_get_method(zval **object_ptr, char *method_name, int method_len, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zend_function *zend_closure_get_method(zval **object_ptr, char *method_name, zend_size_t method_len, const zend_literal *key TSRMLS_DC) /* {{{ */
 {
 	char *lc_name;
 	ALLOCA_FLAG(use_heap)
@@ -338,14 +338,14 @@ static HashTable *zend_closure_get_debug_info(zval *object, int *is_temp TSRMLS_
 		}
 
 		if (arg_info) {
-			zend_uint i, required = closure->func.common.required_num_args;
+			zend_size_t i, required = closure->func.common.required_num_args;
 
 			MAKE_STD_ZVAL(val);
 			array_init(val);
 
 			for (i = 0; i < closure->func.common.num_args; i++) {
 				char *name, *info;
-				int name_len, info_len;
+				zend_size_t name_len, info_len;
 				if (arg_info->name) {
 					name_len = zend_spprintf(&name, 0, "%s$%s",
 									arg_info->pass_by_reference ? "&" : "",
@@ -480,6 +480,7 @@ ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_ent
 		}
 	}
 
+	closure->this_ptr = NULL;
 	/* Invariants:
 	 * If the closure is unscoped, it has no bound object.
 	 * The the closure is scoped, it's either static or it's bound */
@@ -491,10 +492,7 @@ ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_ent
 			Z_ADDREF_P(this_ptr);
 		} else {
 			closure->func.common.fn_flags |= ZEND_ACC_STATIC;
-			closure->this_ptr = NULL;
 		}
-	} else {
-		closure->this_ptr = NULL;
 	}
 }
 /* }}} */

Zend/zend_compile.h

@@ -40,7 +40,7 @@
 #define INC_BPC(op_array)	if (op_array->fn_flags & ZEND_ACC_INTERACTIVE) { (CG(context).backpatch_count++); }
 #define DEC_BPC(op_array)	if (op_array->fn_flags & ZEND_ACC_INTERACTIVE) { (CG(context).backpatch_count--); }
 #define HANDLE_INTERACTIVE()  if (CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) { execute_new_code(TSRMLS_C); }
-#define DO_TICKS()            if (Z_LVAL(CG(declarables).ticks)) { zend_do_ticks(TSRMLS_C); }
+#define DO_TICKS()            if (Z_IVAL(CG(declarables).ticks)) { zend_do_ticks(TSRMLS_C); }
 
 #define RESET_DOC_COMMENT()        \
     {                              \
@@ -68,7 +68,7 @@ typedef struct _zend_compiler_context {
 
 typedef struct _zend_literal {
 	zval       constant;
-	zend_ulong hash_value;
+	zend_uint_t hash_value;
 	zend_uint  cache_slot;
 } zend_literal;
 
@@ -78,8 +78,8 @@ typedef struct _zend_literal {
 typedef union _znode_op {
 	zend_uint      constant;
 	zend_uint      var;
-	zend_uint      num;
-	zend_ulong     hash;
+	zend_size_t     num;
+	zend_uint_t     hash;
 	zend_uint      opline_num; /*  Needs to be signed */
 	zend_op       *jmp_addr;
 	zval          *zv;
@@ -113,8 +113,8 @@ struct _zend_op {
 	znode_op op1;
 	znode_op op2;
 	znode_op result;
-	ulong extended_value;
-	uint lineno;
+	zend_uint_t extended_value;
+	zend_size_t lineno;
 	zend_uchar opcode;
 	zend_uchar op1_type;
 	zend_uchar op2_type;
@@ -141,8 +141,12 @@ typedef struct _zend_try_catch_element {
 	zend_uint finally_end;
 } zend_try_catch_element;
 
-#if SIZEOF_LONG == 8
-#define THIS_HASHVAL 210728972157UL
+#if SIZEOF_ZEND_INT == 8
+# ifdef _WIN32
+#  define THIS_HASHVAL 210728972157Ui64
+# else
+#  define THIS_HASHVAL 210728972157ULL
+# endif
 #else
 #define THIS_HASHVAL 275574653UL
 #endif
@@ -223,20 +227,20 @@ char *zend_visibility_string(zend_uint fn_flags);
 typedef struct _zend_property_info {
 	zend_uint flags;
 	const char *name;
-	int name_length;
-	ulong h;
+	zend_size_t name_length;
+	zend_uint_t h;
 	int offset;
 	const char *doc_comment;
-	int doc_comment_len;
+	zend_size_t doc_comment_len;
 	zend_class_entry *ce;
 } zend_property_info;
 
 
 typedef struct _zend_arg_info {
 	const char *name;
-	zend_uint name_len;
+	zend_size_t name_len;
 	const char *class_name;
-	zend_uint class_name_len;
+	zend_size_t class_name_len;
 	zend_uchar type_hint;
 	zend_uchar pass_by_reference;
 	zend_bool allow_null;
@@ -249,9 +253,9 @@ typedef struct _zend_arg_info {
  */
 typedef struct _zend_internal_function_info {
 	const char *_name;
-	zend_uint _name_len;
+	zend_size_t _name_len;
 	const char *_class_name;
-	zend_uint required_num_args;
+	zend_size_t required_num_args;
 	zend_uchar _type_hint;
 	zend_bool return_reference;
 	zend_bool _allow_null;
@@ -260,8 +264,8 @@ typedef struct _zend_internal_function_info {
 
 typedef struct _zend_compiled_variable {
 	const char *name;
-	int name_len;
-	ulong hash_value;
+	zend_size_t name_len;
+	zend_uint_t hash_value;
 } zend_compiled_variable;
 
 struct _zend_op_array {
@@ -271,8 +275,8 @@ struct _zend_op_array {
 	zend_class_entry *scope;
 	zend_uint fn_flags;
 	union _zend_function *prototype;
-	zend_uint num_args;
-	zend_uint required_num_args;
+	zend_size_t num_args;
+	zend_size_t required_num_args;
 	zend_arg_info *arg_info;
 	/* END of common elements */
 
@@ -302,10 +306,10 @@ struct _zend_op_array {
 	zend_uint this_var;
 
 	const char *filename;
-	zend_uint line_start;
-	zend_uint line_end;
+	zend_size_t line_start;
+	zend_size_t line_end;
 	const char *doc_comment;
-	zend_uint doc_comment_len;
+	zend_size_t doc_comment_len;
 	zend_uint early_binding; /* the linked list of delayed declarations */
 
 	zend_literal *literals;
@@ -328,8 +332,8 @@ typedef struct _zend_internal_function {
 	zend_class_entry *scope;
 	zend_uint fn_flags;
 	union _zend_function *prototype;
-	zend_uint num_args;
-	zend_uint required_num_args;
+	zend_size_t num_args;
+	zend_size_t required_num_args;
 	zend_arg_info *arg_info;
 	/* END of common elements */
 
@@ -348,8 +352,8 @@ typedef union _zend_function {
 		zend_class_entry *scope;
 		zend_uint fn_flags;
 		union _zend_function *prototype;
-		zend_uint num_args;
-		zend_uint required_num_args;
+		zend_size_t num_args;
+		zend_size_t required_num_args;
 		zend_arg_info *arg_info;
 	} common;
 
@@ -363,6 +367,11 @@ typedef struct _zend_function_state {
 	void **arguments;
 } zend_function_state;
 
+typedef struct _zend_function_call_entry {
+	zend_function *fbc;
+	zend_uint arg_num;
+	zend_bool uses_argument_unpacking;
+} zend_function_call_entry;
 
 typedef struct _zend_switch_entry {
 	znode cond;
@@ -442,14 +451,14 @@ void shutdown_scanner(TSRMLS_D);
 ZEND_API char *zend_set_compiled_filename(const char *new_compiled_filename TSRMLS_DC);
 ZEND_API void zend_restore_compiled_filename(char *original_compiled_filename TSRMLS_DC);
 ZEND_API char *zend_get_compiled_filename(TSRMLS_D);
-ZEND_API int zend_get_compiled_lineno(TSRMLS_D);
+ZEND_API zend_uint_t zend_get_compiled_lineno(TSRMLS_D);
 ZEND_API size_t zend_get_scanned_file_offset(TSRMLS_D);
 
 void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace, zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC);
 void zend_resolve_function_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC);
 void zend_resolve_const_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC);
 void zend_resolve_class_name(znode *class_name TSRMLS_DC);
-ZEND_API const char* zend_get_compiled_variable_name(const zend_op_array *op_array, zend_uint var, int* name_len);
+ZEND_API const char* zend_get_compiled_variable_name(const zend_op_array *op_array, zend_uint var, zend_size_t* name_len);
 
 #ifdef ZTS
 const char *zend_get_zendtext(TSRMLS_D);
@@ -518,7 +527,7 @@ void zend_do_begin_dynamic_function_call(znode *function_name, int prefix_len TS
 void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC);
 void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_class_member TSRMLS_DC);
 int zend_do_begin_class_member_function_call(znode *class_name, znode *method_name TSRMLS_DC);
-void zend_do_end_function_call(znode *function_name, znode *result, const znode *argument_list, int is_method, int is_dynamic_fcall TSRMLS_DC);
+void zend_do_end_function_call(znode *function_name, znode *result, int is_method, int is_dynamic_fcall TSRMLS_DC);
 void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC);
 void zend_do_yield(znode *result, znode *value, const znode *key, zend_bool is_variable TSRMLS_DC);
 void zend_do_handle_exception(TSRMLS_D);
@@ -554,8 +563,8 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent
 void zend_do_early_binding(TSRMLS_D);
 ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS_DC);
 
-void zend_do_pass_param(znode *param, zend_uchar op, int offset TSRMLS_DC);
-void zend_do_unpack_params(znode *params, int offset TSRMLS_DC);
+void zend_do_pass_param(znode *param, zend_uchar op TSRMLS_DC);
+void zend_do_unpack_params(znode *params TSRMLS_DC);
 
 
 void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC);
@@ -585,7 +594,7 @@ void zend_do_pop_object(znode *object TSRMLS_DC);
 
 
 void zend_do_begin_new_object(znode *new_token, znode *class_type TSRMLS_DC);
-void zend_do_end_new_object(znode *result, const znode *new_token, const znode *argument_list TSRMLS_DC);
+void zend_do_end_new_object(znode *result, const znode *new_token TSRMLS_DC);
 
 void zend_do_fetch_constant(znode *result, znode *constant_container, znode *constant_name, int mode, zend_bool check_namespace TSRMLS_DC);
 
@@ -593,7 +602,7 @@ void zend_do_shell_exec(znode *result, const znode *cmd TSRMLS_DC);
 
 void zend_do_init_array(znode *result, const znode *expr, const znode *offset, zend_bool is_ref TSRMLS_DC);
 void zend_do_add_array_element(znode *result, const znode *expr, const znode *offset, zend_bool is_ref TSRMLS_DC);
-void zend_do_add_static_array_element(znode *result, znode *offset, const znode *expr);
+void zend_do_add_static_array_element(zval *result, zval *offset, const zval *expr);
 void zend_do_list_init(TSRMLS_D);
 void zend_do_list_end(znode *result, znode *expr TSRMLS_DC);
 void zend_do_add_list_element(const znode *element TSRMLS_DC);
@@ -687,10 +696,10 @@ ZEND_API void zend_function_dtor(zend_function *function);
 ZEND_API void destroy_zend_class(zend_class_entry **pce);
 void zend_class_add_ref(zend_class_entry **ce);
 
-ZEND_API void zend_mangle_property_name(char **dest, int *dest_length, const char *src1, int src1_length, const char *src2, int src2_length, int internal);
+ZEND_API void zend_mangle_property_name(char **dest, zend_size_t *dest_length, const char *src1, zend_size_t src1_length, const char *src2, zend_size_t src2_length, int internal);
 #define zend_unmangle_property_name(mangled_property, mangled_property_len, class_name, prop_name) \
         zend_unmangle_property_name_ex(mangled_property, mangled_property_len, class_name, prop_name, NULL)
-ZEND_API int zend_unmangle_property_name_ex(const char *mangled_property, int mangled_property_len, const char **class_name, const char **prop_name, int *prop_len);
+ZEND_API int zend_unmangle_property_name_ex(const char *mangled_property, zend_size_t mangled_property_len, const char **class_name, const char **prop_name, zend_size_t *prop_len);
 
 #define ZEND_FUNCTION_DTOR (void (*)(void *)) zend_function_dtor
 #define ZEND_CLASS_DTOR (void (*)(void *)) destroy_zend_class
@@ -708,21 +717,21 @@ void zend_do_mark_last_catch(const znode *first_catch, const znode *last_additio
 ZEND_API zend_bool zend_is_compiling(TSRMLS_D);
 ZEND_API char *zend_make_compiled_string_description(const char *name TSRMLS_DC);
 ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC);
-int zend_get_class_fetch_type(const char *class_name, uint class_name_len);
+int zend_get_class_fetch_type(const char *class_name, zend_size_t class_name_len);
 
-typedef zend_bool (*zend_auto_global_callback)(const char *name, uint name_len TSRMLS_DC);
+typedef zend_bool (*zend_auto_global_callback)(const char *name, zend_size_t name_len TSRMLS_DC);
 typedef struct _zend_auto_global {
 	const char *name;
-	uint name_len;
+	zend_size_t name_len;
 	zend_auto_global_callback auto_global_callback;
 	zend_bool jit;
 	zend_bool armed;
 } zend_auto_global;
 
-ZEND_API int zend_register_auto_global(const char *name, uint name_len, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC);
+ZEND_API int zend_register_auto_global(const char *name, zend_size_t name_len, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC);
 ZEND_API void zend_activate_auto_globals(TSRMLS_D);
-ZEND_API zend_bool zend_is_auto_global(const char *name, uint name_len TSRMLS_DC);
-ZEND_API zend_bool zend_is_auto_global_quick(const char *name, uint name_len, ulong hashval TSRMLS_DC);
+ZEND_API zend_bool zend_is_auto_global(const char *name, zend_size_t name_len TSRMLS_DC);
+ZEND_API zend_bool zend_is_auto_global_quick(const char *name, zend_size_t name_len, zend_uint_t hashval TSRMLS_DC);
 ZEND_API size_t zend_dirname(char *path, size_t len);
 
 int zendlex(znode *zendlval TSRMLS_DC);
@@ -859,6 +868,9 @@ int zend_add_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC);
 #define ZEND_FAST_RET_TO_CATCH		1
 #define ZEND_FAST_RET_TO_FINALLY	2
 
+#define ZEND_FAST_CALL_FROM_CATCH	1
+#define ZEND_FAST_CALL_FROM_FINALLY	2
+
 END_EXTERN_C()
 
 #define ZEND_CLONE_FUNC_NAME		"__clone"
@@ -873,6 +885,7 @@ END_EXTERN_C()
 #define ZEND_TOSTRING_FUNC_NAME     "__tostring"
 #define ZEND_AUTOLOAD_FUNC_NAME     "__autoload"
 #define ZEND_INVOKE_FUNC_NAME       "__invoke"
+#define ZEND_DEBUGINFO_FUNC_NAME    "__debuginfo"
 
 /* The following constants may be combined in CG(compiler_options)
  * to change the default compiler behavior */

Zend/zend_constants.c

@@ -95,26 +95,26 @@ int zend_startup_constants(TSRMLS_D)
 
 void zend_register_standard_constants(TSRMLS_D)
 {
-	REGISTER_MAIN_LONG_CONSTANT("E_ERROR", E_ERROR, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_RECOVERABLE_ERROR", E_RECOVERABLE_ERROR, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_WARNING", E_WARNING, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_PARSE", E_PARSE, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_NOTICE", E_NOTICE, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_STRICT", E_STRICT, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_DEPRECATED", E_DEPRECATED, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_CORE_ERROR", E_CORE_ERROR, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_CORE_WARNING", E_CORE_WARNING, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_ERROR", E_COMPILE_ERROR, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_WARNING", E_COMPILE_WARNING, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_USER_ERROR", E_USER_ERROR, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_USER_WARNING", E_USER_WARNING, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_USER_NOTICE", E_USER_NOTICE, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("E_USER_DEPRECATED", E_USER_DEPRECATED, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_ERROR", E_ERROR, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_RECOVERABLE_ERROR", E_RECOVERABLE_ERROR, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_WARNING", E_WARNING, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_PARSE", E_PARSE, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_NOTICE", E_NOTICE, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_STRICT", E_STRICT, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_DEPRECATED", E_DEPRECATED, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_CORE_ERROR", E_CORE_ERROR, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_CORE_WARNING", E_CORE_WARNING, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_COMPILE_ERROR", E_COMPILE_ERROR, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_COMPILE_WARNING", E_COMPILE_WARNING, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_USER_ERROR", E_USER_ERROR, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_USER_WARNING", E_USER_WARNING, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_USER_NOTICE", E_USER_NOTICE, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_USER_DEPRECATED", E_USER_DEPRECATED, CONST_PERSISTENT | CONST_CS);
 
-	REGISTER_MAIN_LONG_CONSTANT("E_ALL", E_ALL, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("E_ALL", E_ALL, CONST_PERSISTENT | CONST_CS);
 
-	REGISTER_MAIN_LONG_CONSTANT("DEBUG_BACKTRACE_PROVIDE_OBJECT", DEBUG_BACKTRACE_PROVIDE_OBJECT, CONST_PERSISTENT | CONST_CS);
-	REGISTER_MAIN_LONG_CONSTANT("DEBUG_BACKTRACE_IGNORE_ARGS", DEBUG_BACKTRACE_IGNORE_ARGS, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("DEBUG_BACKTRACE_PROVIDE_OBJECT", DEBUG_BACKTRACE_PROVIDE_OBJECT, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_INT_CONSTANT("DEBUG_BACKTRACE_IGNORE_ARGS", DEBUG_BACKTRACE_IGNORE_ARGS, CONST_PERSISTENT | CONST_CS);
 	/* true/false constants */
 	{
 		REGISTER_MAIN_BOOL_CONSTANT("TRUE", 1, CONST_PERSISTENT | CONST_CT_SUBST);
@@ -143,7 +143,7 @@ void clean_non_persistent_constants(TSRMLS_D)
 	}
 }
 
-ZEND_API void zend_register_null_constant(const char *name, uint name_len, int flags, int module_number TSRMLS_DC)
+ZEND_API void zend_register_null_constant(const char *name, zend_size_t name_len, int flags, int module_number TSRMLS_DC)
 {
 	zend_constant c;
 	
@@ -155,7 +155,7 @@ ZEND_API void zend_register_null_constant(const char *name, uint name_len, int f
 	zend_register_constant(&c TSRMLS_CC);
 }
 
-ZEND_API void zend_register_bool_constant(const char *name, uint name_len, zend_bool bval, int flags, int module_number TSRMLS_DC)
+ZEND_API void zend_register_bool_constant(const char *name, zend_size_t name_len, zend_bool bval, int flags, int module_number TSRMLS_DC)
 {
 	zend_constant c;
 	
@@ -167,11 +167,11 @@ ZEND_API void zend_register_bool_constant(const char *name, uint name_len, zend_
 	zend_register_constant(&c TSRMLS_CC);
 }
 
-ZEND_API void zend_register_long_constant(const char *name, uint name_len, long lval, int flags, int module_number TSRMLS_DC)
+ZEND_API void zend_register_int_constant(const char *name, zend_size_t name_len, zend_int_t lval, int flags, int module_number TSRMLS_DC)
 {
 	zend_constant c;
 	
-	ZVAL_LONG(&c.value, lval);
+	ZVAL_INT(&c.value, lval);
 	c.flags = flags;
 	c.name = zend_strndup(name, name_len-1);
 	c.name_len = name_len;
@@ -180,7 +180,7 @@ ZEND_API void zend_register_long_constant(const char *name, uint name_len, long
 }
 
 
-ZEND_API void zend_register_double_constant(const char *name, uint name_len, double dval, int flags, int module_number TSRMLS_DC)
+ZEND_API void zend_register_double_constant(const char *name, zend_size_t name_len, double dval, int flags, int module_number TSRMLS_DC)
 {
 	zend_constant c;
 	
@@ -193,7 +193,7 @@ ZEND_API void zend_register_double_constant(const char *name, uint name_len, dou
 }
 
 
-ZEND_API void zend_register_stringl_constant(const char *name, uint name_len, char *strval, uint strlen, int flags, int module_number TSRMLS_DC)
+ZEND_API void zend_register_stringl_constant(const char *name, zend_size_t name_len, char *strval, zend_size_t strlen, int flags, int module_number TSRMLS_DC)
 {
 	zend_constant c;
 	
@@ -206,12 +206,12 @@ ZEND_API void zend_register_stringl_constant(const char *name, uint name_len, ch
 }
 
 
-ZEND_API void zend_register_string_constant(const char *name, uint name_len, char *strval, int flags, int module_number TSRMLS_DC)
+ZEND_API void zend_register_string_constant(const char *name, zend_size_t name_len, char *strval, int flags, int module_number TSRMLS_DC)
 {
 	zend_register_stringl_constant(name, name_len, strval, strlen(strval), flags, module_number TSRMLS_CC);
 }
 
-static int zend_get_special_constant(const char *name, uint name_len, zend_constant **c TSRMLS_DC)
+static int zend_get_special_constant(const char *name, zend_size_t name_len, zend_constant **c TSRMLS_DC)
 {
 	int ret;
 	static char haltoff[] = "__COMPILER_HALT_OFFSET__";
@@ -224,7 +224,7 @@ static int zend_get_special_constant(const char *name, uint name_len, zend_const
 
 		/* Returned constants may be cached, so they have to be stored */
 		if (EG(scope) && EG(scope)->name) {
-			int const_name_len;
+			zend_size_t const_name_len;
 			char *const_name;
 			ALLOCA_FLAG(use_heap)
 			
@@ -236,7 +236,7 @@ static int zend_get_special_constant(const char *name, uint name_len, zend_const
 				zend_hash_add(EG(zend_constants), const_name, const_name_len, (void*)&tmp, sizeof(zend_constant), (void**)c);
 				memset(*c, 0, sizeof(zend_constant));
 				Z_STRVAL((**c).value) = estrndup(EG(scope)->name, EG(scope)->name_length);
-				Z_STRLEN((**c).value) = EG(scope)->name_length;
+				Z_STRSIZE((**c).value) = EG(scope)->name_length;
 				Z_TYPE((**c).value) = IS_STRING;
 			}
 			free_alloca(const_name, use_heap);
@@ -245,7 +245,7 @@ static int zend_get_special_constant(const char *name, uint name_len, zend_const
 				zend_hash_add(EG(zend_constants), "\0__CLASS__", sizeof("\0__CLASS__"), (void*)&tmp, sizeof(zend_constant), (void**)c);
 				memset(*c, 0, sizeof(zend_constant));
 				Z_STRVAL((**c).value) = estrndup("", 0);
-				Z_STRLEN((**c).value) = 0;
+				Z_STRSIZE((**c).value) = 0;
 				Z_TYPE((**c).value) = IS_STRING;
 			}
 		}
@@ -254,7 +254,7 @@ static int zend_get_special_constant(const char *name, uint name_len, zend_const
 	          !memcmp(name, "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__")-1)) {
 		const char *cfilename;
 		char *haltname;
-		int len, clen;
+		zend_size_t len, clen;
 
 		cfilename = zend_get_executed_filename(TSRMLS_C);
 		clen = strlen(cfilename);
@@ -270,7 +270,7 @@ static int zend_get_special_constant(const char *name, uint name_len, zend_const
 }
 
 
-ZEND_API int zend_get_constant(const char *name, uint name_len, zval *result TSRMLS_DC)
+ZEND_API int zend_get_constant(const char *name, zend_size_t name_len, zval *result TSRMLS_DC)
 {
 	zend_constant *c;
 	int retval = 1;
@@ -299,7 +299,7 @@ ZEND_API int zend_get_constant(const char *name, uint name_len, zval *result TSR
 	return retval;
 }
 
-ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result, zend_class_entry *scope, ulong flags TSRMLS_DC)
+ZEND_API int zend_get_constant_ex(const char *name, zend_size_t name_len, zval *result, zend_class_entry *scope, zend_uint_t flags TSRMLS_DC)
 {
 	zend_constant *c;
 	int retval = 1;
@@ -317,8 +317,8 @@ ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result,
 
 	if ((colon = zend_memrchr(name, ':', name_len)) &&
 	    colon > name && (*(colon - 1) == ':')) {
-		int class_name_len = colon - name - 1;
-		int const_name_len = name_len - class_name_len - 2;
+		zend_size_t class_name_len = colon - name - 1;
+		zend_size_t const_name_len = name_len - class_name_len - 2;
 		const char *constant_name = colon + 1;
 		char *lcname;
 
@@ -380,8 +380,8 @@ ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result,
 	/* non-class constant */
 	if ((colon = zend_memrchr(name, '\\', name_len)) != NULL) {
 		/* compound constant name */
-		int prefix_len = colon - name;
-		int const_name_len = name_len - prefix_len - 1;
+		zend_size_t prefix_len = colon - name;
+		zend_size_t const_name_len = name_len - prefix_len - 1;
 		const char *constant_name = colon + 1;
 		char *lcname;
 		int found_const = 0;
@@ -408,7 +408,7 @@ ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result,
 		efree(lcname);
 		if(found_const) {
 			*result = c->value;
-			zval_update_constant_ex(&result, (void*)1, NULL TSRMLS_CC);
+			zval_update_constant_ex(&result, 1, NULL TSRMLS_CC);
 			zval_copy_ctor(result);
 			Z_SET_REFCOUNT_P(result, 1);
 			Z_UNSET_ISREF_P(result);
@@ -423,7 +423,7 @@ ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result,
 		retval = 0;
 finish:
 		if (retval) {
-			zval_update_constant_ex(ret_constant, (void*)1, ce TSRMLS_CC);
+			zval_update_constant_ex(ret_constant, 1, ce TSRMLS_CC);
 			*result = **ret_constant;
 			zval_copy_ctor(result);
 			INIT_PZVAL(result);
@@ -435,30 +435,30 @@ finish:
 	return zend_get_constant(name, name_len, result TSRMLS_CC);
 }
 
-zend_constant *zend_quick_get_constant(const zend_literal *key, ulong flags TSRMLS_DC)
+zend_constant *zend_quick_get_constant(const zend_literal *key, zend_uint_t flags TSRMLS_DC)
 {
 	zend_constant *c;
 
-	if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE) {
+	if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRSIZE(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE) {
 		key++;
-		if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE ||
+		if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRSIZE(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE ||
 		    (c->flags & CONST_CS) != 0) {
 			if ((flags & (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) == (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) {
 				key++;
-				if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE) {
+				if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRSIZE(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE) {
 				    key++;
-					if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE ||
+					if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRSIZE(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE ||
 					    (c->flags & CONST_CS) != 0) {
 
 						key--;
-						if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant), &c TSRMLS_CC)) {
+						if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRSIZE(key->constant), &c TSRMLS_CC)) {
 							return NULL;
 						}
 					}
 				}
 			} else {
 				key--;
-				if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant), &c TSRMLS_CC)) {
+				if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRSIZE(key->constant), &c TSRMLS_CC)) {
 					return NULL;
 				}
 			}
@@ -472,7 +472,7 @@ ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC)
 	char *lowercase_name = NULL;
 	char *name;
 	int ret = SUCCESS;
-	ulong chash;
+	zend_uint_t chash;
 
 #if 0
 	printf("Registering constant for module %d\n", c->module_number);

Zend/zend_constants.h

@@ -34,27 +34,27 @@ typedef struct _zend_constant {
 	zval value;
 	int flags;
 	char *name;
-	uint name_len;
+	zend_size_t name_len;
 	int module_number;
 } zend_constant;
 
 #define REGISTER_NULL_CONSTANT(name, flags)  zend_register_null_constant((name), sizeof(name), (flags), module_number TSRMLS_CC)
 #define REGISTER_BOOL_CONSTANT(name, bval, flags)  zend_register_bool_constant((name), sizeof(name), (bval), (flags), module_number TSRMLS_CC)
-#define REGISTER_LONG_CONSTANT(name, lval, flags)  zend_register_long_constant((name), sizeof(name), (lval), (flags), module_number TSRMLS_CC)
+#define REGISTER_INT_CONSTANT(name, lval, flags)  zend_register_int_constant((name), sizeof(name), (lval), (flags), module_number TSRMLS_CC)
 #define REGISTER_DOUBLE_CONSTANT(name, dval, flags)  zend_register_double_constant((name), sizeof(name), (dval), (flags), module_number TSRMLS_CC)
 #define REGISTER_STRING_CONSTANT(name, str, flags)  zend_register_string_constant((name), sizeof(name), (str), (flags), module_number TSRMLS_CC)
 #define REGISTER_STRINGL_CONSTANT(name, str, len, flags)  zend_register_stringl_constant((name), sizeof(name), (str), (len), (flags), module_number TSRMLS_CC)
 
 #define REGISTER_NS_NULL_CONSTANT(ns, name, flags)  zend_register_null_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (flags), module_number TSRMLS_CC)
 #define REGISTER_NS_BOOL_CONSTANT(ns, name, bval, flags)  zend_register_bool_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (bval), (flags), module_number TSRMLS_CC)
-#define REGISTER_NS_LONG_CONSTANT(ns, name, lval, flags)  zend_register_long_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (lval), (flags), module_number TSRMLS_CC)
+#define REGISTER_NS_INT_CONSTANT(ns, name, lval, flags)  zend_register_int_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (lval), (flags), module_number TSRMLS_CC)
 #define REGISTER_NS_DOUBLE_CONSTANT(ns, name, dval, flags)  zend_register_double_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (dval), (flags), module_number TSRMLS_CC)
 #define REGISTER_NS_STRING_CONSTANT(ns, name, str, flags)  zend_register_string_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (str), (flags), module_number TSRMLS_CC)
 #define REGISTER_NS_STRINGL_CONSTANT(ns, name, str, len, flags)  zend_register_stringl_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (str), (len), (flags), module_number TSRMLS_CC)
 
 #define REGISTER_MAIN_NULL_CONSTANT(name, flags)  zend_register_null_constant((name), sizeof(name), (flags), 0 TSRMLS_CC)
 #define REGISTER_MAIN_BOOL_CONSTANT(name, bval, flags)  zend_register_bool_constant((name), sizeof(name), (bval), (flags), 0 TSRMLS_CC)
-#define REGISTER_MAIN_LONG_CONSTANT(name, lval, flags)  zend_register_long_constant((name), sizeof(name), (lval), (flags), 0 TSRMLS_CC)
+#define REGISTER_MAIN_INT_CONSTANT(name, lval, flags)  zend_register_int_constant((name), sizeof(name), (lval), (flags), 0 TSRMLS_CC)
 #define REGISTER_MAIN_DOUBLE_CONSTANT(name, dval, flags)  zend_register_double_constant((name), sizeof(name), (dval), (flags), 0 TSRMLS_CC)
 #define REGISTER_MAIN_STRING_CONSTANT(name, str, flags)  zend_register_string_constant((name), sizeof(name), (str), (flags), 0 TSRMLS_CC)
 #define REGISTER_MAIN_STRINGL_CONSTANT(name, str, len, flags)  zend_register_stringl_constant((name), sizeof(name), (str), (len), (flags), 0 TSRMLS_CC)
@@ -66,18 +66,18 @@ int zend_startup_constants(TSRMLS_D);
 int zend_shutdown_constants(TSRMLS_D);
 void zend_register_standard_constants(TSRMLS_D);
 void clean_non_persistent_constants(TSRMLS_D);
-ZEND_API int zend_get_constant(const char *name, uint name_len, zval *result TSRMLS_DC);
-ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result, zend_class_entry *scope, ulong flags TSRMLS_DC);
-ZEND_API void zend_register_bool_constant(const char *name, uint name_len, zend_bool bval, int flags, int module_number TSRMLS_DC);
-ZEND_API void zend_register_null_constant(const char *name, uint name_len, int flags, int module_number TSRMLS_DC);
-ZEND_API void zend_register_long_constant(const char *name, uint name_len, long lval, int flags, int module_number TSRMLS_DC);
-ZEND_API void zend_register_double_constant(const char *name, uint name_len, double dval, int flags, int module_number TSRMLS_DC);
-ZEND_API void zend_register_string_constant(const char *name, uint name_len, char *strval, int flags, int module_number TSRMLS_DC);
-ZEND_API void zend_register_stringl_constant(const char *name, uint name_len, char *strval, uint strlen, int flags, int module_number TSRMLS_DC);
+ZEND_API int zend_get_constant(const char *name, zend_size_t name_len, zval *result TSRMLS_DC);
+ZEND_API int zend_get_constant_ex(const char *name, zend_size_t name_len, zval *result, zend_class_entry *scope, zend_uint_t flags TSRMLS_DC);
+ZEND_API void zend_register_int_constant(const char *name, zend_size_t name_len, zend_int_t lval, int flags, int module_number TSRMLS_DC);
+ZEND_API void zend_register_double_constant(const char *name, zend_size_t name_len, double dval, int flags, int module_number TSRMLS_DC);
+ZEND_API void zend_register_string_constant(const char *name, zend_size_t name_len, char *strval, int flags, int module_number TSRMLS_DC);
+ZEND_API void zend_register_stringl_constant(const char *name, zend_size_t name_len, char *strval, zend_size_t strlen, int flags, int module_number TSRMLS_DC);
+ZEND_API void zend_register_bool_constant(const char *name, zend_size_t name_len, zend_bool bval, int flags, int module_number TSRMLS_DC);
+ZEND_API void zend_register_null_constant(const char *name, zend_size_t name_len, int flags, int module_number TSRMLS_DC);
 ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC);
 void zend_copy_constants(HashTable *target, HashTable *sourc);
 void copy_zend_constant(zend_constant *c);
-zend_constant *zend_quick_get_constant(const zend_literal *key, ulong flags TSRMLS_DC);
+zend_constant *zend_quick_get_constant(const zend_literal *key, zend_uint_t flags TSRMLS_DC);
 END_EXTERN_C()
 
 #define ZEND_CONSTANT_DTOR (void (*)(void *)) free_zend_constant

Zend/zend_exceptions.c

@@ -86,7 +86,7 @@ void zend_throw_exception_internal(zval *exception TSRMLS_DC) /* {{{ */
 #ifdef HAVE_DTRACE
 	if (DTRACE_EXCEPTION_THROWN_ENABLED()) {
 		const char *classname;
-		zend_uint name_len;
+		zend_size_t name_len;
 
 		if (exception != NULL) {
 			zend_get_object_classname(exception, &classname, &name_len TSRMLS_CC);
@@ -161,7 +161,7 @@ static zend_object_value zend_default_exception_new_ex(zend_class_entry *class_t
 	zend_fetch_debug_backtrace(trace, skip_top_traces, 0, 0 TSRMLS_CC);
 
 	zend_update_property_string(default_exception_ce, &obj, "file", sizeof("file")-1, zend_get_executed_filename(TSRMLS_C) TSRMLS_CC);
-	zend_update_property_long(default_exception_ce, &obj, "line", sizeof("line")-1, zend_get_executed_lineno(TSRMLS_C) TSRMLS_CC);
+	zend_update_property_int(default_exception_ce, &obj, "line", sizeof("line")-1, zend_get_executed_lineno(TSRMLS_C) TSRMLS_CC);
 	zend_update_property(default_exception_ce, &obj, "trace", sizeof("trace")-1, trace TSRMLS_CC);
 
 	return Z_OBJVAL(obj);
@@ -194,11 +194,12 @@ ZEND_METHOD(exception, __clone)
 ZEND_METHOD(exception, __construct)
 {
 	char  *message = NULL;
-	long   code = 0;
+	zend_int_t   code = 0;
 	zval  *object, *previous = NULL;
-	int    argc = ZEND_NUM_ARGS(), message_len;
+	int    argc = ZEND_NUM_ARGS();
+	zend_size_t message_len;
 
-	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc TSRMLS_CC, "|slO!", &message, &message_len, &code, &previous, default_exception_ce) == FAILURE) {
+	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc TSRMLS_CC, "|SiO!", &message, &message_len, &code, &previous, default_exception_ce) == FAILURE) {
 		zend_error(E_ERROR, "Wrong parameters for Exception([string $exception [, long $code [, Exception $previous = NULL]]])");
 	}
 
@@ -209,7 +210,7 @@ ZEND_METHOD(exception, __construct)
 	}
 
 	if (code) {
-		zend_update_property_long(default_exception_ce, object, "code", sizeof("code")-1, code TSRMLS_CC);
+		zend_update_property_int(default_exception_ce, object, "code", sizeof("code")-1, code TSRMLS_CC);
 	}
 
 	if (previous) {
@@ -223,11 +224,12 @@ ZEND_METHOD(exception, __construct)
 ZEND_METHOD(error_exception, __construct)
 {
 	char  *message = NULL, *filename = NULL;
-	long   code = 0, severity = E_ERROR, lineno;
+	zend_int_t   code = 0, severity = E_ERROR, lineno;
 	zval  *object, *previous = NULL;
-	int    argc = ZEND_NUM_ARGS(), message_len, filename_len;
+	int    argc = ZEND_NUM_ARGS();
+	zend_size_t message_len, filename_len;
 
-	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc TSRMLS_CC, "|sllslO!", &message, &message_len, &code, &severity, &filename, &filename_len, &lineno, &previous, default_exception_ce) == FAILURE) {
+	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc TSRMLS_CC, "|SiiSiO!", &message, &message_len, &code, &severity, &filename, &filename_len, &lineno, &previous, default_exception_ce) == FAILURE) {
 		zend_error(E_ERROR, "Wrong parameters for ErrorException([string $exception [, long $code, [ long $severity, [ string $filename, [ long $lineno  [, Exception $previous = NULL]]]]]])");
 	}
 
@@ -238,21 +240,21 @@ ZEND_METHOD(error_exception, __construct)
 	}
 
 	if (code) {
-		zend_update_property_long(default_exception_ce, object, "code", sizeof("code")-1, code TSRMLS_CC);
+		zend_update_property_int(default_exception_ce, object, "code", sizeof("code")-1, code TSRMLS_CC);
 	}
 
 	if (previous) {
 		zend_update_property(default_exception_ce, object, "previous", sizeof("previous")-1, previous TSRMLS_CC);
 	}
 
-	zend_update_property_long(default_exception_ce, object, "severity", sizeof("severity")-1, severity TSRMLS_CC);
+	zend_update_property_int(default_exception_ce, object, "severity", sizeof("severity")-1, severity TSRMLS_CC);
 
 	if (argc >= 4) {
 	    zend_update_property_string(default_exception_ce, object, "file", sizeof("file")-1, filename TSRMLS_CC);
     	if (argc < 5) {
     	    lineno = 0; /* invalidate lineno */
     	}
-    	zend_update_property_long(default_exception_ce, object, "line", sizeof("line")-1, lineno TSRMLS_CC);
+    	zend_update_property_int(default_exception_ce, object, "line", sizeof("line")-1, lineno TSRMLS_CC);
 	}
 }
 /* }}} */
@@ -262,7 +264,7 @@ ZEND_METHOD(error_exception, __construct)
 		return; \
 	}
 
-static void _default_exception_get_entry(zval *object, char *name, int name_len, zval *return_value TSRMLS_DC) /* {{{ */
+static void _default_exception_get_entry(zval *object, char *name, zend_size_t name_len, zval *return_value TSRMLS_DC) /* {{{ */
 {
 	zval *value;
 
@@ -341,7 +343,7 @@ ZEND_METHOD(error_exception, getSeverity)
 
 #define TRACE_APPEND_STRL(val, vallen)                                   \
 	{                                                                    \
-		int l = vallen;                                                  \
+		zend_size_t l = vallen;                                                  \
 		*str = (char*)erealloc(*str, *len + l + 1);                      \
 		memcpy((*str) + *len, val, l);                                   \
 		*len += l;                                                       \
@@ -356,22 +358,27 @@ ZEND_METHOD(error_exception, getSeverity)
 			zend_error(E_WARNING, "Value for %s is no string", key); \
 			TRACE_APPEND_STR("[unknown]");                          \
 		} else {                                                        \
-			TRACE_APPEND_STRL(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));  \
+			TRACE_APPEND_STRL(Z_STRVAL_PP(tmp), Z_STRSIZE_PP(tmp));  \
 		}                                                               \
 	}
 
+
+#define TRACE_ARG_APPEND(vallen)								\
+	*str = (char*)erealloc(*str, *len + 1 + vallen);					\
+	memmove((*str) + *len - l_added + 1 + vallen, (*str) + *len - l_added + 1, l_added);
+
 /* }}} */
 
 static int _build_trace_args(zval **arg TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
 	char **str;
-	int *len;
+	zend_size_t *len;
 
 	str = va_arg(args, char**);
-	len = va_arg(args, int*);
+	len = va_arg(args, zend_size_t*);
 
 	/* the trivial way would be to do:
-	 * conver_to_string_ex(arg);
+	 * convert_to_string_ex(arg);
 	 * append it and kill the now tmp arg.
 	 * but that could cause some E_NOTICE and also damn long lines.
 	 */
@@ -381,27 +388,77 @@ static int _build_trace_args(zval **arg TSRMLS_DC, int num_args, va_list args, z
 			TRACE_APPEND_STR("NULL, ");
 			break;
 		case IS_STRING: {
-			int l_added;
+			zend_size_t l_added;
 			TRACE_APPEND_CHR('\'');
-			if (Z_STRLEN_PP(arg) > 15) {
+			if (Z_STRSIZE_PP(arg) > 15) {
 				TRACE_APPEND_STRL(Z_STRVAL_PP(arg), 15);
 				TRACE_APPEND_STR("...', ");
 				l_added = 15 + 6 + 1; /* +1 because of while (--l_added) */
 			} else {
-				l_added = Z_STRLEN_PP(arg);
+				l_added = Z_STRSIZE_PP(arg);
 				TRACE_APPEND_STRL(Z_STRVAL_PP(arg), l_added);
 				TRACE_APPEND_STR("', ");
 				l_added += 3 + 1;
 			}
 			while (--l_added) {
-				if ((*str)[*len - l_added] < 32) {
-					(*str)[*len - l_added] = '?';
+				unsigned char chr = (*str)[*len - l_added];
+				if (chr < 32 || chr == '\\' || chr > 126) {
+					(*str)[*len - l_added] = '\\';
+
+					switch (chr) {
+						case '\n':
+							TRACE_ARG_APPEND(1);
+							(*str)[++(*len) - l_added] = 'n';
+							break;
+						case '\r':
+							TRACE_ARG_APPEND(1);
+							(*str)[++(*len) - l_added] = 'r';
+							break;
+						case '\t':
+							TRACE_ARG_APPEND(1);
+							(*str)[++(*len) - l_added] = 't';
+							break;
+						case '\f':
+							TRACE_ARG_APPEND(1);
+							(*str)[++(*len) - l_added] = 'f';
+							break;
+						case '\v':
+							TRACE_ARG_APPEND(1);
+							(*str)[++(*len) - l_added] = 'v';
+							break;
+#ifndef PHP_WIN32
+						case '\e':
+#else
+						case VK_ESCAPE:
+#endif
+							TRACE_ARG_APPEND(1);
+							(*str)[++(*len) - l_added] = 'e';
+							break;
+						case '\\':
+							TRACE_ARG_APPEND(1);
+							(*str)[++(*len) - l_added] = '\\';
+							break;
+						default:
+							TRACE_ARG_APPEND(3);
+							(*str)[*len - l_added + 1] = 'x';
+							if ((chr >> 4) < 10) {
+								(*str)[*len - l_added + 2] = (chr >> 4) + '0';
+							} else {
+								(*str)[*len - l_added + 2] = (chr >> 4) + 'A' - 10;
+							}
+							if (chr % 16 < 10) {
+								(*str)[*len - l_added + 3] = chr % 16 + '0';
+							} else {
+								(*str)[*len - l_added + 3] = chr % 16 + 'A' - 10;
+							}
+							*len += 3;
+					}
 				}
 			}
 			break;
 		}
 		case IS_BOOL:
-			if (Z_LVAL_PP(arg)) {
+			if (Z_IVAL_PP(arg)) {
 				TRACE_APPEND_STR("true, ");
 			} else {
 				TRACE_APPEND_STR("false, ");
@@ -410,10 +467,10 @@ static int _build_trace_args(zval **arg TSRMLS_DC, int num_args, va_list args, z
 		case IS_RESOURCE:
 			TRACE_APPEND_STR("Resource id #");
 			/* break; */
-		case IS_LONG: {
-			long lval = Z_LVAL_PP(arg);
-			char s_tmp[MAX_LENGTH_OF_LONG + 1];
-			int l_tmp = zend_sprintf(s_tmp, "%ld", lval);  /* SAFE */
+		case IS_INT: {
+			zend_int_t lval = Z_IVAL_PP(arg);
+			char s_tmp[MAX_LENGTH_OF_ZEND_INT + 1];
+			zend_size_t l_tmp = zend_sprintf(s_tmp, ZEND_INT_FMT, lval);  /* SAFE */
 			TRACE_APPEND_STRL(s_tmp, l_tmp);
 			TRACE_APPEND_STR(", ");
 			break;
@@ -421,7 +478,7 @@ static int _build_trace_args(zval **arg TSRMLS_DC, int num_args, va_list args, z
 		case IS_DOUBLE: {
 			double dval = Z_DVAL_PP(arg);
 			char *s_tmp;
-			int l_tmp;
+			zend_size_t l_tmp;
 
 			s_tmp = emalloc(MAX_LENGTH_OF_DOUBLE + EG(precision) + 1);
 			l_tmp = zend_sprintf(s_tmp, "%.*G", (int) EG(precision), dval);  /* SAFE */
@@ -436,7 +493,7 @@ static int _build_trace_args(zval **arg TSRMLS_DC, int num_args, va_list args, z
 			break;
 		case IS_OBJECT: {
 			const char *class_name;
-			zend_uint class_name_len;
+			zend_size_t class_name_len;
 			int dup;
 
 			TRACE_APPEND_STR("Object(");
@@ -461,8 +518,8 @@ static int _build_trace_args(zval **arg TSRMLS_DC, int num_args, va_list args, z
 static int _build_trace_string(zval **frame TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
 	char *s_tmp, **str;
-	int *len, *num;
-	long line;
+	zend_size_t *len, *num;
+	zend_int_t line;
 	HashTable *ht = Z_ARRVAL_PP(frame);
 	zval **file, **tmp;
 
@@ -472,11 +529,11 @@ static int _build_trace_string(zval **frame TSRMLS_DC, int num_args, va_list arg
 	}
 
 	str = va_arg(args, char**);
-	len = va_arg(args, int*);
-	num = va_arg(args, int*);
+	len = va_arg(args, zend_size_t*);
+	num = va_arg(args, zend_size_t*);
 
-	s_tmp = emalloc(1 + MAX_LENGTH_OF_LONG + 1 + 1);
-	sprintf(s_tmp, "#%d ", (*num)++);
+	s_tmp = emalloc(1 + MAX_LENGTH_OF_ZEND_INT + 1 + 1);
+	sprintf(s_tmp, "#" ZEND_INT_FMT " ", (*num)++);
 	TRACE_APPEND_STRL(s_tmp, strlen(s_tmp));
 	efree(s_tmp);
 	if (zend_hash_find(ht, "file", sizeof("file"), (void**)&file) == SUCCESS) {
@@ -485,8 +542,8 @@ static int _build_trace_string(zval **frame TSRMLS_DC, int num_args, va_list arg
 			TRACE_APPEND_STR("[unknown function]");
 		} else{
 			if (zend_hash_find(ht, "line", sizeof("line"), (void**)&tmp) == SUCCESS) {
-				if (Z_TYPE_PP(tmp) == IS_LONG) {
-					line = Z_LVAL_PP(tmp);
+				if (Z_TYPE_PP(tmp) == IS_INT) {
+					line = Z_IVAL_PP(tmp);
 				} else {
 					zend_error(E_WARNING, "Line is no long");
 					line = 0;
@@ -494,8 +551,8 @@ static int _build_trace_string(zval **frame TSRMLS_DC, int num_args, va_list arg
 			} else {
 				line = 0;
 			}
-			s_tmp = emalloc(Z_STRLEN_PP(file) + MAX_LENGTH_OF_LONG + 4 + 1);
-			sprintf(s_tmp, "%s(%ld): ", Z_STRVAL_PP(file), line);
+			s_tmp = emalloc(Z_STRSIZE_PP(file) + MAX_LENGTH_OF_ZEND_INT + 4 + 1);
+			sprintf(s_tmp, "%s(" ZEND_INT_FMT "): ", Z_STRVAL_PP(file), line);
 			TRACE_APPEND_STRL(s_tmp, strlen(s_tmp));
 			efree(s_tmp);
 		}
@@ -508,7 +565,7 @@ static int _build_trace_string(zval **frame TSRMLS_DC, int num_args, va_list arg
 	TRACE_APPEND_CHR('(');
 	if (zend_hash_find(ht, "args", sizeof("args"), (void**)&tmp) == SUCCESS) {
 		if (Z_TYPE_PP(tmp) == IS_ARRAY) {
-			int last_len = *len;
+			zend_size_t last_len = *len;
 			zend_hash_apply_with_arguments(Z_ARRVAL_PP(tmp) TSRMLS_CC, (apply_func_args_t)_build_trace_args, 2, str, len);
 			if (last_len != *len) {
 				*len -= 2; /* remove last ', ' */
@@ -528,7 +585,7 @@ ZEND_METHOD(exception, getTraceAsString)
 {
 	zval *trace;
 	char *res, **str, *s_tmp;
-	int res_len = 0, *len = &res_len, num = 0;
+	zend_size_t res_len = 0, *len = &res_len, num = 0;
 
 	DEFAULT_0_PARAMS;
 	
@@ -538,8 +595,8 @@ ZEND_METHOD(exception, getTraceAsString)
 	trace = zend_read_property(default_exception_ce, getThis(), "trace", sizeof("trace")-1, 1 TSRMLS_CC);
 	zend_hash_apply_with_arguments(Z_ARRVAL_P(trace) TSRMLS_CC, (apply_func_args_t)_build_trace_string, 3, str, len, &num);
 
-	s_tmp = emalloc(1 + MAX_LENGTH_OF_LONG + 7 + 1);
-	sprintf(s_tmp, "#%d {main}", num);
+	s_tmp = emalloc(1 + MAX_LENGTH_OF_ZEND_INT + 7 + 1);
+	sprintf(s_tmp, "#" ZEND_INT_FMT " {main}", num);
 	TRACE_APPEND_STRL(s_tmp, strlen(s_tmp));
 	efree(s_tmp);
 
@@ -560,10 +617,10 @@ ZEND_METHOD(exception, getPrevious)
 	RETURN_ZVAL(previous, 1, 0);
 }
 
-int zend_spprintf(char **message, int max_len, const char *format, ...) /* {{{ */
+zend_size_t zend_spprintf(char **message, zend_size_t max_len, const char *format, ...) /* {{{ */
 {
 	va_list arg;
-	int len;
+	zend_size_t len;
 
 	va_start(arg, format);
 	len = zend_vspprintf(message, max_len, format, arg);
@@ -578,7 +635,7 @@ ZEND_METHOD(exception, __toString)
 {
 	zval message, file, line, *trace, *exception;
 	char *str, *prev_str;
-	int len = 0;
+	zend_size_t len = 0;
 	zend_fcall_info fci;
 	zval fname;
 	
@@ -597,7 +654,7 @@ ZEND_METHOD(exception, __toString)
 
 		convert_to_string(&message);
 		convert_to_string(&file);
-		convert_to_long(&line);
+		convert_to_int(&line);
 
 		fci.size = sizeof(fci);
 		fci.function_table = &Z_OBJCE_P(exception)->function_table;
@@ -616,15 +673,15 @@ ZEND_METHOD(exception, __toString)
 			trace = NULL;
 		}
 
-		if (Z_STRLEN(message) > 0) {
-			len = zend_spprintf(&str, 0, "exception '%s' with message '%s' in %s:%ld\nStack trace:\n%s%s%s",
-								Z_OBJCE_P(exception)->name, Z_STRVAL(message), Z_STRVAL(file), Z_LVAL(line),
-								(trace && Z_STRLEN_P(trace)) ? Z_STRVAL_P(trace) : "#0 {main}\n",
+		if (Z_STRSIZE(message) > 0) {
+			len = zend_spprintf(&str, 0, "exception '%s' with message '%s' in %s:" ZEND_INT_FMT "\nStack trace:\n%s%s%s",
+								Z_OBJCE_P(exception)->name, Z_STRVAL(message), Z_STRVAL(file), Z_IVAL(line),
+								(trace && Z_STRSIZE_P(trace)) ? Z_STRVAL_P(trace) : "#0 {main}\n",
 								len ? "\n\nNext " : "", prev_str);
 		} else {
-			len = zend_spprintf(&str, 0, "exception '%s' in %s:%ld\nStack trace:\n%s%s%s",
-								Z_OBJCE_P(exception)->name, Z_STRVAL(file), Z_LVAL(line),
-								(trace && Z_STRLEN_P(trace)) ? Z_STRVAL_P(trace) : "#0 {main}\n",
+			len = zend_spprintf(&str, 0, "exception '%s' in %s:" ZEND_INT_FMT "\nStack trace:\n%s%s%s",
+								Z_OBJCE_P(exception)->name, Z_STRVAL(file), Z_IVAL(line),
+								(trace && Z_STRSIZE_P(trace)) ? Z_STRVAL_P(trace) : "#0 {main}\n",
 								len ? "\n\nNext " : "", prev_str);
 		}
 		efree(prev_str);
@@ -707,7 +764,7 @@ void zend_register_default_exception(TSRMLS_D) /* {{{ */
 
 	zend_declare_property_string(default_exception_ce, "message", sizeof("message")-1, "", ZEND_ACC_PROTECTED TSRMLS_CC);
 	zend_declare_property_string(default_exception_ce, "string", sizeof("string")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
-	zend_declare_property_long(default_exception_ce, "code", sizeof("code")-1, 0, ZEND_ACC_PROTECTED TSRMLS_CC);
+	zend_declare_property_int(default_exception_ce, "code", sizeof("code")-1, 0, ZEND_ACC_PROTECTED TSRMLS_CC);
 	zend_declare_property_null(default_exception_ce, "file", sizeof("file")-1, ZEND_ACC_PROTECTED TSRMLS_CC);
 	zend_declare_property_null(default_exception_ce, "line", sizeof("line")-1, ZEND_ACC_PROTECTED TSRMLS_CC);
 	zend_declare_property_null(default_exception_ce, "trace", sizeof("trace")-1, ZEND_ACC_PRIVATE TSRMLS_CC);
@@ -716,7 +773,7 @@ void zend_register_default_exception(TSRMLS_D) /* {{{ */
 	INIT_CLASS_ENTRY(ce, "ErrorException", error_exception_functions);
 	error_exception_ce = zend_register_internal_class_ex(&ce, default_exception_ce, NULL TSRMLS_CC);
 	error_exception_ce->create_object = zend_error_exception_new;
-	zend_declare_property_long(error_exception_ce, "severity", sizeof("severity")-1, E_ERROR, ZEND_ACC_PROTECTED TSRMLS_CC);
+	zend_declare_property_int(error_exception_ce, "severity", sizeof("severity")-1, E_ERROR, ZEND_ACC_PROTECTED TSRMLS_CC);
 }
 /* }}} */
 
@@ -732,7 +789,7 @@ ZEND_API zend_class_entry *zend_get_error_exception(TSRMLS_D) /* {{{ */
 }
 /* }}} */
 
-ZEND_API zval * zend_throw_exception(zend_class_entry *exception_ce, const char *message, long code TSRMLS_DC) /* {{{ */
+ZEND_API zval * zend_throw_exception(zend_class_entry *exception_ce, const char *message, zend_int_t code TSRMLS_DC) /* {{{ */
 {
 	zval *ex;
 
@@ -752,7 +809,7 @@ ZEND_API zval * zend_throw_exception(zend_class_entry *exception_ce, const char
 		zend_update_property_string(default_exception_ce, ex, "message", sizeof("message")-1, message TSRMLS_CC);
 	}
 	if (code) {
-		zend_update_property_long(default_exception_ce, ex, "code", sizeof("code")-1, code TSRMLS_CC);
+		zend_update_property_int(default_exception_ce, ex, "code", sizeof("code")-1, code TSRMLS_CC);
 	}
 
 	zend_throw_exception_internal(ex TSRMLS_CC);
@@ -760,7 +817,7 @@ ZEND_API zval * zend_throw_exception(zend_class_entry *exception_ce, const char
 }
 /* }}} */
 
-ZEND_API zval * zend_throw_exception_ex(zend_class_entry *exception_ce, long code TSRMLS_DC, const char *format, ...) /* {{{ */
+ZEND_API zval * zend_throw_exception_ex(zend_class_entry *exception_ce, zend_int_t code TSRMLS_DC, const char *format, ...) /* {{{ */
 {
 	va_list arg;
 	char *message;
@@ -775,15 +832,15 @@ ZEND_API zval * zend_throw_exception_ex(zend_class_entry *exception_ce, long cod
 }
 /* }}} */
 
-ZEND_API zval * zend_throw_error_exception(zend_class_entry *exception_ce, const char *message, long code, int severity TSRMLS_DC) /* {{{ */
+ZEND_API zval * zend_throw_error_exception(zend_class_entry *exception_ce, const char *message, zend_int_t code, int severity TSRMLS_DC) /* {{{ */
 {
 	zval *ex = zend_throw_exception(exception_ce, message, code TSRMLS_CC);
-	zend_update_property_long(default_exception_ce, ex, "severity", sizeof("severity")-1, severity TSRMLS_CC);
+	zend_update_property_int(default_exception_ce, ex, "severity", sizeof("severity")-1, severity TSRMLS_CC);
 	return ex;
 }
 /* }}} */
 
-static void zend_error_va(int type, const char *file, uint lineno, const char *format, ...) /* {{{ */
+static void zend_error_va(int type, const char *file, zend_size_t lineno, const char *format, ...) /* {{{ */
 {
 	va_list args;
 
@@ -819,13 +876,13 @@ ZEND_API void zend_exception_error(zval *exception, int severity TSRMLS_DC) /* {
 				line = zend_read_property(default_exception_ce, EG(exception), "line", sizeof("line")-1, 1 TSRMLS_CC);
 
 				convert_to_string(file);
-				file = (Z_STRLEN_P(file) > 0) ? file : NULL;
-				line = (Z_TYPE_P(line) == IS_LONG) ? line : NULL;
+				file = (Z_STRSIZE_P(file) > 0) ? file : NULL;
+				line = (Z_TYPE_P(line) == IS_INT) ? line : NULL;
 			} else {
 				file = NULL;
 				line = NULL;
 			}
-			zend_error_va(E_WARNING, file ? Z_STRVAL_P(file) : NULL, line ? Z_LVAL_P(line) : 0, "Uncaught %s in exception handling during call to %s::__tostring()", Z_OBJCE_P(EG(exception))->name, ce_exception->name);
+			zend_error_va(E_WARNING, file ? Z_STRVAL_P(file) : NULL, line ? Z_IVAL_P(line) : 0, "Uncaught %s in exception handling during call to %s::__tostring()", Z_OBJCE_P(EG(exception))->name, ce_exception->name);
 		}
 
 		str = zend_read_property(default_exception_ce, exception, "string", sizeof("string")-1, 1 TSRMLS_CC);
@@ -834,9 +891,9 @@ ZEND_API void zend_exception_error(zval *exception, int severity TSRMLS_DC) /* {
 
 		convert_to_string(str);
 		convert_to_string(file);
-		convert_to_long(line);
+		convert_to_int(line);
 
-		zend_error_va(severity, (Z_STRLEN_P(file) > 0) ? Z_STRVAL_P(file) : NULL, Z_LVAL_P(line), "Uncaught %s\n  thrown", Z_STRVAL_P(str));
+		zend_error_va(severity, (Z_STRSIZE_P(file) > 0) ? Z_STRVAL_P(file) : NULL, Z_IVAL_P(line), "Uncaught %s\n  thrown", Z_STRVAL_P(str));
 	} else {
 		zend_error(severity, "Uncaught exception '%s'", ce_exception->name);
 	}

Zend/zend_exceptions.h

@@ -40,12 +40,12 @@ ZEND_API void zend_register_default_classes(TSRMLS_D);
 
 /* exception_ce   NULL or zend_exception_get_default() or a derived class
  * message        NULL or the message of the exception */
-ZEND_API zval * zend_throw_exception(zend_class_entry *exception_ce, const char *message, long code TSRMLS_DC);
-ZEND_API zval * zend_throw_exception_ex(zend_class_entry *exception_ce, long code TSRMLS_DC, const char *format, ...);
+ZEND_API zval * zend_throw_exception(zend_class_entry *exception_ce, const char *message, zend_int_t code TSRMLS_DC);
+ZEND_API zval * zend_throw_exception_ex(zend_class_entry *exception_ce, zend_int_t code TSRMLS_DC, const char *format, ...);
 ZEND_API void zend_throw_exception_object(zval *exception TSRMLS_DC);
 ZEND_API void zend_clear_exception(TSRMLS_D);
 
-ZEND_API zval * zend_throw_error_exception(zend_class_entry *exception_ce, const char *message, long code, int severity TSRMLS_DC);
+ZEND_API zval * zend_throw_error_exception(zend_class_entry *exception_ce, const char *message, zend_int_t code, int severity TSRMLS_DC);
 
 extern ZEND_API void (*zend_throw_exception_hook)(zval *ex TSRMLS_DC);
 
@@ -53,7 +53,7 @@ extern ZEND_API void (*zend_throw_exception_hook)(zval *ex TSRMLS_DC);
 ZEND_API void zend_exception_error(zval *exception, int severity TSRMLS_DC);
 
 /* do not export, in php it's available thru spprintf directly */
-int zend_spprintf(char **message, int max_len, const char *format, ...);
+zend_size_t zend_spprintf(char **message, zend_size_t max_len, const char *format, ...);
 
 END_EXTERN_C()
 

Zend/zend_execute.c

@@ -563,8 +563,8 @@ static void zend_assign_to_variable_reference(zval **variable_ptr_ptr, zval **va
 static inline void make_real_object(zval **object_ptr TSRMLS_DC)
 {
 	if (Z_TYPE_PP(object_ptr) == IS_NULL
-		|| (Z_TYPE_PP(object_ptr) == IS_BOOL && Z_LVAL_PP(object_ptr) == 0)
-		|| (Z_TYPE_PP(object_ptr) == IS_STRING && Z_STRLEN_PP(object_ptr) == 0)
+		|| (Z_TYPE_PP(object_ptr) == IS_BOOL && Z_IVAL_PP(object_ptr) == 0)
+		|| (Z_TYPE_PP(object_ptr) == IS_STRING && Z_STRSIZE_PP(object_ptr) == 0)
 	) {
 		SEPARATE_ZVAL_IF_NOT_REF(object_ptr);
 		zval_dtor(*object_ptr);
@@ -573,7 +573,7 @@ static inline void make_real_object(zval **object_ptr TSRMLS_DC)
 	}
 }
 
-ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, ulong fetch_type, const char **class_name, zend_class_entry **pce TSRMLS_DC)
+ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, zend_uint_t fetch_type, const char **class_name, zend_class_entry **pce TSRMLS_DC)
 {
 	*pce = zend_fetch_class(cur_arg_info->class_name, cur_arg_info->class_name_len, (fetch_type | ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD) TSRMLS_CC);
 
@@ -585,7 +585,7 @@ ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, ul
 	}
 }
 
-ZEND_API int zend_verify_arg_error(int error_type, const zend_function *zf, zend_uint arg_num, const char *need_msg, const char *need_kind, const char *given_msg, const char *given_kind TSRMLS_DC)
+ZEND_API int zend_verify_arg_error(int error_type, const zend_function *zf, zend_size_t arg_num, const char *need_msg, const char *need_kind, const char *given_msg, const char *given_kind TSRMLS_DC)
 {
 	zend_execute_data *ptr = EG(current_execute_data)->prev_execute_data;
 	const char *fname = zf->common.function_name;
@@ -601,14 +601,14 @@ ZEND_API int zend_verify_arg_error(int error_type, const zend_function *zf, zend
 	}
 
 	if (ptr && ptr->op_array) {
-		zend_error(error_type, "Argument %d passed to %s%s%s() must %s%s, %s%s given, called in %s on line %d and defined", arg_num, fclass, fsep, fname, need_msg, need_kind, given_msg, given_kind, ptr->op_array->filename, ptr->opline->lineno);
+		zend_error(error_type, "Argument %pu passed to %s%s%s() must %s%s, %s%s given, called in %s on line %pu and defined", arg_num, fclass, fsep, fname, need_msg, need_kind, given_msg, given_kind, ptr->op_array->filename, ptr->opline->lineno);
 	} else {
-		zend_error(error_type, "Argument %d passed to %s%s%s() must %s%s, %s%s given", arg_num, fclass, fsep, fname, need_msg, need_kind, given_msg, given_kind);
+		zend_error(error_type, "Argument %pu passed to %s%s%s() must %s%s, %s%s given", arg_num, fclass, fsep, fname, need_msg, need_kind, given_msg, given_kind);
 	}
 	return 0;
 }
 
-static inline int zend_verify_arg_type(zend_function *zf, zend_uint arg_num, zval *arg, ulong fetch_type TSRMLS_DC)
+static inline int zend_verify_arg_type(zend_function *zf, zend_size_t arg_num, zval *arg, zend_uint_t fetch_type TSRMLS_DC)
 {
 	zend_arg_info *cur_arg_info;
 	char *need_msg;
@@ -686,8 +686,8 @@ static inline void zend_assign_to_object(zval **retval, zval **object_ptr, zval
 			return;
 		}
 		if (Z_TYPE_P(object) == IS_NULL ||
-		    (Z_TYPE_P(object) == IS_BOOL && Z_LVAL_P(object) == 0) ||
-		    (Z_TYPE_P(object) == IS_STRING && Z_STRLEN_P(object) == 0)) {
+		    (Z_TYPE_P(object) == IS_BOOL && Z_IVAL_P(object) == 0) ||
+		    (Z_TYPE_P(object) == IS_STRING && Z_STRSIZE_P(object) == 0)) {
 			SEPARATE_ZVAL_IF_NOT_REF(object_ptr);
 			object = *object_ptr;
 			Z_ADDREF_P(object);
@@ -771,20 +771,20 @@ static inline void zend_assign_to_object(zval **retval, zval **object_ptr, zval
 static inline int zend_assign_to_string_offset(const temp_variable *T, const zval *value, int value_type TSRMLS_DC)
 {
 	zval *str = T->str_offset.str;
-	zend_uint offset = T->str_offset.offset;
+	zend_uint_t offset = T->str_offset.offset;
 	if (Z_TYPE_P(str) == IS_STRING) {
-		if ((int)offset < 0) {
+		if ((zend_int_t)offset < 0) {
 			zend_error(E_WARNING, "Illegal string offset:  %d", offset);
 			return 0;
 		}
 
-		if (offset >= Z_STRLEN_P(str)) {
+		if (offset >= Z_STRSIZE_P(str)) {
 			Z_STRVAL_P(str) = str_erealloc(Z_STRVAL_P(str), offset+1+1);
-			memset(Z_STRVAL_P(str) + Z_STRLEN_P(str), ' ', offset - Z_STRLEN_P(str));
+			memset(Z_STRVAL_P(str) + Z_STRSIZE_P(str), ' ', offset - Z_STRSIZE_P(str));
 			Z_STRVAL_P(str)[offset+1] = 0;
-			Z_STRLEN_P(str) = offset+1;
+			Z_STRSIZE_P(str) = offset+1;
 		} else if (IS_INTERNED(Z_STRVAL_P(str))) {
-			Z_STRVAL_P(str) = estrndup(Z_STRVAL_P(str), Z_STRLEN_P(str));
+			Z_STRVAL_P(str) = estrndup(Z_STRVAL_P(str), Z_STRSIZE_P(str));
 		}
 
 		if (Z_TYPE_P(value) != IS_STRING) {
@@ -943,6 +943,26 @@ copy_value:
 	}
 }
 
+static void zval_deep_copy(zval **p)
+{
+	zval *value;
+
+	ALLOC_ZVAL(value);
+	*value = **p;
+	if (Z_TYPE_P(value) == IS_ARRAY) {
+		HashTable *ht;
+
+		ALLOC_HASHTABLE(ht);
+		zend_hash_init(ht, zend_hash_num_elements(Z_ARRVAL_P(value)), NULL, ZVAL_PTR_DTOR, 0);
+		zend_hash_copy(ht, Z_ARRVAL_P(value), (copy_ctor_func_t) zval_deep_copy, NULL, sizeof(zval *));
+		Z_ARRVAL_P(value) = ht;
+	} else {
+		zval_copy_ctor(value);
+	}
+	INIT_PZVAL(value);
+	*p = value;
+}
+
 /* Utility Functions for Extensions */
 static void zend_extension_statement_handler(const zend_extension *extension, zend_op_array *op_array TSRMLS_DC)
 {
@@ -997,8 +1017,8 @@ static inline zval **zend_fetch_dimension_address_inner(HashTable *ht, const zva
 {
 	zval **retval;
 	char *offset_key;
-	int offset_key_length;
-	ulong hval;
+	zend_size_t offset_key_length;
+	zend_uint_t hval;
 
 	switch (dim->type) {
 		case IS_NULL:
@@ -1042,26 +1062,26 @@ fetch_string_dim:
 			}
 			break;
 		case IS_DOUBLE:
-			hval = zend_dval_to_lval(Z_DVAL_P(dim));
+			hval = zend_dval_to_ival(Z_DVAL_P(dim));
 			goto num_index;
 		case IS_RESOURCE:
-			zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_LVAL_P(dim), Z_LVAL_P(dim));
+			zend_error(E_STRICT, "Resource ID#" ZEND_INT_FMT " used as offset, casting to integer (" ZEND_INT_FMT ")", Z_IVAL_P(dim), Z_IVAL_P(dim));
 			/* Fall Through */
 		case IS_BOOL:
-		case IS_LONG:
-			hval = Z_LVAL_P(dim);
+		case IS_INT:
+			hval = Z_IVAL_P(dim);
 num_index:
 			if (zend_hash_index_find(ht, hval, (void **) &retval) == FAILURE) {
 				switch (type) {
 					case BP_VAR_R:
-						zend_error(E_NOTICE,"Undefined offset: %ld", hval);
+						zend_error(E_NOTICE,"Undefined offset: " ZEND_INT_FMT, hval);
 						/* break missing intentionally */
 					case BP_VAR_UNSET:
 					case BP_VAR_IS:
 						retval = &EG(uninitialized_zval_ptr);
 						break;
 					case BP_VAR_RW:
-						zend_error(E_NOTICE,"Undefined offset: %ld", hval);
+						zend_error(E_NOTICE,"Undefined offset: " ZEND_INT_FMT, hval);
 						/* break missing intentionally */
 					case BP_VAR_W: {
 						zval *new_zval = &EG(uninitialized_zval);
@@ -1136,7 +1156,7 @@ convert_to_array:
 		case IS_STRING: {
 				zval tmp;
 
-				if (type != BP_VAR_UNSET && Z_STRLEN_P(container)==0) {
+				if (type != BP_VAR_UNSET && Z_STRSIZE_P(container)==0) {
 					goto convert_to_array;
 				}
 				if (dim == NULL) {
@@ -1147,12 +1167,12 @@ convert_to_array:
 					SEPARATE_ZVAL_IF_NOT_REF(container_ptr);
 				}
 
-				if (Z_TYPE_P(dim) != IS_LONG) {
+				if (Z_TYPE_P(dim) != IS_INT) {
 
 					switch(Z_TYPE_P(dim)) {
-						/* case IS_LONG: */
+						/* case IS_INT: */
 						case IS_STRING:
-							if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) {
+							if (IS_INT == is_numeric_string(Z_STRVAL_P(dim), Z_STRSIZE_P(dim), NULL, NULL, -1)) {
 								break;
 							}
 							if (type != BP_VAR_UNSET) {
@@ -1172,13 +1192,13 @@ convert_to_array:
 
 					tmp = *dim;
 					zval_copy_ctor(&tmp);
-					convert_to_long(&tmp);
+					convert_to_int(&tmp);
 					dim = &tmp;
 				}
 				container = *container_ptr;
 				result->str_offset.str = container;
 				PZVAL_LOCK(container);
-				result->str_offset.offset = Z_LVAL_P(dim);
+				result->str_offset.offset = Z_IVAL_P(dim);
 				result->str_offset.ptr_ptr = NULL;
 				return;
 			}
@@ -1227,7 +1247,7 @@ convert_to_array:
 			break;
 
 		case IS_BOOL:
-			if (type != BP_VAR_UNSET && Z_LVAL_P(container)==0) {
+			if (type != BP_VAR_UNSET && Z_IVAL_P(container)==0) {
 				goto convert_to_array;
 			}
 			/* break missing intentionally */
@@ -1267,11 +1287,11 @@ static void zend_fetch_dimension_address_read(temp_variable *result, zval *conta
 				zval tmp;
 				zval *ptr;
 
-				if (Z_TYPE_P(dim) != IS_LONG) {
+				if (Z_TYPE_P(dim) != IS_INT) {
 					switch(Z_TYPE_P(dim)) {
-						/* case IS_LONG: */
+						/* case IS_INT: */
 						case IS_STRING:
-							if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) {
+							if (IS_INT == is_numeric_string(Z_STRVAL_P(dim), Z_STRSIZE_P(dim), NULL, NULL, -1)) {
 								break;
 							}
 							if (type != BP_VAR_IS) {
@@ -1292,7 +1312,7 @@ static void zend_fetch_dimension_address_read(temp_variable *result, zval *conta
 
 					ZVAL_COPY_VALUE(&tmp, dim);
 					zval_copy_ctor(&tmp);
-					convert_to_long(&tmp);
+					convert_to_int(&tmp);
 					dim = &tmp;
 				}
 
@@ -1300,17 +1320,17 @@ static void zend_fetch_dimension_address_read(temp_variable *result, zval *conta
 				INIT_PZVAL(ptr);
 				Z_TYPE_P(ptr) = IS_STRING;
 
-				if (Z_LVAL_P(dim) < 0 || Z_STRLEN_P(container) <= Z_LVAL_P(dim)) {
+				if (Z_IVAL_P(dim) < 0 || Z_STRSIZE_P(container) <= Z_IVAL_P(dim)) {
 					if (type != BP_VAR_IS) {
-						zend_error(E_NOTICE, "Uninitialized string offset: %ld", Z_LVAL_P(dim));
+						zend_error(E_NOTICE, "Uninitialized string offset: " ZEND_INT_FMT, Z_IVAL_P(dim));
 					}
 					Z_STRVAL_P(ptr) = STR_EMPTY_ALLOC();
-					Z_STRLEN_P(ptr) = 0;
+					Z_STRSIZE_P(ptr) = 0;
 				} else {
 					Z_STRVAL_P(ptr) = (char*)emalloc(2);
-					Z_STRVAL_P(ptr)[0] = Z_STRVAL_P(container)[Z_LVAL_P(dim)];
+					Z_STRVAL_P(ptr)[0] = Z_STRVAL_P(container)[Z_IVAL_P(dim)];
 					Z_STRVAL_P(ptr)[1] = 0;
-					Z_STRLEN_P(ptr) = 1;
+					Z_STRSIZE_P(ptr) = 1;
 				}
 				result->var.ptr = ptr;
 				return;
@@ -1352,9 +1372,15 @@ static void zend_fetch_dimension_address_read(temp_variable *result, zval *conta
 	}
 }
 
+ZEND_API void zend_fetch_dimension_by_zval(zval **result, zval *container, zval *dim TSRMLS_DC) {
+	temp_variable tmp;
+	zend_fetch_dimension_address_read(&tmp, container, dim, IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+	*result = tmp.var.ptr;
+}
+
 static void zend_fetch_property_address(temp_variable *result, zval **container_ptr, zval *prop_ptr, const zend_literal *key, int type TSRMLS_DC)
 {
-	zval *container = *container_ptr;;
+	zval *container = *container_ptr;
 
 	if (Z_TYPE_P(container) != IS_OBJECT) {
 		if (container == &EG(error_zval)) {
@@ -1366,8 +1392,8 @@ static void zend_fetch_property_address(temp_variable *result, zval **container_
 		/* this should modify object only if it's empty */
 		if (type != BP_VAR_UNSET &&
 		    ((Z_TYPE_P(container) == IS_NULL ||
-		     (Z_TYPE_P(container) == IS_BOOL && Z_LVAL_P(container)==0) ||
-		     (Z_TYPE_P(container) == IS_STRING && Z_STRLEN_P(container)==0)))) {
+		     (Z_TYPE_P(container) == IS_BOOL && Z_IVAL_P(container)==0) ||
+		     (Z_TYPE_P(container) == IS_STRING && Z_STRSIZE_P(container)==0)))) {
 			if (!PZVAL_IS_REF(container)) {
 				SEPARATE_ZVAL(container_ptr);
 				container = *container_ptr;
@@ -1484,7 +1510,8 @@ ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, zend_fcall_i
 	} else {
 		zval **return_value_ptr = &EX_TMP_VAR(execute_data_ptr, execute_data_ptr->opline->result.var)->var.ptr;
 		execute_data_ptr->function_state.function->internal_function.handler(
-			execute_data_ptr->opline->extended_value, *return_value_ptr, return_value_ptr,
+			execute_data_ptr->opline->extended_value + execute_data_ptr->call->num_additional_args,
+			*return_value_ptr, return_value_ptr,
 			execute_data_ptr->object, return_value_used TSRMLS_CC
 		);
 	}
@@ -1601,7 +1628,7 @@ static zend_always_inline zend_execute_data *i_create_execute_data_from_op_array
 		/* Prepend the regular stack frame with a copy of prev_execute_data
 		 * and the passed arguments
 		 */
-		int args_count = zend_vm_stack_get_args_count_ex(EG(current_execute_data));
+		zend_size_t args_count = zend_vm_stack_get_args_count_ex(EG(current_execute_data));
 		size_t args_size = ZEND_MM_ALIGNED_SIZE(sizeof(zval*)) * (args_count + 1);
 
 		total_size += args_size + execute_data_size;
@@ -1686,7 +1713,7 @@ ZEND_API zend_execute_data *zend_create_execute_data_from_op_array(zend_op_array
 
 static zend_always_inline zend_bool zend_is_by_ref_func_arg_fetch(zend_op *opline, call_slot *call TSRMLS_DC) /* {{{ */
 {
-	zend_uint arg_num = (opline->extended_value & ZEND_FETCH_ARG_MASK) + call->num_additional_args;
+	zend_uint arg_num = opline->extended_value & ZEND_FETCH_ARG_MASK;
 	return ARG_SHOULD_BE_SENT_BY_REF(call->fbc, arg_num);
 }
 /* }}} */

Zend/zend_execute.h

@@ -37,7 +37,7 @@ typedef union _temp_variable {
 	struct {
 		zval **ptr_ptr; /* shared with var.ptr_ptr */
 		zval *str;
-		zend_uint offset;
+		zend_size_t offset;
 	} str_offset;
 	struct {
 		zval **ptr_ptr; /* shared with var.ptr_ptr */
@@ -60,16 +60,16 @@ ZEND_API zend_execute_data *zend_create_execute_data_from_op_array(zend_op_array
 ZEND_API void zend_execute(zend_op_array *op_array TSRMLS_DC);
 ZEND_API void execute_ex(zend_execute_data *execute_data TSRMLS_DC);
 ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, struct _zend_fcall_info *fci, int return_value_used TSRMLS_DC);
-ZEND_API int zend_is_true(zval *op);
-ZEND_API int zend_lookup_class(const char *name, int name_length, zend_class_entry ***ce TSRMLS_DC);
-ZEND_API int zend_lookup_class_ex(const char *name, int name_length, const zend_literal *key, int use_autoload, zend_class_entry ***ce TSRMLS_DC);
+ZEND_API int zend_is_true(zval *op TSRMLS_DC);
+ZEND_API int zend_lookup_class(const char *name, zend_size_t name_length, zend_class_entry ***ce TSRMLS_DC);
+ZEND_API int zend_lookup_class_ex(const char *name, zend_size_t name_length, const zend_literal *key, int use_autoload, zend_class_entry ***ce TSRMLS_DC);
 ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSRMLS_DC);
-ZEND_API int zend_eval_stringl(char *str, int str_len, zval *retval_ptr, char *string_name TSRMLS_DC);
+ZEND_API int zend_eval_stringl(char *str, zend_size_t str_len, zval *retval_ptr, char *string_name TSRMLS_DC);
 ZEND_API int zend_eval_string_ex(char *str, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC);
-ZEND_API int zend_eval_stringl_ex(char *str, int str_len, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC);
+ZEND_API int zend_eval_stringl_ex(char *str, zend_size_t str_len, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC);
 
-ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, ulong fetch_type, const char **class_name, zend_class_entry **pce TSRMLS_DC);
-ZEND_API int zend_verify_arg_error(int error_type, const zend_function *zf, zend_uint arg_num, const char *need_msg, const char *need_kind, const char *given_msg, const char *given_kind TSRMLS_DC);
+ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, zend_uint_t fetch_type, const char **class_name, zend_class_entry **pce TSRMLS_DC);
+ZEND_API int zend_verify_arg_error(int error_type, const zend_function *zf, zend_size_t arg_num, const char *need_msg, const char *need_kind, const char *given_msg, const char *given_kind TSRMLS_DC);
 
 static zend_always_inline void i_zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC TSRMLS_DC)
 {
@@ -101,7 +101,7 @@ static zend_always_inline void i_zval_ptr_dtor_nogc(zval *zval_ptr ZEND_FILE_LIN
 	}
 }
 
-static zend_always_inline int i_zend_is_true(zval *op)
+static zend_always_inline int i_zend_is_true(zval *op TSRMLS_DC)
 {
 	int result;
 
@@ -109,17 +109,17 @@ static zend_always_inline int i_zend_is_true(zval *op)
 		case IS_NULL:
 			result = 0;
 			break;
-		case IS_LONG:
+		case IS_INT:
 		case IS_BOOL:
 		case IS_RESOURCE:
-			result = (Z_LVAL_P(op)?1:0);
+			result = (Z_IVAL_P(op)?1:0);
 			break;
 		case IS_DOUBLE:
 			result = (Z_DVAL_P(op) ? 1 : 0);
 			break;
 		case IS_STRING:
-			if (Z_STRLEN_P(op) == 0
-				|| (Z_STRLEN_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) {
+			if (Z_STRSIZE_P(op) == 0
+				|| (Z_STRSIZE_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) {
 				result = 0;
 			} else {
 				result = 1;
@@ -130,12 +130,10 @@ static zend_always_inline int i_zend_is_true(zval *op)
 			break;
 		case IS_OBJECT:
 			if(IS_ZEND_STD_OBJECT(*op)) {
-				TSRMLS_FETCH();
-
 				if (Z_OBJ_HT_P(op)->cast_object) {
 					zval tmp;
 					if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, IS_BOOL TSRMLS_CC) == SUCCESS) {
-						result = Z_LVAL(tmp);
+						result = (int)Z_IVAL(tmp);
 						break;
 					}
 				} else if (Z_OBJ_HT_P(op)->get) {
@@ -143,7 +141,7 @@ static zend_always_inline int i_zend_is_true(zval *op)
 					if(Z_TYPE_P(tmp) != IS_OBJECT) {
 						/* for safety - avoid loop */
 						convert_to_boolean(tmp);
-						result = Z_LVAL_P(tmp);
+						result = (int)Z_IVAL_P(tmp);
 						zval_ptr_dtor(&tmp);
 						break;
 					}
@@ -158,10 +156,10 @@ static zend_always_inline int i_zend_is_true(zval *op)
 	return result;
 }
 
-ZEND_API int zval_update_constant(zval **pp, void *arg TSRMLS_DC);
-ZEND_API int zval_update_constant_inline_change(zval **pp, void *arg TSRMLS_DC);
-ZEND_API int zval_update_constant_no_inline_change(zval **pp, void *arg TSRMLS_DC);
-ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *scope TSRMLS_DC);
+ZEND_API int zval_update_constant(zval **pp, zend_bool inline_change TSRMLS_DC);
+ZEND_API int zval_update_constant_inline_change(zval **pp, zend_class_entry *scope TSRMLS_DC);
+ZEND_API int zval_update_constant_no_inline_change(zval **pp, zend_class_entry *scope TSRMLS_DC);
+ZEND_API int zval_update_constant_ex(zval **pp, zend_bool inline_change, zend_class_entry *scope TSRMLS_DC);
 
 /* dedicated Zend executor functions - do not use! */
 #define ZEND_VM_STACK_PAGE_SIZE ((16 * 1024) - 16)
@@ -183,7 +181,7 @@ struct _zend_vm_stack {
 		}															\
 	} while (0)
 
-static zend_always_inline zend_vm_stack zend_vm_stack_new_page(int count) {
+static zend_always_inline zend_vm_stack zend_vm_stack_new_page(size_t count) {
 	zend_vm_stack page = (zend_vm_stack)emalloc(ZEND_MM_ALIGNED_SIZE(sizeof(*page)) + sizeof(void*) * count);
 
 	page->top = ZEND_VM_STACK_ELEMETS(page);
@@ -208,7 +206,7 @@ static zend_always_inline void zend_vm_stack_destroy(TSRMLS_D)
 	}
 }
 
-static zend_always_inline void zend_vm_stack_extend(int count TSRMLS_DC)
+static zend_always_inline void zend_vm_stack_extend(size_t count TSRMLS_DC)
 {
 	zend_vm_stack p = zend_vm_stack_new_page(count >= ZEND_VM_STACK_PAGE_SIZE ? count : ZEND_VM_STACK_PAGE_SIZE);
 	p->prev = EG(argument_stack);
@@ -254,7 +252,7 @@ static zend_always_inline void *zend_vm_stack_alloc(size_t size TSRMLS_DC)
 			EG(argument_stack)->top += ZEND_MM_ALIGNED_SIZE(sizeof(void*)) / sizeof(void*);
 		}
 	} else {
-		ZEND_VM_STACK_GROW_IF_NEEDED((int)size);
+		ZEND_VM_STACK_GROW_IF_NEEDED(size);
 	}
 	ret = (void*)EG(argument_stack)->top;
 	EG(argument_stack)->top += size;
@@ -300,7 +298,7 @@ static zend_always_inline void zend_vm_stack_free(void *ptr TSRMLS_DC)
 static zend_always_inline void zend_vm_stack_clear_multiple(int nested TSRMLS_DC)
 {
 	void **p = EG(argument_stack)->top - 1;
- 	void **end = p - (int)(zend_uintptr_t)*p;
+ 	void **end = p - (ptrdiff_t)(zend_uintptr_t)*p;
 
 	while (p != end) {
 		zval *q = (zval *) *(--p);
@@ -314,20 +312,20 @@ static zend_always_inline void zend_vm_stack_clear_multiple(int nested TSRMLS_DC
 	}
 }
 
-static zend_always_inline int zend_vm_stack_get_args_count_ex(zend_execute_data *ex)
+static zend_always_inline zend_size_t zend_vm_stack_get_args_count_ex(zend_execute_data *ex)
 {
 	if (ex) {
 		void **p = ex->function_state.arguments;
-		return (int)(zend_uintptr_t) *p;
+		return (zend_size_t)(zend_uintptr_t) *p;
 	} else {
 		return 0;			
 	}
 }
 
-static zend_always_inline zval** zend_vm_stack_get_arg_ex(zend_execute_data *ex, int requested_arg)
+static zend_always_inline zval** zend_vm_stack_get_arg_ex(zend_execute_data *ex, zend_size_t requested_arg)
 {
 	void **p = ex->function_state.arguments;
-	int arg_count = (int)(zend_uintptr_t) *p;
+	zend_int_t arg_count = (zend_int_t)(zend_uintptr_t) *p;
 
 	if (UNEXPECTED(requested_arg > arg_count)) {
 		return NULL;
@@ -335,12 +333,12 @@ static zend_always_inline zval** zend_vm_stack_get_arg_ex(zend_execute_data *ex,
 	return (zval**)p - arg_count + requested_arg - 1;
 }
 
-static zend_always_inline int zend_vm_stack_get_args_count(TSRMLS_D)
+static zend_always_inline zend_size_t zend_vm_stack_get_args_count(TSRMLS_D)
 {
 	return zend_vm_stack_get_args_count_ex(EG(current_execute_data)->prev_execute_data);
 }
 
-static zend_always_inline zval** zend_vm_stack_get_arg(int requested_arg TSRMLS_DC)
+static zend_always_inline zval** zend_vm_stack_get_arg(zend_size_t requested_arg TSRMLS_DC)
 {
 	return zend_vm_stack_get_arg_ex(EG(current_execute_data)->prev_execute_data, requested_arg);
 }
@@ -352,16 +350,18 @@ void execute_new_code(TSRMLS_D);
 ZEND_API const char *get_active_class_name(const char **space TSRMLS_DC);
 ZEND_API const char *get_active_function_name(TSRMLS_D);
 ZEND_API const char *zend_get_executed_filename(TSRMLS_D);
-ZEND_API uint zend_get_executed_lineno(TSRMLS_D);
+ZEND_API zend_size_t zend_get_executed_lineno(TSRMLS_D);
 ZEND_API zend_bool zend_is_executing(TSRMLS_D);
 
-ZEND_API void zend_set_timeout(long seconds, int reset_signals);
+ZEND_API void zend_set_timeout(zend_int_t seconds, int reset_signals);
 ZEND_API void zend_unset_timeout(TSRMLS_D);
 ZEND_API void zend_timeout(int dummy);
-ZEND_API zend_class_entry *zend_fetch_class(const char *class_name, uint class_name_len, int fetch_type TSRMLS_DC);
-ZEND_API zend_class_entry *zend_fetch_class_by_name(const char *class_name, uint class_name_len, const zend_literal *key, int fetch_type TSRMLS_DC);
+ZEND_API zend_class_entry *zend_fetch_class(const char *class_name, zend_size_t class_name_len, int fetch_type TSRMLS_DC);
+ZEND_API zend_class_entry *zend_fetch_class_by_name(const char *class_name, zend_size_t class_name_len, const zend_literal *key, int fetch_type TSRMLS_DC);
 void zend_verify_abstract_class(zend_class_entry *ce TSRMLS_DC);
 
+ZEND_API void zend_fetch_dimension_by_zval(zval **result, zval *container, zval *dim TSRMLS_DC);
+
 #ifdef ZEND_WIN32
 void zend_init_timeout_thread(void);
 void zend_shutdown_timeout_thread(void);

Zend/zend_execute_API.c

@@ -401,7 +401,7 @@ ZEND_API const char *zend_get_executed_filename(TSRMLS_D) /* {{{ */
 }
 /* }}} */
 
-ZEND_API uint zend_get_executed_lineno(TSRMLS_D) /* {{{ */
+ZEND_API zend_size_t zend_get_executed_lineno(TSRMLS_D) /* {{{ */
 {
 	if(EG(exception) && EG(opline_ptr) && active_opline->opcode == ZEND_HANDLE_EXCEPTION &&
 		active_opline->lineno == 0 && EG(opline_before_exception)) {
@@ -443,36 +443,20 @@ ZEND_API void _zval_internal_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC) /* {{{
 }
 /* }}} */
 
-ZEND_API int zend_is_true(zval *op) /* {{{ */
+ZEND_API int zend_is_true(zval *op TSRMLS_DC) /* {{{ */
 {
-	return i_zend_is_true(op);
+	return i_zend_is_true(op TSRMLS_CC);
 }
 /* }}} */
 
-#include "../TSRM/tsrm_strtok_r.h"
-
-#define IS_VISITED_CONSTANT			IS_CONSTANT_INDEX
+#define IS_VISITED_CONSTANT			0x80
 #define IS_CONSTANT_VISITED(p)		(Z_TYPE_P(p) & IS_VISITED_CONSTANT)
 #define Z_REAL_TYPE_P(p)			(Z_TYPE_P(p) & ~IS_VISITED_CONSTANT)
 #define MARK_CONSTANT_VISITED(p)	Z_TYPE_P(p) |= IS_VISITED_CONSTANT
 
-static void zval_deep_copy(zval **p)
-{
-	zval *value;
-
-	ALLOC_ZVAL(value);
-	*value = **p;
-	Z_TYPE_P(value) &= ~IS_CONSTANT_INDEX;
-	zval_copy_ctor(value);
-	Z_TYPE_P(value) = Z_TYPE_PP(p);
-	INIT_PZVAL(value);
-	*p = value;
-}
-
-ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *scope TSRMLS_DC) /* {{{ */
+ZEND_API int zval_update_constant_ex(zval **pp, zend_bool inline_change, zend_class_entry *scope TSRMLS_DC) /* {{{ */
 {
 	zval *p = *pp;
-	zend_bool inline_change = (zend_bool) (zend_uintptr_t) arg;
 	zval const_value;
 	char *colon;
 
@@ -493,11 +477,11 @@ ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *sco
 		if (!zend_get_constant_ex(p->value.str.val, p->value.str.len, &const_value, scope, Z_REAL_TYPE_P(p) TSRMLS_CC)) {
 			char *actual = Z_STRVAL_P(p);
 
-			if ((colon = (char*)zend_memrchr(Z_STRVAL_P(p), ':', Z_STRLEN_P(p)))) {
+			if ((colon = (char*)zend_memrchr(Z_STRVAL_P(p), ':', Z_STRSIZE_P(p)))) {
 				zend_error(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(p));
-				Z_STRLEN_P(p) -= ((colon - Z_STRVAL_P(p)) + 1);
+				Z_STRSIZE_P(p) -= ((colon - Z_STRVAL_P(p)) + 1);
 				if (inline_change) {
-					colon = estrndup(colon, Z_STRLEN_P(p));
+					colon = estrndup(colon, Z_STRSIZE_P(p));
 					str_efree(Z_STRVAL_P(p));
 					Z_STRVAL_P(p) = colon;
 				} else {
@@ -505,20 +489,20 @@ ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *sco
 				}
 			} else {
 				char *save = actual, *slash;
-				int actual_len = Z_STRLEN_P(p);
+				zend_size_t actual_len = Z_STRSIZE_P(p);
 				if ((Z_TYPE_P(p) & IS_CONSTANT_UNQUALIFIED) && (slash = (char *)zend_memrchr(actual, '\\', actual_len))) {
 					actual = slash + 1;
 					actual_len -= (actual - Z_STRVAL_P(p));
 					if (inline_change) {
 						actual = estrndup(actual, actual_len);
 						Z_STRVAL_P(p) = actual;
-						Z_STRLEN_P(p) = actual_len;
+						Z_STRSIZE_P(p) = actual_len;
 					}
 				}
 				if (actual[0] == '\\') {
 					if (inline_change) {
-						memmove(Z_STRVAL_P(p), Z_STRVAL_P(p)+1, Z_STRLEN_P(p));
-						--Z_STRLEN_P(p);
+						memmove(Z_STRVAL_P(p), Z_STRVAL_P(p)+1, Z_STRSIZE_P(p));
+						--Z_STRSIZE_P(p);
 					} else {
 						++actual;
 					}
@@ -546,7 +530,7 @@ ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *sco
 				p->type = IS_STRING;
 				if (!inline_change) {
 					Z_STRVAL_P(p) = actual;
-					Z_STRLEN_P(p) = actual_len;
+					Z_STRSIZE_P(p) = actual_len;
 					zval_copy_ctor(p);
 				}
 			}
@@ -559,110 +543,6 @@ ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *sco
 
 		Z_SET_REFCOUNT_P(p, refcount);
 		Z_SET_ISREF_TO_P(p, is_ref);
-	} else if (Z_TYPE_P(p) == IS_CONSTANT_ARRAY) {
-		zval **element, *new_val;
-		char *str_index;
-		uint str_index_len;
-		ulong num_index;
-		int ret;
-
-		SEPARATE_ZVAL_IF_NOT_REF(pp);
-		p = *pp;
-		Z_TYPE_P(p) = IS_ARRAY;
-
-		if (!inline_change) {
-			zval *tmp;
-			HashTable *tmp_ht = NULL;
-
-			ALLOC_HASHTABLE(tmp_ht);
-			zend_hash_init(tmp_ht, zend_hash_num_elements(Z_ARRVAL_P(p)), NULL, ZVAL_PTR_DTOR, 0);
-			zend_hash_copy(tmp_ht, Z_ARRVAL_P(p), (copy_ctor_func_t) zval_deep_copy, (void *) &tmp, sizeof(zval *));
-			Z_ARRVAL_P(p) = tmp_ht;
-		}
-
-		/* First go over the array and see if there are any constant indices */
-		zend_hash_internal_pointer_reset(Z_ARRVAL_P(p));
-		while (zend_hash_get_current_data(Z_ARRVAL_P(p), (void **) &element) == SUCCESS) {
-			if (!(Z_TYPE_PP(element) & IS_CONSTANT_INDEX)) {
-				zend_hash_move_forward(Z_ARRVAL_P(p));
-				continue;
-			}
-			Z_TYPE_PP(element) &= ~IS_CONSTANT_INDEX;
-			if (zend_hash_get_current_key_ex(Z_ARRVAL_P(p), &str_index, &str_index_len, &num_index, 0, NULL) != HASH_KEY_IS_STRING) {
-				zend_hash_move_forward(Z_ARRVAL_P(p));
-				continue;
-			}
-			if (str_index[str_index_len - 2] == IS_CONSTANT_AST) {
-				zend_ast_evaluate(&const_value, *(zend_ast **)str_index, scope TSRMLS_CC);
-				zend_ast_destroy(*(zend_ast **)str_index);
-			} else if (!zend_get_constant_ex(str_index, str_index_len - 3, &const_value, scope, str_index[str_index_len - 2] TSRMLS_CC)) {
-				char *actual;
-				const char *save = str_index;
-				if ((colon = (char*)zend_memrchr(str_index, ':', str_index_len - 3))) {
-					zend_error(E_ERROR, "Undefined class constant '%s'", str_index);
-					str_index_len -= ((colon - str_index) + 1);
-					str_index = colon;
-				} else {
-					if (str_index[str_index_len - 2] & IS_CONSTANT_UNQUALIFIED) {
-						if ((actual = (char *)zend_memrchr(str_index, '\\', str_index_len - 3))) {
-							actual++;
-							str_index_len -= (actual - str_index);
-							str_index = actual;
-						}
-					}
-					if (str_index[0] == '\\') {
-						++str_index;
-						--str_index_len;
-					}
-					if (save[0] == '\\') {
-						++save;
-					}
-					if ((str_index[str_index_len - 2] & IS_CONSTANT_UNQUALIFIED) == 0) {
-						zend_error(E_ERROR, "Undefined constant '%s'", save);
-					}
-					zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",	str_index, str_index);
-				}
-				ZVAL_STRINGL(&const_value, str_index, str_index_len-3, 1);
-			}
-
-			if (Z_REFCOUNT_PP(element) > 1) {
-				ALLOC_ZVAL(new_val);
-				*new_val = **element;
-				zval_copy_ctor(new_val);
-				Z_SET_REFCOUNT_P(new_val, 1);
-				Z_UNSET_ISREF_P(new_val);
-
-				/* preserve this bit for inheritance */
-				Z_TYPE_PP(element) |= IS_CONSTANT_INDEX;
-				zval_ptr_dtor(element);
-				*element = new_val;
-			}
-
-			switch (Z_TYPE(const_value)) {
-				case IS_STRING:
-					ret = zend_symtable_update_current_key(Z_ARRVAL_P(p), Z_STRVAL(const_value), Z_STRLEN(const_value) + 1, HASH_UPDATE_KEY_IF_BEFORE);
-					break;
-				case IS_BOOL:
-				case IS_LONG:
-					ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_LONG, NULL, 0, Z_LVAL(const_value), HASH_UPDATE_KEY_IF_BEFORE, NULL);
-					break;
-				case IS_DOUBLE:
-					ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_LONG, NULL, 0, zend_dval_to_lval(Z_DVAL(const_value)), HASH_UPDATE_KEY_IF_BEFORE, NULL);
-					break;
-				case IS_NULL:
-					ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_STRING, "", 1, 0, HASH_UPDATE_KEY_IF_BEFORE, NULL);
-					break;
-				default:
-					ret = SUCCESS;
-					break;
-			}
-			if (ret == SUCCESS) {
-				zend_hash_move_forward(Z_ARRVAL_P(p));
-			}
-			zval_dtor(&const_value);
-		}
-		zend_hash_apply_with_argument(Z_ARRVAL_P(p), (apply_func_arg_t) zval_update_constant_inline_change, (void *) scope TSRMLS_CC);
-		zend_hash_internal_pointer_reset(Z_ARRVAL_P(p));
 	} else if (Z_TYPE_P(p) == IS_CONSTANT_AST) {
 		SEPARATE_ZVAL_IF_NOT_REF(pp);
 		p = *pp;
@@ -677,21 +557,21 @@ ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *sco
 }
 /* }}} */
 
-ZEND_API int zval_update_constant_inline_change(zval **pp, void *scope TSRMLS_DC) /* {{{ */
+ZEND_API int zval_update_constant_inline_change(zval **pp, zend_class_entry *scope TSRMLS_DC) /* {{{ */
 {
-	return zval_update_constant_ex(pp, (void*)1, scope TSRMLS_CC);
+	return zval_update_constant_ex(pp, 1, scope TSRMLS_CC);
 }
 /* }}} */
 
-ZEND_API int zval_update_constant_no_inline_change(zval **pp, void *scope TSRMLS_DC) /* {{{ */
+ZEND_API int zval_update_constant_no_inline_change(zval **pp, zend_class_entry *scope TSRMLS_DC) /* {{{ */
 {
-	return zval_update_constant_ex(pp, (void*)0, scope TSRMLS_CC);
+	return zval_update_constant_ex(pp, 0, scope TSRMLS_CC);
 }
 /* }}} */
 
-ZEND_API int zval_update_constant(zval **pp, void *arg TSRMLS_DC) /* {{{ */
+ZEND_API int zval_update_constant(zval **pp, zend_bool inline_change TSRMLS_DC) /* {{{ */
 {
-	return zval_update_constant_ex(pp, arg, NULL TSRMLS_CC);
+	return zval_update_constant_ex(pp, inline_change, NULL TSRMLS_CC);
 }
 /* }}} */
 
@@ -1023,24 +903,25 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
 }
 /* }}} */
 
-ZEND_API int zend_lookup_class_ex(const char *name, int name_length, const zend_literal *key, int use_autoload, zend_class_entry ***ce TSRMLS_DC) /* {{{ */
+ZEND_API int zend_lookup_class_ex(const char *name, zend_size_t name_length, const zend_literal *key, int use_autoload, zend_class_entry ***ce TSRMLS_DC) /* {{{ */
 {
 	zval **args[1];
 	zval autoload_function;
 	zval *class_name_ptr;
 	zval *retval_ptr = NULL;
-	int retval, lc_length;
+	int retval;
+	zend_size_t lc_length;
 	char *lc_name;
 	char *lc_free;
 	zend_fcall_info fcall_info;
 	zend_fcall_info_cache fcall_cache;
 	char dummy = 1;
-	ulong hash;
+	zend_uint_t hash;
 	ALLOCA_FLAG(use_heap)
 
 	if (key) {
 		lc_name = Z_STRVAL(key->constant);
-		lc_length = Z_STRLEN(key->constant) + 1;
+		lc_length = Z_STRSIZE(key->constant) + 1;
 		hash = key->hash_value;
 	} else {
 		if (name == NULL || !name_length) {
@@ -1148,13 +1029,13 @@ ZEND_API int zend_lookup_class_ex(const char *name, int name_length, const zend_
 }
 /* }}} */
 
-ZEND_API int zend_lookup_class(const char *name, int name_length, zend_class_entry ***ce TSRMLS_DC) /* {{{ */
+ZEND_API int zend_lookup_class(const char *name, zend_size_t name_length, zend_class_entry ***ce TSRMLS_DC) /* {{{ */
 {
 	return zend_lookup_class_ex(name, name_length, NULL, 1, ce TSRMLS_CC);
 }
 /* }}} */
 
-ZEND_API int zend_eval_stringl(char *str, int str_len, zval *retval_ptr, char *string_name TSRMLS_DC) /* {{{ */
+ZEND_API int zend_eval_stringl(char *str, zend_size_t str_len, zval *retval_ptr, char *string_name TSRMLS_DC) /* {{{ */
 {
 	zval pv;
 	zend_op_array *new_op_array;
@@ -1163,14 +1044,14 @@ ZEND_API int zend_eval_stringl(char *str, int str_len, zval *retval_ptr, char *s
 	int retval;
 
 	if (retval_ptr) {
-		Z_STRLEN(pv) = str_len + sizeof("return ;") - 1;
-		Z_STRVAL(pv) = emalloc(Z_STRLEN(pv) + 1);
+		Z_STRSIZE(pv) = str_len + sizeof("return ;") - 1;
+		Z_STRVAL(pv) = emalloc(Z_STRSIZE(pv) + 1);
 		memcpy(Z_STRVAL(pv), "return ", sizeof("return ") - 1);
 		memcpy(Z_STRVAL(pv) + sizeof("return ") - 1, str, str_len);
-		Z_STRVAL(pv)[Z_STRLEN(pv) - 1] = ';';
-		Z_STRVAL(pv)[Z_STRLEN(pv)] = '\0';
+		Z_STRVAL(pv)[Z_STRSIZE(pv) - 1] = ';';
+		Z_STRVAL(pv)[Z_STRSIZE(pv)] = '\0';
 	} else {
-		Z_STRLEN(pv) = str_len;
+		Z_STRSIZE(pv) = str_len;
 		Z_STRVAL(pv) = str;
 	}
 	Z_TYPE(pv) = IS_STRING;
@@ -1240,7 +1121,7 @@ ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSR
 }
 /* }}} */
 
-ZEND_API int zend_eval_stringl_ex(char *str, int str_len, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC) /* {{{ */
+ZEND_API int zend_eval_stringl_ex(char *str, zend_size_t str_len, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC) /* {{{ */
 {
 	int result;
 
@@ -1294,7 +1175,7 @@ void execute_new_code(TSRMLS_D) /* {{{ */
 		}
 		switch (opline->opcode) {
 			case ZEND_GOTO:
-				if (Z_TYPE_P(opline->op2.zv) != IS_LONG) {
+				if (Z_TYPE_P(opline->op2.zv) != IS_INT) {
 					zend_resolve_goto_label(CG(active_op_array), opline, 1 TSRMLS_CC);
 				}
 				/* break omitted intentionally */
@@ -1466,7 +1347,7 @@ void zend_shutdown_timeout_thread(void) /* {{{ */
 #define SIGPROF 27
 #endif
 
-void zend_set_timeout(long seconds, int reset_signals) /* {{{ */
+void zend_set_timeout(zend_int_t seconds, int reset_signals) /* {{{ */
 {
 	TSRMLS_FETCH();
 
@@ -1545,7 +1426,7 @@ void zend_unset_timeout(TSRMLS_D) /* {{{ */
 }
 /* }}} */
 
-zend_class_entry *zend_fetch_class(const char *class_name, uint class_name_len, int fetch_type TSRMLS_DC) /* {{{ */
+zend_class_entry *zend_fetch_class(const char *class_name, zend_size_t class_name_len, int fetch_type TSRMLS_DC) /* {{{ */
 {
 	zend_class_entry **pce;
 	int use_autoload = (fetch_type & ZEND_FETCH_CLASS_NO_AUTOLOAD) == 0;
@@ -1600,7 +1481,7 @@ check_fetch_type:
 }
 /* }}} */
 
-zend_class_entry *zend_fetch_class_by_name(const char *class_name, uint class_name_len, const zend_literal *key, int fetch_type TSRMLS_DC) /* {{{ */
+zend_class_entry *zend_fetch_class_by_name(const char *class_name, zend_size_t class_name_len, const zend_literal *key, int fetch_type TSRMLS_DC) /* {{{ */
 {
 	zend_class_entry **pce;
 	int use_autoload = (fetch_type & ZEND_FETCH_CLASS_NO_AUTOLOAD) == 0;
@@ -1695,7 +1576,7 @@ ZEND_API void zend_reset_all_cv(HashTable *symbol_table TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, const char *name, int name_len, ulong hash_value TSRMLS_DC) /* {{{ */
+ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, const char *name, zend_size_t name_len, zend_uint_t hash_value TSRMLS_DC) /* {{{ */
 {
 	if (zend_hash_quick_del(ht, name, name_len, hash_value) == SUCCESS) {
 		name_len--;
@@ -1718,7 +1599,7 @@ ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, const c
 }
 /* }}} */
 
-ZEND_API int zend_delete_global_variable_ex(const char *name, int name_len, ulong hash_value TSRMLS_DC) /* {{{ */
+ZEND_API int zend_delete_global_variable_ex(const char *name, zend_size_t name_len, zend_uint_t hash_value TSRMLS_DC) /* {{{ */
 {
 	zend_execute_data *ex;
 
@@ -1743,7 +1624,7 @@ ZEND_API int zend_delete_global_variable_ex(const char *name, int name_len, ulon
 }
 /* }}} */
 
-ZEND_API int zend_delete_global_variable(const char *name, int name_len TSRMLS_DC) /* {{{ */
+ZEND_API int zend_delete_global_variable(const char *name, zend_size_t name_len TSRMLS_DC) /* {{{ */
 {
 	return zend_delete_global_variable_ex(name, name_len, zend_inline_hash_func(name, name_len + 1) TSRMLS_CC);
 }

Zend/zend_extensions.c

@@ -24,7 +24,7 @@
 ZEND_API zend_llist zend_extensions;
 static int last_resource_number;
 
-int zend_load_extension(const char *path)
+int zend_load_extension(const char *path TSRMLS_DC)
 {
 #if ZEND_EXTENSIONS_SUPPORT
 	DL_HANDLE handle;
@@ -107,7 +107,7 @@ int zend_load_extension(const char *path)
 		return FAILURE;
 	}
 
-	return zend_register_extension(new_extension, handle);
+	return zend_register_extension(new_extension, handle TSRMLS_CC);
 #else
 	fprintf(stderr, "Extensions are not supported on this platform.\n");
 /* See http://support.microsoft.com/kb/190351 */
@@ -119,7 +119,7 @@ int zend_load_extension(const char *path)
 }
 
 
-int zend_register_extension(zend_extension *new_extension, DL_HANDLE handle)
+int zend_register_extension(zend_extension *new_extension, DL_HANDLE handle TSRMLS_DC)
 {
 #if ZEND_EXTENSIONS_SUPPORT
 	zend_extension extension;
@@ -127,7 +127,7 @@ int zend_register_extension(zend_extension *new_extension, DL_HANDLE handle)
 	extension = *new_extension;
 	extension.handle = handle;
 
-	zend_extension_dispatch_message(ZEND_EXTMSG_NEW_EXTENSION, &extension);
+	zend_extension_dispatch_message(ZEND_EXTMSG_NEW_EXTENSION, &extension TSRMLS_CC);
 
 	zend_llist_add_element(&zend_extensions, &extension);
 
@@ -208,10 +208,8 @@ static void zend_extension_message_dispatcher(const zend_extension *extension, i
 }
 
 
-ZEND_API void zend_extension_dispatch_message(int message, void *arg)
+ZEND_API void zend_extension_dispatch_message(int message, void *arg TSRMLS_DC)
 {
-	TSRMLS_FETCH();
-
 	zend_llist_apply_with_arguments(&zend_extensions, (llist_apply_with_args_func_t) zend_extension_message_dispatcher TSRMLS_CC, 2, message, arg);
 }
 

Zend/zend_extensions.h

@@ -28,7 +28,7 @@
 /* The first number is the engine version and the rest is the date.
  * This way engine 2/3 API no. is always greater than engine 1 API no..
  */
-#define ZEND_EXTENSION_API_NO	220131226
+#define ZEND_EXTENSION_API_NO	220131227
 
 typedef struct _zend_extension_version_info {
 	int zend_extension_api_no;
@@ -94,7 +94,7 @@ struct _zend_extension {
 
 BEGIN_EXTERN_C()
 ZEND_API int zend_get_resource_handle(zend_extension *extension);
-ZEND_API void zend_extension_dispatch_message(int message, void *arg);
+ZEND_API void zend_extension_dispatch_message(int message, void *arg TSRMLS_DC);
 END_EXTERN_C()
 
 #define ZEND_EXTMSG_NEW_EXTENSION		1
@@ -117,8 +117,8 @@ int zend_startup_extensions(void);
 void zend_shutdown_extensions(TSRMLS_D);
 
 BEGIN_EXTERN_C()
-ZEND_API int zend_load_extension(const char *path);
-ZEND_API int zend_register_extension(zend_extension *new_extension, DL_HANDLE handle);
+ZEND_API int zend_load_extension(const char *path TSRMLS_DC);
+ZEND_API int zend_register_extension(zend_extension *new_extension, DL_HANDLE handle TSRMLS_DC);
 ZEND_API zend_extension *zend_get_extension(const char *extension_name);
 END_EXTERN_C()
 

Zend/zend_generators.c

@@ -125,6 +125,7 @@ ZEND_API void zend_generator_close(zend_generator *generator, zend_bool finished
 		/* A fatal error / die occurred during the generator execution. Trying to clean
 		 * up the stack may not be safe in this case. */
 		if (CG(unclean_shutdown)) {
+			generator->execute_data = NULL;
 			return;
 		}
 

Zend/zend_generators.h

@@ -51,7 +51,7 @@ typedef struct _zend_generator {
 	/* Variable to put sent value into */
 	zval **send_target;
 	/* Largest used integer key for auto-incrementing keys */
-	long largest_used_integer_key;
+	zend_int_t largest_used_integer_key;
 
 	/* ZEND_GENERATOR_* flags */
 	zend_uchar flags;

Zend/zend_globals.h

@@ -87,7 +87,7 @@ struct _zend_compiler_globals {
 
 	char *compiled_filename;
 
-	int zend_lineno;
+	zend_uint_t zend_lineno;
 
 	zend_op_array *active_op_array;
 
@@ -111,7 +111,7 @@ struct _zend_compiler_globals {
 
 	zend_llist open_files;
 
-	long catch_begin;
+	zend_int_t catch_begin;
 
 	struct _zend_ini_parser_param *ini_parser_param;
 
@@ -188,8 +188,8 @@ struct _zend_executor_globals {
 
 	JMP_BUF *bailout;
 
-	int error_reporting;
-	int orig_error_reporting;
+	zend_int_t error_reporting;
+	zend_int_t orig_error_reporting;
 	int exit_status;
 
 	zend_op_array *active_op_array;
@@ -203,7 +203,7 @@ struct _zend_executor_globals {
 
 	zval *This;
 
-	long precision;
+	zend_int_t precision;
 
 	int ticks_count;
 
@@ -236,7 +236,7 @@ struct _zend_executor_globals {
 	zend_class_entry      *exception_class;
 
 	/* timeout support */
-	int timeout_seconds;
+	zend_int_t timeout_seconds;
 
 	int lambda_count;
 

Zend/zend_hash.c

@@ -29,18 +29,24 @@
 		(element)->pNext->pLast = (element);				\
 	}
 
-#define CONNECT_TO_GLOBAL_DLLIST(element, ht)				\
-	(element)->pListLast = (ht)->pListTail;					\
-	(ht)->pListTail = (element);							\
-	(element)->pListNext = NULL;							\
-	if ((element)->pListLast != NULL) {						\
-		(element)->pListLast->pListNext = (element);		\
-	}														\
-	if (!(ht)->pListHead) {									\
+#define CONNECT_TO_GLOBAL_DLLIST_EX(element, ht, last, next)\
+	(element)->pListLast = (last);							\
+	(element)->pListNext = (next);							\
+	if ((last) != NULL) {									\
+		(last)->pListNext = (element);						\
+	} else {												\
 		(ht)->pListHead = (element);						\
 	}														\
-	if ((ht)->pInternalPointer == NULL) {					\
-		(ht)->pInternalPointer = (element);					\
+	if ((next) != NULL) {									\
+		(next)->pListLast = (element);						\
+	} else {												\
+		(ht)->pListTail = (element);						\
+	}														\
+
+#define CONNECT_TO_GLOBAL_DLLIST(element, ht)									\
+	CONNECT_TO_GLOBAL_DLLIST_EX(element, ht, (ht)->pListTail, (Bucket *) NULL);	\
+	if ((ht)->pInternalPointer == NULL) {										\
+		(ht)->pInternalPointer = (element);										\
 	}
 
 #if ZEND_DEBUG
@@ -49,7 +55,7 @@
 #define HT_DESTROYED		2
 #define HT_CLEANING			3
 
-static void _zend_is_inconsistent(const HashTable *ht, const char *file, int line)
+static void _zend_is_inconsistent(const HashTable *ht, const char *file, zend_size_t line)
 {
 	if (ht->inconsistent==HT_OK) {
 		return;
@@ -98,7 +104,7 @@ static void _zend_is_inconsistent(const HashTable *ht, const char *file, int lin
 
 static void zend_hash_do_resize(HashTable *ht);
 
-ZEND_API ulong zend_hash_func(const char *arKey, uint nKeyLength)
+ZEND_API zend_uint_t zend_hash_func(const char *arKey, zend_size_t nKeyLength)
 {
 	return zend_inline_hash_func(arKey, nKeyLength);
 }
@@ -122,13 +128,13 @@ ZEND_API ulong zend_hash_func(const char *arKey, uint nKeyLength)
 		memcpy((p)->pData, pData, nDataSize);											\
 	}
 
-#define INIT_DATA(ht, p, pData, nDataSize);								\
+#define INIT_DATA(ht, p, _pData, nDataSize);								\
 	if (nDataSize == sizeof(void*)) {									\
-		memcpy(&(p)->pDataPtr, pData, sizeof(void *));					\
+		memcpy(&(p)->pDataPtr, (_pData), sizeof(void *));					\
 		(p)->pData = &(p)->pDataPtr;									\
 	} else {															\
 		(p)->pData = (void *) pemalloc_rel(nDataSize, (ht)->persistent);\
-		memcpy((p)->pData, pData, nDataSize);							\
+		memcpy((p)->pData, (_pData), nDataSize);							\
 		(p)->pDataPtr=NULL;												\
 	}
 
@@ -141,20 +147,65 @@ ZEND_API ulong zend_hash_func(const char *arKey, uint nKeyLength)
  
 static const Bucket *uninitialized_bucket = NULL;
 
-ZEND_API int _zend_hash_init(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC)
+static zend_always_inline void i_zend_hash_bucket_delete(HashTable *ht, Bucket *p)
 {
-	uint i = 3;
+#ifdef ZEND_SIGNALS
+	TSRMLS_FETCH();
+#endif
+
+	HANDLE_BLOCK_INTERRUPTIONS();
+	if (p->pLast) {
+		p->pLast->pNext = p->pNext;
+	} else {
+		ht->arBuckets[p->h & ht->nTableMask] = p->pNext;
+	}
+	if (p->pNext) {
+		p->pNext->pLast = p->pLast;
+	}
+	if (p->pListLast != NULL) {
+		p->pListLast->pListNext = p->pListNext;
+	} else { 
+		/* Deleting the head of the list */
+		ht->pListHead = p->pListNext;
+	}
+	if (p->pListNext != NULL) {
+		p->pListNext->pListLast = p->pListLast;
+	} else {
+		/* Deleting the tail of the list */
+		ht->pListTail = p->pListLast;
+	}
+	if (ht->pInternalPointer == p) {
+		ht->pInternalPointer = p->pListNext;
+	}
+	ht->nNumOfElements--;
+	if (ht->pDestructor) {
+		ht->pDestructor(p->pData);
+	}
+	if (p->pData != &p->pDataPtr) {
+		pefree(p->pData, ht->persistent);
+	}
+	pefree(p, ht->persistent);
+	HANDLE_UNBLOCK_INTERRUPTIONS();
+}
+
+static void zend_hash_bucket_delete(HashTable *ht, Bucket *p) {
+	i_zend_hash_bucket_delete(ht, p);
+}
+
+ZEND_API int _zend_hash_init(HashTable *ht, zend_uint_t nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC)
+{
+	zend_uint_t i = 3;
 
 	SET_INCONSISTENT(HT_OK);
 
-	if (nSize >= 0x80000000) {
+	if (nSize >= ZEND_INT_MAX) {
 		/* prevent overflow */
-		ht->nTableSize = 0x80000000;
+		ht->nTableSize = ZEND_INT_MAX;
 	} else {
-		while ((1U << i) < nSize) {
+		while ((Z_UI(1) << i) < nSize) {
 			i++;
 		}
-		ht->nTableSize = 1 << i;
+		ht->nTableSize = Z_UI(1) << i;
 	}
 
 	ht->nTableMask = 0;	/* 0 means that ht->arBuckets is uninitialized */
@@ -172,7 +223,7 @@ ZEND_API int _zend_hash_init(HashTable *ht, uint nSize, dtor_func_t pDestructor,
 }
 
 
-ZEND_API int _zend_hash_init_ex(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC)
+ZEND_API int _zend_hash_init_ex(HashTable *ht, zend_uint_t nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC)
 {
 	int retval = _zend_hash_init(ht, nSize, pDestructor, persistent ZEND_FILE_LINE_CC);
 
@@ -188,10 +239,10 @@ ZEND_API void zend_hash_set_apply_protection(HashTable *ht, zend_bool bApplyProt
 
 
 
-ZEND_API int _zend_hash_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
+ZEND_API int _zend_hash_add_or_update(HashTable *ht, const char *arKey, zend_size_t nKeyLength, void *pData, zend_uint_t nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
 {
-	ulong h;
-	uint nIndex;
+	zend_uint_t h;
+	zend_uint_t nIndex;
 	Bucket *p;
 #ifdef ZEND_SIGNALS
 	TSRMLS_FETCH();
@@ -254,9 +305,9 @@ ZEND_API int _zend_hash_add_or_update(HashTable *ht, const char *arKey, uint nKe
 	return SUCCESS;
 }
 
-ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
+ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, zend_size_t nKeyLength, zend_uint_t h, void *pData, zend_uint_t nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
 {
-	uint nIndex;
+	zend_uint_t nIndex;
 	Bucket *p;
 #ifdef ZEND_SIGNALS
 	TSRMLS_FETCH();
@@ -321,7 +372,7 @@ ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, ui
 }
 
 
-ZEND_API int zend_hash_add_empty_element(HashTable *ht, const char *arKey, uint nKeyLength)
+ZEND_API int zend_hash_add_empty_element(HashTable *ht, const char *arKey, zend_size_t nKeyLength)
 {
 	void *dummy = (void *) 1;
 
@@ -329,9 +380,9 @@ ZEND_API int zend_hash_add_empty_element(HashTable *ht, const char *arKey, uint
 }
 
 
-ZEND_API int _zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
+ZEND_API int _zend_hash_index_update_or_next_insert(HashTable *ht, zend_uint_t h, void *pData, zend_uint_t nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
 {
-	uint nIndex;
+	zend_uint_t nIndex;
 	Bucket *p;
 #ifdef ZEND_SIGNALS
 	TSRMLS_FETCH();
@@ -358,9 +409,6 @@ ZEND_API int _zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void
 			}
 			UPDATE_DATA(ht, p, pData, nDataSize);
 			HANDLE_UNBLOCK_INTERRUPTIONS();
-			if ((long)h >= (long)ht->nNextFreeElement) {
-				ht->nNextFreeElement = h < LONG_MAX ? h + 1 : LONG_MAX;
-			}
 			if (pDest) {
 				*pDest = p->pData;
 			}
@@ -384,8 +432,8 @@ ZEND_API int _zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void
 	CONNECT_TO_GLOBAL_DLLIST(p, ht);
 	HANDLE_UNBLOCK_INTERRUPTIONS();
 
-	if ((long)h >= (long)ht->nNextFreeElement) {
-		ht->nNextFreeElement = h < LONG_MAX ? h + 1 : LONG_MAX;
+	if ((zend_int_t)h >= (zend_int_t)ht->nNextFreeElement) {
+		ht->nNextFreeElement = h < ZEND_INT_MAX ? h + 1 : ZEND_INT_MAX;
 	}
 	ht->nNumOfElements++;
 	ZEND_HASH_IF_FULL_DO_RESIZE(ht);
@@ -416,7 +464,7 @@ static void zend_hash_do_resize(HashTable *ht)
 ZEND_API int zend_hash_rehash(HashTable *ht)
 {
 	Bucket *p;
-	uint nIndex;
+	zend_uint_t nIndex;
 
 	IS_CONSISTENT(ht);
 	if (UNEXPECTED(ht->nNumOfElements == 0)) {
@@ -424,23 +472,43 @@ ZEND_API int zend_hash_rehash(HashTable *ht)
 	}
 
 	memset(ht->arBuckets, 0, ht->nTableSize * sizeof(Bucket *));
-	p = ht->pListHead;
-	while (p != NULL) {
+	for (p = ht->pListHead; p != NULL; p = p->pListNext) {
 		nIndex = p->h & ht->nTableMask;
 		CONNECT_TO_BUCKET_DLLIST(p, ht->arBuckets[nIndex]);
 		ht->arBuckets[nIndex] = p;
-		p = p->pListNext;
 	}
 	return SUCCESS;
 }
 
-ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, int flag)
+ZEND_API void zend_hash_reindex(HashTable *ht, zend_bool only_integer_keys) {
+	Bucket *p;
+	zend_uint_t nIndex;
+	zend_uint_t offset = 0;
+
+	IS_CONSISTENT(ht);
+	if (UNEXPECTED(ht->nNumOfElements == 0)) {
+		ht->nNextFreeElement = 0;
+		return;
+	}
+
+	memset(ht->arBuckets, 0, ht->nTableSize * sizeof(Bucket *));
+	for (p = ht->pListHead; p != NULL; p = p->pListNext) {
+		if (!only_integer_keys || p->nKeyLength == 0) {
+			p->h = offset++;
+			p->nKeyLength = 0;
+		}
+
+		nIndex = p->h & ht->nTableMask;
+		CONNECT_TO_BUCKET_DLLIST(p, ht->arBuckets[nIndex]);
+		ht->arBuckets[nIndex] = p;
+	}
+	ht->nNextFreeElement = offset;
+}
+
+ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, zend_size_t nKeyLength, zend_uint_t h, int flag)
 {
-	uint nIndex;
+	zend_uint_t nIndex;
 	Bucket *p;
-#ifdef ZEND_SIGNALS
-	TSRMLS_FETCH();
-#endif
 
 	IS_CONSISTENT(ht);
 
@@ -455,38 +523,7 @@ ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, uint n
 			 && (p->nKeyLength == nKeyLength)
 			 && ((p->nKeyLength == 0) /* Numeric index (short circuits the memcmp() check) */
 				 || !memcmp(p->arKey, arKey, nKeyLength))) { /* String index */
-			HANDLE_BLOCK_INTERRUPTIONS();
-			if (p == ht->arBuckets[nIndex]) {
-				ht->arBuckets[nIndex] = p->pNext;
-			} else {
-				p->pLast->pNext = p->pNext;
-			}
-			if (p->pNext) {
-				p->pNext->pLast = p->pLast;
-			}
-			if (p->pListLast != NULL) {
-				p->pListLast->pListNext = p->pListNext;
-			} else { 
-				/* Deleting the head of the list */
-				ht->pListHead = p->pListNext;
-			}
-			if (p->pListNext != NULL) {
-				p->pListNext->pListLast = p->pListLast;
-			} else {
-				ht->pListTail = p->pListLast;
-			}
-			if (ht->pInternalPointer == p) {
-				ht->pInternalPointer = p->pListNext;
-			}
-			ht->nNumOfElements--;
-			if (ht->pDestructor) {
-				ht->pDestructor(p->pData);
-			}
-			if (p->pData != &p->pDataPtr) {
-				pefree(p->pData, ht->persistent);
-			}
-			pefree(p, ht->persistent);
-			HANDLE_UNBLOCK_INTERRUPTIONS();
+			i_zend_hash_bucket_delete(ht, p);
 			return SUCCESS;
 		}
 		p = p->pNext;
@@ -553,73 +590,14 @@ ZEND_API void zend_hash_clean(HashTable *ht)
 	}
 }
 
-/* This function is used by the various apply() functions.
- * It deletes the passed bucket, and returns the address of the
- * next bucket.  The hash *may* be altered during that time, the
- * returned value will still be valid.
- */
-static Bucket *zend_hash_apply_deleter(HashTable *ht, Bucket *p)
-{
-	Bucket *retval;
-#ifdef ZEND_SIGNALS
-	TSRMLS_FETCH();
-#endif
-
-	HANDLE_BLOCK_INTERRUPTIONS();
-	if (p->pLast) {
-		p->pLast->pNext = p->pNext;
-	} else {
-		uint nIndex;
-
-		nIndex = p->h & ht->nTableMask;
-		ht->arBuckets[nIndex] = p->pNext;
-	}
-	if (p->pNext) {
-		p->pNext->pLast = p->pLast;
-	} else {
-		/* Nothing to do as this list doesn't have a tail */
-	}
-
-	if (p->pListLast != NULL) {
-		p->pListLast->pListNext = p->pListNext;
-	} else { 
-		/* Deleting the head of the list */
-		ht->pListHead = p->pListNext;
-	}
-	if (p->pListNext != NULL) {
-		p->pListNext->pListLast = p->pListLast;
-	} else {
-		ht->pListTail = p->pListLast;
-	}
-	if (ht->pInternalPointer == p) {
-		ht->pInternalPointer = p->pListNext;
-	}
-	ht->nNumOfElements--;
-	HANDLE_UNBLOCK_INTERRUPTIONS();
-
-	if (ht->pDestructor) {
-		ht->pDestructor(p->pData);
-	}
-	if (p->pData != &p->pDataPtr) {
-		pefree(p->pData, ht->persistent);
-	}
-	retval = p->pListNext;
-	pefree(p, ht->persistent);
-
-	return retval;
-}
-
-
 ZEND_API void zend_hash_graceful_destroy(HashTable *ht)
 {
-	Bucket *p;
-
 	IS_CONSISTENT(ht);
 
-	p = ht->pListHead;
-	while (p != NULL) {
-		p = zend_hash_apply_deleter(ht, p);
+	while (ht->pListHead != NULL) {
+		zend_hash_bucket_delete(ht, ht->pListHead);
 	}
+
 	if (ht->nTableMask) {
 		pefree(ht->arBuckets, ht->persistent);
 	}
@@ -629,14 +607,10 @@ ZEND_API void zend_hash_graceful_destroy(HashTable *ht)
 
 ZEND_API void zend_hash_graceful_reverse_destroy(HashTable *ht)
 {
-	Bucket *p;
-
 	IS_CONSISTENT(ht);
 
-	p = ht->pListTail;
-	while (p != NULL) {
-		zend_hash_apply_deleter(ht, p);
-		p = ht->pListTail;
+	while (ht->pListTail != NULL) {
+		zend_hash_bucket_delete(ht, ht->pListTail);
 	}
 
 	if (ht->nTableMask) {
@@ -665,12 +639,13 @@ ZEND_API void zend_hash_apply(HashTable *ht, apply_func_t apply_func TSRMLS_DC)
 	p = ht->pListHead;
 	while (p != NULL) {
 		int result = apply_func(p->pData TSRMLS_CC);
-		
+
+		Bucket *p_next = p->pListNext;
 		if (result & ZEND_HASH_APPLY_REMOVE) {
-			p = zend_hash_apply_deleter(ht, p);
-		} else {
-			p = p->pListNext;
+			zend_hash_bucket_delete(ht, p);
 		}
+		p = p_next;
+
 		if (result & ZEND_HASH_APPLY_STOP) {
 			break;
 		}
@@ -690,11 +665,12 @@ ZEND_API void zend_hash_apply_with_argument(HashTable *ht, apply_func_arg_t appl
 	while (p != NULL) {
 		int result = apply_func(p->pData, argument TSRMLS_CC);
 		
+		Bucket *p_next = p->pListNext;
 		if (result & ZEND_HASH_APPLY_REMOVE) {
-			p = zend_hash_apply_deleter(ht, p);
-		} else {
-			p = p->pListNext;
+			zend_hash_bucket_delete(ht, p);
 		}
+		p = p_next;
+
 		if (result & ZEND_HASH_APPLY_STOP) {
 			break;
 		}
@@ -716,17 +692,20 @@ ZEND_API void zend_hash_apply_with_arguments(HashTable *ht TSRMLS_DC, apply_func
 	p = ht->pListHead;
 	while (p != NULL) {
 		int result;
+		Bucket *p_next;
+
 		va_start(args, num_args);
 		hash_key.arKey = p->arKey;
 		hash_key.nKeyLength = p->nKeyLength;
 		hash_key.h = p->h;
 		result = apply_func(p->pData TSRMLS_CC, num_args, args, &hash_key);
 
+		p_next = p->pListNext;
 		if (result & ZEND_HASH_APPLY_REMOVE) {
-			p = zend_hash_apply_deleter(ht, p);
-		} else {
-			p = p->pListNext;
+			zend_hash_bucket_delete(ht, p);
 		}
+		p = p_next;
+
 		if (result & ZEND_HASH_APPLY_STOP) {
 			va_end(args);
 			break;
@@ -740,7 +719,7 @@ ZEND_API void zend_hash_apply_with_arguments(HashTable *ht TSRMLS_DC, apply_func
 
 ZEND_API void zend_hash_reverse_apply(HashTable *ht, apply_func_t apply_func TSRMLS_DC)
 {
-	Bucket *p, *q;
+	Bucket *p;
 
 	IS_CONSISTENT(ht);
 
@@ -749,11 +728,12 @@ ZEND_API void zend_hash_reverse_apply(HashTable *ht, apply_func_t apply_func TSR
 	while (p != NULL) {
 		int result = apply_func(p->pData TSRMLS_CC);
 
-		q = p;
-		p = p->pListLast;
+		Bucket *p_last = p->pListLast;
 		if (result & ZEND_HASH_APPLY_REMOVE) {
-			zend_hash_apply_deleter(ht, q);
+			zend_hash_bucket_delete(ht, p);
 		}
+		p = p_last;
+
 		if (result & ZEND_HASH_APPLY_STOP) {
 			break;
 		}
@@ -762,7 +742,7 @@ ZEND_API void zend_hash_reverse_apply(HashTable *ht, apply_func_t apply_func TSR
 }
 
 
-ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size)
+ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, zend_uint_t size)
 {
 	Bucket *p;
 	void *new_entry;
@@ -793,7 +773,7 @@ ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_fun
 }
 
 
-ZEND_API void _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite ZEND_FILE_LINE_DC)
+ZEND_API void _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, zend_uint_t size, int overwrite ZEND_FILE_LINE_DC)
 {
 	Bucket *p;
 	void *t;
@@ -830,7 +810,7 @@ static zend_bool zend_hash_replace_checker_wrapper(HashTable *target, void *sour
 }
 
 
-ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, uint size, merge_checker_func_t pMergeSource, void *pParam)
+ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, zend_uint_t size, merge_checker_func_t pMergeSource, void *pParam)
 {
 	Bucket *p;
 	void *t;
@@ -855,10 +835,10 @@ ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor
  * data is returned in pData. The reason is that there's no reason
  * someone using the hash table might not want to have NULL data
  */
-ZEND_API int zend_hash_find(const HashTable *ht, const char *arKey, uint nKeyLength, void **pData)
+ZEND_API int zend_hash_find(const HashTable *ht, const char *arKey, zend_size_t nKeyLength, void **pData)
 {
-	ulong h;
-	uint nIndex;
+	zend_uint_t h;
+	zend_uint_t nIndex;
 	Bucket *p;
 
 	IS_CONSISTENT(ht);
@@ -879,9 +859,9 @@ ZEND_API int zend_hash_find(const HashTable *ht, const char *arKey, uint nKeyLen
 }
 
 
-ZEND_API int zend_hash_quick_find(const HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void **pData)
+ZEND_API int zend_hash_quick_find(const HashTable *ht, const char *arKey, zend_size_t nKeyLength, zend_uint_t h, void **pData)
 {
-	uint nIndex;
+	zend_uint_t nIndex;
 	Bucket *p;
 
 	ZEND_ASSERT(nKeyLength != 0);
@@ -903,10 +883,10 @@ ZEND_API int zend_hash_quick_find(const HashTable *ht, const char *arKey, uint n
 }
 
 
-ZEND_API int zend_hash_exists(const HashTable *ht, const char *arKey, uint nKeyLength)
+ZEND_API int zend_hash_exists(const HashTable *ht, const char *arKey, zend_size_t nKeyLength)
 {
-	ulong h;
-	uint nIndex;
+	zend_uint_t h;
+	zend_uint_t nIndex;
 	Bucket *p;
 
 	IS_CONSISTENT(ht);
@@ -926,9 +906,9 @@ ZEND_API int zend_hash_exists(const HashTable *ht, const char *arKey, uint nKeyL
 }
 
 
-ZEND_API int zend_hash_quick_exists(const HashTable *ht, const char *arKey, uint nKeyLength, ulong h)
+ZEND_API int zend_hash_quick_exists(const HashTable *ht, const char *arKey, zend_size_t nKeyLength, zend_uint_t h)
 {
-	uint nIndex;
+	zend_uint_t nIndex;
 	Bucket *p;
 
 	ZEND_ASSERT(nKeyLength != 0);
@@ -950,9 +930,9 @@ ZEND_API int zend_hash_quick_exists(const HashTable *ht, const char *arKey, uint
 }
 
 
-ZEND_API int zend_hash_index_find(const HashTable *ht, ulong h, void **pData)
+ZEND_API int zend_hash_index_find(const HashTable *ht, zend_uint_t h, void **pData)
 {
-	uint nIndex;
+	zend_uint_t nIndex;
 	Bucket *p;
 
 	IS_CONSISTENT(ht);
@@ -971,9 +951,9 @@ ZEND_API int zend_hash_index_find(const HashTable *ht, ulong h, void **pData)
 }
 
 
-ZEND_API int zend_hash_index_exists(const HashTable *ht, ulong h)
+ZEND_API int zend_hash_index_exists(const HashTable *ht, zend_uint_t h)
 {
-	uint nIndex;
+	zend_uint_t nIndex;
 	Bucket *p;
 
 	IS_CONSISTENT(ht);
@@ -991,7 +971,7 @@ ZEND_API int zend_hash_index_exists(const HashTable *ht, ulong h)
 }
 
 
-ZEND_API int zend_hash_num_elements(const HashTable *ht)
+ZEND_API zend_uint_t zend_hash_num_elements(const HashTable *ht)
 {
 	IS_CONSISTENT(ht);
 
@@ -1085,7 +1065,7 @@ ZEND_API int zend_hash_move_backwards_ex(HashTable *ht, HashPosition *pos)
 
 
 /* This function should be made binary safe  */
-ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, char **str_index, uint *str_length, ulong *num_index, zend_bool duplicate, HashPosition *pos)
+ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, char **str_index, zend_size_t *str_length, zend_uint_t *num_index, zend_bool duplicate, HashPosition *pos)
 {
 	Bucket *p;
 
@@ -1106,7 +1086,7 @@ ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, char **str_index,
 			return HASH_KEY_IS_STRING;
 		} else {
 			*num_index = p->h;
-			return HASH_KEY_IS_LONG;
+			return HASH_KEY_IS_INT;
 		}
 	}
 	return HASH_KEY_NON_EXISTENT;
@@ -1124,10 +1104,10 @@ ZEND_API void zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key,
 	} else if (p->nKeyLength) {
 		Z_TYPE_P(key) = IS_STRING;
 		Z_STRVAL_P(key) = IS_INTERNED(p->arKey) ? (char*)p->arKey : estrndup(p->arKey, p->nKeyLength - 1);
-		Z_STRLEN_P(key) = p->nKeyLength - 1;
+		Z_STRSIZE_P(key) = p->nKeyLength - 1;
 	} else {
-		Z_TYPE_P(key) = IS_LONG;
-		Z_LVAL_P(key) = p->h;
+		Z_TYPE_P(key) = IS_INT;
+		Z_IVAL_P(key) = p->h;
 	}
 }
 
@@ -1143,7 +1123,7 @@ ZEND_API int zend_hash_get_current_key_type_ex(HashTable *ht, HashPosition *pos)
 		if (p->nKeyLength) {
 			return HASH_KEY_IS_STRING;
 		} else {
-			return HASH_KEY_IS_LONG;
+			return HASH_KEY_IS_INT;
 		}
 	}
 	return HASH_KEY_NON_EXISTENT;
@@ -1169,10 +1149,10 @@ ZEND_API int zend_hash_get_current_data_ex(HashTable *ht, void **pData, HashPosi
 /* This function changes key of current element without changing elements'
  * order. If element with target key already exists, it will be deleted first.
  */
-ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const char *str_index, uint str_length, ulong num_index, int mode, HashPosition *pos)
+ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const char *str_index, zend_size_t str_length, zend_uint_t num_index, int mode, HashPosition *pos)
 {
 	Bucket *p, *q;
-	ulong h;
+	zend_uint_t h;
 #ifdef ZEND_SIGNALS
 	TSRMLS_FETCH();
 #endif
@@ -1182,7 +1162,7 @@ ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const
 	IS_CONSISTENT(ht);
 
 	if (p) {
-		if (key_type == HASH_KEY_IS_LONG) {
+		if (key_type == HASH_KEY_IS_INT) {
 			str_length = 0;
 			if (!p->nKeyLength && p->h == num_index) {
 				return SUCCESS;
@@ -1223,8 +1203,6 @@ ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const
 			return FAILURE;
 		}
 
-		HANDLE_BLOCK_INTERRUPTIONS();
-
 		if (q) {
 			if (mode != HASH_UPDATE_KEY_ANYWAY) {
 				Bucket *r = p->pListLast;
@@ -1239,73 +1217,17 @@ ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const
 				}
 				if (mode & found) {
 					/* delete current bucket */
-					if (p == ht->arBuckets[p->h & ht->nTableMask]) {
-						ht->arBuckets[p->h & ht->nTableMask] = p->pNext;
-					} else {
-						p->pLast->pNext = p->pNext;
-					}
-					if (p->pNext) {
-						p->pNext->pLast = p->pLast;
-					}
-					if (p->pListLast != NULL) {
-						p->pListLast->pListNext = p->pListNext;
-					} else {
-						/* Deleting the head of the list */
-						ht->pListHead = p->pListNext;
-					}
-					if (p->pListNext != NULL) {
-						p->pListNext->pListLast = p->pListLast;
-					} else {
-						ht->pListTail = p->pListLast;
-					}
-					if (ht->pInternalPointer == p) {
-						ht->pInternalPointer = p->pListNext;
-					}
-					ht->nNumOfElements--;
-					if (ht->pDestructor) {
-						ht->pDestructor(p->pData);
-					}
-					if (p->pData != &p->pDataPtr) {
-						pefree(p->pData, ht->persistent);
-					}
-					pefree(p, ht->persistent);
-					HANDLE_UNBLOCK_INTERRUPTIONS();
+					zend_hash_bucket_delete(ht, p);
 					return FAILURE;
 				}
 			}
+
 			/* delete another bucket with the same key */
-			if (q == ht->arBuckets[q->h & ht->nTableMask]) {
-				ht->arBuckets[q->h & ht->nTableMask] = q->pNext;
-			} else {
-				q->pLast->pNext = q->pNext;
-			}
-			if (q->pNext) {
-				q->pNext->pLast = q->pLast;
-			}
-			if (q->pListLast != NULL) {
-				q->pListLast->pListNext = q->pListNext;
-			} else {
-				/* Deleting the head of the list */
-				ht->pListHead = q->pListNext;
-			}
-			if (q->pListNext != NULL) {
-				q->pListNext->pListLast = q->pListLast;
-			} else {
-				ht->pListTail = q->pListLast;
-			}
-			if (ht->pInternalPointer == q) {
-				ht->pInternalPointer = q->pListNext;
-			}
-			ht->nNumOfElements--;
-			if (ht->pDestructor) {
-				ht->pDestructor(q->pData);
-			}
-			if (q->pData != &q->pDataPtr) {
-				pefree(q->pData, ht->persistent);
-			}
-			pefree(q, ht->persistent);
+			zend_hash_bucket_delete(ht, q);
 		}
 
+		HANDLE_BLOCK_INTERRUPTIONS();
+
 		if (p->pNext) {
 			p->pNext->pLast = p->pLast;
 		}
@@ -1332,21 +1254,12 @@ ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const
 				q->pData = p->pData;
 			}
 			q->pDataPtr = p->pDataPtr;
-			q->pListNext = p->pListNext;
-			q->pListLast = p->pListLast;
-			if (q->pListNext) {
-				p->pListNext->pListLast = q;
-			} else {
-				ht->pListTail = q;
-			}
-			if (q->pListLast) {
-				p->pListLast->pListNext = q;
-			} else {
-				ht->pListHead = q;
-			}
+
+			CONNECT_TO_GLOBAL_DLLIST_EX(q, ht, p->pListLast, p->pListNext);
 			if (ht->pInternalPointer == p) {
 				ht->pInternalPointer = q;
 			}
+
 			if (pos) {
 				*pos = q;
 			}
@@ -1354,7 +1267,7 @@ ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const
 			p = q;
 		}
 
-		if (key_type == HASH_KEY_IS_LONG) {
+		if (key_type == HASH_KEY_IS_INT) {
 			p->h = num_index;
 		} else {
 			p->h = h;
@@ -1377,6 +1290,75 @@ ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const
 	}
 }
 
+/* Performs an in-place splice operation on a hashtable:
+ * The elements between offset and offset+length are removed and the elements in list[list_count]
+ * are inserted in their place. The removed elements can be optionally collected into a hashtable.
+ * This operation reindexes the hashtable, i.e. integer keys will be zero-based and sequential,
+ * while string keys stay intact. The same applies to the elements inserted into the removed HT. */
+ZEND_API void _zend_hash_splice(HashTable *ht, zend_uint_t nDataSize, copy_ctor_func_t pCopyConstructor, zend_uint_t offset, zend_size_t length, void **list, zend_size_t list_count, HashTable *removed ZEND_FILE_LINE_DC) /* {{{ */
+{
+	zend_size_t pos;
+	Bucket *p;
+
+	IS_CONSISTENT(ht);
+	CHECK_INIT(ht);
+
+	/* Skip all elements until offset */
+	for (pos = 0, p = ht->pListHead; pos < offset && p; pos++, p = p->pListNext);
+
+	while (pos < offset + length && p) {
+		/* Copy removed element into HT, if it was specified */
+		if (removed != NULL) {
+			void *new_entry;
+
+			if (p->nKeyLength == 0) {
+				zend_hash_next_index_insert(removed, p->pData, sizeof(zval *), &new_entry);
+			} else {
+				zend_hash_quick_update(removed, p->arKey, p->nKeyLength, p->h, p->pData, sizeof(zval *), &new_entry);
+			}
+
+			if (pCopyConstructor) {
+				pCopyConstructor(new_entry);
+			}
+		}
+
+		/* Remove element */
+		{
+			Bucket *p_next = p->pListNext;	
+			zend_hash_bucket_delete(ht, p);
+			p = p_next;
+		}
+
+		pos++;
+	}
+
+	if (list != NULL) {
+		zend_size_t i;
+		for (i = 0; i < list_count; i++) {
+			/* Add new element only to the global linked list, not the bucket list.
+			 * Also use key 0 for everything, as we'll reindex the hashtable anyways. */
+			Bucket *q = pemalloc_rel(sizeof(Bucket), ht->persistent);
+			q->arKey = NULL;
+			q->nKeyLength = 0;
+			q->h = 0;
+			INIT_DATA(ht, q, list[i], nDataSize);
+
+			CONNECT_TO_GLOBAL_DLLIST_EX(q, ht, p ? p->pListLast : ht->pListTail, p);
+
+			ht->nNumOfElements++;
+
+			if (pCopyConstructor) {
+				pCopyConstructor(q->pData);
+			}
+		}
+
+		ZEND_HASH_IF_FULL_DO_RESIZE(ht);
+	}
+
+	zend_hash_reindex(ht, 1);
+}
+/* }}} */
+
 ZEND_API int zend_hash_sort(HashTable *ht, sort_func_t sort_func,
 							compare_func_t compar, int renumber TSRMLS_DC)
 {
@@ -1423,15 +1405,7 @@ ZEND_API int zend_hash_sort(HashTable *ht, sort_func_t sort_func,
 	HANDLE_UNBLOCK_INTERRUPTIONS();
 
 	if (renumber) {
-		p = ht->pListHead;
-		i=0;
-		while (p != NULL) {
-			p->nKeyLength = 0;
-			p->h = i++;
-			p = p->pListNext;
-		}
-		ht->nNextFreeElement = i;
-		zend_hash_rehash(ht);
+		zend_hash_reindex(ht, 0);
 	}
 	return SUCCESS;
 }
@@ -1440,7 +1414,7 @@ ZEND_API int zend_hash_sort(HashTable *ht, sort_func_t sort_func,
 ZEND_API int zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t compar, zend_bool ordered TSRMLS_DC)
 {
 	Bucket *p1, *p2 = NULL;
-	int result;
+	ptrdiff_t result;
 	void *pData2;
 
 	IS_CONSISTENT(ht1);
@@ -1550,7 +1524,7 @@ ZEND_API int zend_hash_minmax(const HashTable *ht, compare_func_t compar, int fl
 	return SUCCESS;
 }
 
-ZEND_API ulong zend_hash_next_free_element(const HashTable *ht)
+ZEND_API zend_uint_t zend_hash_next_free_element(const HashTable *ht)
 {
 	IS_CONSISTENT(ht);
 
@@ -1574,7 +1548,7 @@ void zend_hash_display_pListTail(const HashTable *ht)
 void zend_hash_display(const HashTable *ht)
 {
 	Bucket *p;
-	uint i;
+	zend_uint_t i;
 
 	if (UNEXPECTED(ht->nNumOfElements == 0)) {
 		zend_output_debug_string(0, "The hash is empty");

Zend/zend_hash.h

@@ -26,7 +26,7 @@
 #include "zend.h"
 
 #define HASH_KEY_IS_STRING 1
-#define HASH_KEY_IS_LONG 2
+#define HASH_KEY_IS_INT 2
 #define HASH_KEY_NON_EXISTENT 3
 #define HASH_KEY_NON_EXISTANT HASH_KEY_NON_EXISTENT /* Keeping old define (with typo) for backward compatibility */
 
@@ -43,7 +43,7 @@
 #define HASH_UPDATE_KEY_IF_AFTER   2
 #define HASH_UPDATE_KEY_ANYWAY     3
 
-typedef ulong (*hash_func_t)(const char *arKey, uint nKeyLength);
+typedef zend_uint_t (*hash_func_t)(const char *arKey, zend_size_t nKeyLength);
 typedef int  (*compare_func_t)(const void *, const void * TSRMLS_DC);
 typedef void (*sort_func_t)(void *, size_t, register size_t, compare_func_t TSRMLS_DC);
 typedef void (*dtor_func_t)(void *pDest);
@@ -53,8 +53,8 @@ typedef void (*copy_ctor_param_func_t)(void *pElement, void *pParam);
 struct _hashtable;
 
 typedef struct bucket {
-	ulong h;						/* Used for numeric indexing */
-	uint nKeyLength;
+	zend_uint_t h;						/* Used for numeric indexing */
+	zend_size_t nKeyLength;
 	void *pData;
 	void *pDataPtr;
 	struct bucket *pListNext;
@@ -65,10 +65,10 @@ typedef struct bucket {
 } Bucket;
 
 typedef struct _hashtable {
-	uint nTableSize;
-	uint nTableMask;
-	uint nNumOfElements;
-	ulong nNextFreeElement;
+	zend_uint_t nTableSize;
+	zend_uint_t nTableMask;
+	zend_uint_t nNumOfElements;
+	zend_uint_t nNextFreeElement;
 	Bucket *pInternalPointer;	/* Used for element traversal */
 	Bucket *pListHead;
 	Bucket *pListTail;
@@ -85,8 +85,8 @@ typedef struct _hashtable {
 
 typedef struct _zend_hash_key {
 	const char *arKey;
-	uint nKeyLength;
-	ulong h;
+	zend_size_t nKeyLength;
+	zend_uint_t h;
 } zend_hash_key;
 
 
@@ -97,33 +97,33 @@ typedef Bucket* HashPosition;
 BEGIN_EXTERN_C()
 
 /* startup/shutdown */
-ZEND_API int _zend_hash_init(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC);
-ZEND_API int _zend_hash_init_ex(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC);
+ZEND_API int _zend_hash_init(HashTable *ht, zend_uint_t nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC);
+ZEND_API int _zend_hash_init_ex(HashTable *ht, zend_uint_t nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC);
 ZEND_API void zend_hash_destroy(HashTable *ht);
 ZEND_API void zend_hash_clean(HashTable *ht);
 #define zend_hash_init(ht, nSize, pHashFunction, pDestructor, persistent)						_zend_hash_init((ht), (nSize), (pDestructor), (persistent) ZEND_FILE_LINE_CC)
 #define zend_hash_init_ex(ht, nSize, pHashFunction, pDestructor, persistent, bApplyProtection)		_zend_hash_init_ex((ht), (nSize), (pDestructor), (persistent), (bApplyProtection) ZEND_FILE_LINE_CC)
 
 /* additions/updates/changes */
-ZEND_API int _zend_hash_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
+ZEND_API int _zend_hash_add_or_update(HashTable *ht, const char *arKey, zend_size_t nKeyLength, void *pData, zend_uint_t nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
 #define zend_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest) \
 		_zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
 #define zend_hash_add(ht, arKey, nKeyLength, pData, nDataSize, pDest) \
 		_zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC)
 
-ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
+ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, zend_size_t nKeyLength, zend_uint_t h, void *pData, zend_uint_t nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
 #define zend_hash_quick_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
 		_zend_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
 #define zend_hash_quick_add(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
 		_zend_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC)
 
-ZEND_API int _zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
+ZEND_API int _zend_hash_index_update_or_next_insert(HashTable *ht, zend_uint_t h, void *pData, zend_uint_t nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
 #define zend_hash_index_update(ht, h, pData, nDataSize, pDest) \
 		_zend_hash_index_update_or_next_insert(ht, h, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
 #define zend_hash_next_index_insert(ht, pData, nDataSize, pDest) \
 		_zend_hash_index_update_or_next_insert(ht, 0, pData, nDataSize, pDest, HASH_NEXT_INSERT ZEND_FILE_LINE_CC)
 
-ZEND_API int zend_hash_add_empty_element(HashTable *ht, const char *arKey, uint nKeyLength);
+ZEND_API int zend_hash_add_empty_element(HashTable *ht, const char *arKey, zend_size_t nKeyLength);
 
 
 #define ZEND_HASH_APPLY_KEEP				0
@@ -150,7 +150,7 @@ ZEND_API void zend_hash_reverse_apply(HashTable *ht, apply_func_t apply_func TSR
 
 
 /* Deletes */
-ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, int flag);
+ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, zend_size_t nKeyLength, zend_uint_t h, int flag);
 #define zend_hash_del(ht, arKey, nKeyLength) \
 		zend_hash_del_key_or_index(ht, arKey, nKeyLength, 0, HASH_DEL_KEY)
 #define zend_hash_quick_del(ht, arKey, nKeyLength, h) \
@@ -161,32 +161,32 @@ ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, uint n
 		zend_hash_func
 
 /* Data retreival */
-ZEND_API int zend_hash_find(const HashTable *ht, const char *arKey, uint nKeyLength, void **pData);
-ZEND_API int zend_hash_quick_find(const HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void **pData);
-ZEND_API int zend_hash_index_find(const HashTable *ht, ulong h, void **pData);
+ZEND_API int zend_hash_find(const HashTable *ht, const char *arKey, zend_size_t nKeyLength, void **pData);
+ZEND_API int zend_hash_quick_find(const HashTable *ht, const char *arKey, zend_size_t nKeyLength, zend_uint_t h, void **pData);
+ZEND_API int zend_hash_index_find(const HashTable *ht, zend_uint_t h, void **pData);
 
 /* Misc */
-ZEND_API int zend_hash_exists(const HashTable *ht, const char *arKey, uint nKeyLength);
-ZEND_API int zend_hash_quick_exists(const HashTable *ht, const char *arKey, uint nKeyLength, ulong h);
-ZEND_API int zend_hash_index_exists(const HashTable *ht, ulong h);
-ZEND_API ulong zend_hash_next_free_element(const HashTable *ht);
+ZEND_API int zend_hash_exists(const HashTable *ht, const char *arKey, zend_size_t nKeyLength);
+ZEND_API int zend_hash_quick_exists(const HashTable *ht, const char *arKey, zend_size_t nKeyLength, zend_uint_t h);
+ZEND_API int zend_hash_index_exists(const HashTable *ht, zend_uint_t h);
+ZEND_API zend_uint_t zend_hash_next_free_element(const HashTable *ht);
 
 /* traversing */
 #define zend_hash_has_more_elements_ex(ht, pos) \
 	(zend_hash_get_current_key_type_ex(ht, pos) == HASH_KEY_NON_EXISTENT ? FAILURE : SUCCESS)
 ZEND_API int zend_hash_move_forward_ex(HashTable *ht, HashPosition *pos);
 ZEND_API int zend_hash_move_backwards_ex(HashTable *ht, HashPosition *pos);
-ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, char **str_index, uint *str_length, ulong *num_index, zend_bool duplicate, HashPosition *pos);
+ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, char **str_index, zend_size_t *str_length, zend_uint_t *num_index, zend_bool duplicate, HashPosition *pos);
 ZEND_API void zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, HashPosition *pos);
 ZEND_API int zend_hash_get_current_key_type_ex(HashTable *ht, HashPosition *pos);
 ZEND_API int zend_hash_get_current_data_ex(HashTable *ht, void **pData, HashPosition *pos);
 ZEND_API void zend_hash_internal_pointer_reset_ex(HashTable *ht, HashPosition *pos);
 ZEND_API void zend_hash_internal_pointer_end_ex(HashTable *ht, HashPosition *pos);
-ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const char *str_index, uint str_length, ulong num_index, int mode, HashPosition *pos);
+ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const char *str_index, zend_size_t str_length, zend_uint_t num_index, int mode, HashPosition *pos);
 
 typedef struct _HashPointer {
 	HashPosition pos;
-	ulong h;
+	zend_uint_t h;
 } HashPointer;
 
 ZEND_API int zend_hash_get_pointer(const HashTable *ht, HashPointer *ptr);
@@ -214,9 +214,9 @@ ZEND_API int zend_hash_set_pointer(HashTable *ht, const HashPointer *ptr);
 	zend_hash_update_current_key_ex(ht, key_type, str_index, str_length, num_index, HASH_UPDATE_KEY_ANYWAY, NULL)
 
 /* Copying, merging and sorting */
-ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size);
-ZEND_API void _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite ZEND_FILE_LINE_DC);
-ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, uint size, merge_checker_func_t pMergeSource, void *pParam);
+ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, zend_uint_t size);
+ZEND_API void _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, zend_uint_t size, int overwrite ZEND_FILE_LINE_DC);
+ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, zend_uint_t size, merge_checker_func_t pMergeSource, void *pParam);
 ZEND_API int zend_hash_sort(HashTable *ht, sort_func_t sort_func, compare_func_t compare_func, int renumber TSRMLS_DC);
 ZEND_API int zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t compar, zend_bool ordered TSRMLS_DC);
 ZEND_API int zend_hash_minmax(const HashTable *ht, compare_func_t compar, int flag, void **pData TSRMLS_DC);
@@ -224,9 +224,14 @@ ZEND_API int zend_hash_minmax(const HashTable *ht, compare_func_t compar, int fl
 #define zend_hash_merge(target, source, pCopyConstructor, tmp, size, overwrite)					\
 	_zend_hash_merge(target, source, pCopyConstructor, tmp, size, overwrite ZEND_FILE_LINE_CC)
 
-ZEND_API int zend_hash_num_elements(const HashTable *ht);
+ZEND_API zend_uint_t zend_hash_num_elements(const HashTable *ht);
 
 ZEND_API int zend_hash_rehash(HashTable *ht);
+ZEND_API void zend_hash_reindex(HashTable *ht, zend_bool only_integer_keys);
+
+ZEND_API void _zend_hash_splice(HashTable *ht, zend_uint_t nDataSize, copy_ctor_func_t pCopyConstructor, zend_uint_t offset, zend_size_t length, void **list, zend_size_t list_count, HashTable *removed ZEND_FILE_LINE_DC);
+#define zend_hash_splice(ht, nDataSize, pCopyConstructor, offset, length, list, list_count, removed) \
+	_zend_hash_splice(ht, nDataSize, pCopyConstructor, offset, length, list, list_count, removed ZEND_FILE_LINE_CC)
 
 /*
  * DJBX33A (Daniel J. Bernstein, Times 33 with Addition)
@@ -261,9 +266,9 @@ ZEND_API int zend_hash_rehash(HashTable *ht);
  *                  -- Ralf S. Engelschall <rse@engelschall.com>
  */
 
-static inline ulong zend_inline_hash_func(const char *arKey, uint nKeyLength)
+static inline zend_uint_t zend_inline_hash_func(const char *arKey, zend_size_t nKeyLength)
 {
-	register ulong hash = 5381;
+	register zend_uint_t hash = Z_UI(5381);
 
 	/* variant with the hash unrolled eight times */
 	for (; nKeyLength >= 8; nKeyLength -= 8) {
@@ -291,7 +296,7 @@ EMPTY_SWITCH_DEFAULT_CASE()
 }
 
 
-ZEND_API ulong zend_hash_func(const char *arKey, uint nKeyLength);
+ZEND_API zend_uint_t zend_hash_func(const char *arKey, zend_size_t nKeyLength);
 
 #if ZEND_DEBUG
 /* debug */
@@ -318,9 +323,9 @@ END_EXTERN_C()
 																			\
 		if ((*end != '\0') /* not a null terminated string */				\
 		 || (*tmp == '0' && length > 2) /* numbers with leading zeros */	\
-		 || (end - tmp > MAX_LENGTH_OF_LONG - 1) /* number too long */		\
-		 || (SIZEOF_LONG == 4 &&											\
-		     end - tmp == MAX_LENGTH_OF_LONG - 1 &&							\
+		 || (end - tmp > MAX_LENGTH_OF_ZEND_INT - 1) /* number too long */		\
+		 || (SIZEOF_ZEND_INT == 4 &&											\
+		     end - tmp == MAX_LENGTH_OF_ZEND_INT - 1 &&							\
 		     *tmp > '2')) { /* overflow */									\
 			break;															\
 		}																	\
@@ -330,11 +335,11 @@ END_EXTERN_C()
 		}																	\
 		if (tmp == end) {													\
 			if (*key == '-') {												\
-				if (idx-1 > LONG_MAX) { /* overflow */						\
+				if (idx-1 > ZEND_INT_MAX) { /* overflow */						\
 					break;													\
 				}															\
 				idx = 0 - idx;               									\
-			} else if (idx > LONG_MAX) { /* overflow */						\
+			} else if (idx > ZEND_INT_MAX) { /* overflow */						\
 				break;														\
 			}																\
 			func;															\
@@ -343,41 +348,41 @@ END_EXTERN_C()
 } while (0)
 
 #define ZEND_HANDLE_NUMERIC(key, length, func) do {							\
-	ulong idx;																\
+	zend_uint_t idx;																\
 																			\
 	ZEND_HANDLE_NUMERIC_EX(key, length, idx, return func);					\
 } while (0)
 
-static inline int zend_symtable_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest)					\
+static inline int zend_symtable_update(HashTable *ht, const char *arKey, zend_size_t nKeyLength, void *pData, zend_uint_t nDataSize, void **pDest)					\
 {
 	ZEND_HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_update(ht, idx, pData, nDataSize, pDest));
 	return zend_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest);
 }
 
 
-static inline int zend_symtable_del(HashTable *ht, const char *arKey, uint nKeyLength)
+static inline int zend_symtable_del(HashTable *ht, const char *arKey, zend_size_t nKeyLength)
 {
 	ZEND_HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_del(ht, idx));
 	return zend_hash_del(ht, arKey, nKeyLength);
 }
 
 
-static inline int zend_symtable_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData)
+static inline int zend_symtable_find(HashTable *ht, const char *arKey, zend_size_t nKeyLength, void **pData)
 {
 	ZEND_HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_find(ht, idx, pData));
 	return zend_hash_find(ht, arKey, nKeyLength, pData);
 }
 
 
-static inline int zend_symtable_exists(HashTable *ht, const char *arKey, uint nKeyLength)
+static inline int zend_symtable_exists(HashTable *ht, const char *arKey, zend_size_t nKeyLength)
 {
 	ZEND_HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_exists(ht, idx));
 	return zend_hash_exists(ht, arKey, nKeyLength);
 }
 
-static inline int zend_symtable_update_current_key_ex(HashTable *ht, const char *arKey, uint nKeyLength, int mode, HashPosition *pos)
+static inline int zend_symtable_update_current_key_ex(HashTable *ht, const char *arKey, zend_size_t nKeyLength, int mode, HashPosition *pos)
 {
-	ZEND_HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_update_current_key_ex(ht, HASH_KEY_IS_LONG, NULL, 0, idx, mode, pos));
+	ZEND_HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_update_current_key_ex(ht, HASH_KEY_IS_INT, NULL, 0, idx, mode, pos));
 	return zend_hash_update_current_key_ex(ht, HASH_KEY_IS_STRING, arKey, nKeyLength, 0, mode, pos);
 }
 #define zend_symtable_update_current_key(ht,arKey,nKeyLength,mode) \

Zend/zend_highlight.c

@@ -54,10 +54,10 @@ ZEND_API void zend_html_putc(char c)
 }
 
 
-ZEND_API void zend_html_puts(const char *s, uint len TSRMLS_DC)
+ZEND_API void zend_html_puts(const char *s, zend_size_t len TSRMLS_DC)
 {
 	const unsigned char *ptr = (const unsigned char*)s, *end = ptr + len;
-	unsigned char *filtered;
+	unsigned char *filtered = NULL;
 	size_t filtered_len;
 
 	if (LANG_SCNG(output_filter)) {
@@ -150,7 +150,7 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 				case T_DOC_COMMENT:
 					break;
 				default:
-					efree(token.value.str.val);
+					str_efree(token.value.str.val);
 					break;
 			}
 		}
@@ -211,7 +211,7 @@ ZEND_API void zend_strip(TSRMLS_D)
 					break;
 
 				default:
-					efree(token.value.str.val);
+					STR_FREE(token.value.str.val);
 					break;
 			}
 		}

Zend/zend_highlight.h

@@ -44,7 +44,7 @@ ZEND_API void zend_strip(TSRMLS_D);
 ZEND_API int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlighter_ini TSRMLS_DC);
 ZEND_API int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini, char *str_name TSRMLS_DC);
 ZEND_API void zend_html_putc(char c);
-ZEND_API void zend_html_puts(const char *s, uint len TSRMLS_DC);
+ZEND_API void zend_html_puts(const char *s, zend_size_t len TSRMLS_DC);
 END_EXTERN_C()
 
 extern zend_syntax_highlighter_ini syntax_highlighter_ini;

Zend/zend_indent.c

@@ -47,7 +47,7 @@ static void handle_whitespace(int *emit_whitespace)
 }
 
 
-ZEND_API void zend_indent()
+ZEND_API void zend_indent(TSRMLS_D)
 {
 	zval token;
 	int token_type;
@@ -55,7 +55,6 @@ ZEND_API void zend_indent()
 	int nest_level=0;
 	int emit_whitespace[256];
 	int i;
-	TSRMLS_FETCH();
 
 	memset(emit_whitespace, 0, sizeof(int)*256);
 
@@ -139,7 +138,7 @@ dflt_printout:
 			case T_WHITESPACE:
 				break;
 			default:
-				efree(token.value.str.val);
+				str_efree(token.value.str.val);
 				break;
 			}
 		}

Zend/zend_indent.h

@@ -23,7 +23,7 @@
 #define ZEND_INDENT_H
 
 BEGIN_EXTERN_C()
-ZEND_API void zend_indent(void);
+ZEND_API void zend_indent(TSRMLS_D);
 END_EXTERN_C()
 
 #endif /* ZEND_INDENT_H */

Zend/zend_ini.c

@@ -205,9 +205,9 @@ ZEND_API int zend_register_ini_entries(const zend_ini_entry *ini_entry, int modu
 		hashed_ini_entry->module_number = module_number;
 		if ((zend_get_configuration_directive(p->name, p->name_length, &default_value)) == SUCCESS) {
 			if (!hashed_ini_entry->on_modify
-				|| hashed_ini_entry->on_modify(hashed_ini_entry, Z_STRVAL(default_value), Z_STRLEN(default_value), hashed_ini_entry->mh_arg1, hashed_ini_entry->mh_arg2, hashed_ini_entry->mh_arg3, ZEND_INI_STAGE_STARTUP TSRMLS_CC) == SUCCESS) {
+				|| hashed_ini_entry->on_modify(hashed_ini_entry, Z_STRVAL(default_value), Z_STRSIZE(default_value), hashed_ini_entry->mh_arg1, hashed_ini_entry->mh_arg2, hashed_ini_entry->mh_arg3, ZEND_INI_STAGE_STARTUP TSRMLS_CC) == SUCCESS) {
 				hashed_ini_entry->value = Z_STRVAL(default_value);
-				hashed_ini_entry->value_length = Z_STRLEN(default_value);
+				hashed_ini_entry->value_length = Z_STRSIZE(default_value);
 				config_directive_success = 1;
 			}
 		}
@@ -244,7 +244,7 @@ ZEND_API void zend_ini_refresh_caches(int stage TSRMLS_DC) /* {{{ */
 /* }}} */
 #endif
 
-ZEND_API int zend_alter_ini_entry(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage) /* {{{ */
+ZEND_API int zend_alter_ini_entry(char *name, zend_size_t name_length, char *new_value, zend_size_t new_value_length, int modify_type, int stage) /* {{{ */
 {
 	TSRMLS_FETCH();
 
@@ -252,7 +252,7 @@ ZEND_API int zend_alter_ini_entry(char *name, uint name_length, char *new_value,
 }
 /* }}} */
 
-ZEND_API int zend_alter_ini_entry_ex(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage, int force_change TSRMLS_DC) /* {{{ */
+ZEND_API int zend_alter_ini_entry_ex(char *name, zend_size_t name_length, char *new_value, zend_size_t new_value_length, int modify_type, int stage, int force_change TSRMLS_DC) /* {{{ */
 {
 	zend_ini_entry *ini_entry;
 	char *duplicate;
@@ -306,7 +306,7 @@ ZEND_API int zend_alter_ini_entry_ex(char *name, uint name_length, char *new_val
 }
 /* }}} */
 
-ZEND_API int zend_restore_ini_entry(char *name, uint name_length, int stage) /* {{{ */
+ZEND_API int zend_restore_ini_entry(char *name, zend_size_t name_length, int stage) /* {{{ */
 {
 	zend_ini_entry *ini_entry;
 	TSRMLS_FETCH();
@@ -328,7 +328,7 @@ ZEND_API int zend_restore_ini_entry(char *name, uint name_length, int stage) /*
 }
 /* }}} */
 
-ZEND_API int zend_ini_register_displayer(char *name, uint name_length, void (*displayer)(zend_ini_entry *ini_entry, int type)) /* {{{ */
+ZEND_API int zend_ini_register_displayer(char *name, zend_size_t name_length, void (*displayer)(zend_ini_entry *ini_entry, int type)) /* {{{ */
 {
 	zend_ini_entry *ini_entry;
 
@@ -345,16 +345,16 @@ ZEND_API int zend_ini_register_displayer(char *name, uint name_length, void (*di
  * Data retrieval
  */
 
-ZEND_API long zend_ini_long(char *name, uint name_length, int orig) /* {{{ */
+ZEND_API zend_int_t zend_ini_int(char *name, zend_size_t name_length, int orig) /* {{{ */
 {
 	zend_ini_entry *ini_entry;
 	TSRMLS_FETCH();
 
 	if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == SUCCESS) {
 		if (orig && ini_entry->modified) {
-			return (ini_entry->orig_value ? strtol(ini_entry->orig_value, NULL, 0) : 0);
+			return (ini_entry->orig_value ? ZEND_STRTOI(ini_entry->orig_value, NULL, 0) : 0);
 		} else {
-			return (ini_entry->value      ? strtol(ini_entry->value, NULL, 0)      : 0);
+			return (ini_entry->value      ? ZEND_STRTOI(ini_entry->value, NULL, 0)      : 0);
 		}
 	}
 
@@ -362,7 +362,7 @@ ZEND_API long zend_ini_long(char *name, uint name_length, int orig) /* {{{ */
 }
 /* }}} */
 
-ZEND_API double zend_ini_double(char *name, uint name_length, int orig) /* {{{ */
+ZEND_API double zend_ini_double(char *name, zend_size_t name_length, int orig) /* {{{ */
 {
 	zend_ini_entry *ini_entry;
 	TSRMLS_FETCH();
@@ -379,7 +379,7 @@ ZEND_API double zend_ini_double(char *name, uint name_length, int orig) /* {{{ *
 }
 /* }}} */
 
-ZEND_API char *zend_ini_string_ex(char *name, uint name_length, int orig, zend_bool *exists) /* {{{ */
+ZEND_API char *zend_ini_string_ex(char *name, zend_size_t name_length, int orig, zend_bool *exists) /* {{{ */
 {
 	zend_ini_entry *ini_entry;
 	TSRMLS_FETCH();
@@ -403,7 +403,7 @@ ZEND_API char *zend_ini_string_ex(char *name, uint name_length, int orig, zend_b
 }
 /* }}} */
 
-ZEND_API char *zend_ini_string(char *name, uint name_length, int orig) /* {{{ */
+ZEND_API char *zend_ini_string(char *name, zend_size_t name_length, int orig) /* {{{ */
 {
 	zend_bool exists = 1;
 	char *return_value;
@@ -425,7 +425,7 @@ static void zend_ini_displayer_cb(zend_ini_entry *ini_entry, int type) /* {{{ */
 		ini_entry->displayer(ini_entry, type);
 	} else {
 		char *display_string;
-		uint display_string_length;
+		zend_size_t display_string_length;
 
 		if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
 			if (ini_entry->orig_value) {
@@ -460,7 +460,8 @@ static void zend_ini_displayer_cb(zend_ini_entry *ini_entry, int type) /* {{{ */
 
 ZEND_INI_DISP(zend_ini_boolean_displayer_cb) /* {{{ */
 {
-	int value, tmp_value_len;
+	int value;
+	zend_size_t tmp_value_len;
 	char *tmp_value;
 
 	if (type == ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
@@ -577,7 +578,7 @@ ZEND_API ZEND_INI_MH(OnUpdateBool) /* {{{ */
 
 ZEND_API ZEND_INI_MH(OnUpdateLong) /* {{{ */
 {
-	long *p;
+	zend_int_t *p;
 #ifndef ZTS
 	char *base = (char *) mh_arg2;
 #else
@@ -586,7 +587,7 @@ ZEND_API ZEND_INI_MH(OnUpdateLong) /* {{{ */
 	base = (char *) ts_resource(*((int *) mh_arg2));
 #endif
 
-	p = (long *) (base+(size_t) mh_arg1);
+	p = (zend_int_t *) (base+(size_t) mh_arg1);
 
 	*p = zend_atol(new_value, new_value_length);
 	return SUCCESS;
@@ -595,7 +596,7 @@ ZEND_API ZEND_INI_MH(OnUpdateLong) /* {{{ */
 
 ZEND_API ZEND_INI_MH(OnUpdateLongGEZero) /* {{{ */
 {
-	long *p, tmp;
+	zend_int_t *p, tmp;
 #ifndef ZTS
 	char *base = (char *) mh_arg2;
 #else
@@ -609,7 +610,7 @@ ZEND_API ZEND_INI_MH(OnUpdateLongGEZero) /* {{{ */
 		return FAILURE;
 	}
 
-	p = (long *) (base+(size_t) mh_arg1);
+	p = (zend_int_t *) (base+(size_t) mh_arg1);
 	*p = tmp;
 
 	return SUCCESS;

Zend/zend_ini.h

@@ -45,7 +45,7 @@
 # else /* ! (CRAY || __arm) */
 
 # define XtOffset(p_type, field) \
-    ((long) (((char *) (&(((p_type)NULL)->field))) - ((char *) NULL)))
+    ((zend_int_t) (((char *) (&(((p_type)NULL)->field))) - ((char *) NULL)))
 
 # endif /* !CRAY */
 
@@ -57,24 +57,24 @@
 
 #endif
 
-#define ZEND_INI_MH(name) int name(zend_ini_entry *entry, char *new_value, uint new_value_length, void *mh_arg1, void *mh_arg2, void *mh_arg3, int stage TSRMLS_DC)
+#define ZEND_INI_MH(name) int name(zend_ini_entry *entry, char *new_value, zend_size_t new_value_length, void *mh_arg1, void *mh_arg2, void *mh_arg3, int stage TSRMLS_DC)
 #define ZEND_INI_DISP(name) void name(zend_ini_entry *ini_entry, int type)
 
 struct _zend_ini_entry {
 	int module_number;
 	int modifiable;
 	char *name;
-	uint name_length;
+	zend_size_t name_length;
 	ZEND_INI_MH((*on_modify));
 	void *mh_arg1;
 	void *mh_arg2;
 	void *mh_arg3;
 
 	char *value;
-	uint value_length;
+	zend_size_t value_length;
 
 	char *orig_value;
-	uint orig_value_length;
+	zend_size_t orig_value_length;
 	int orig_modifiable;
 	int modified;
 
@@ -94,17 +94,17 @@ ZEND_API void zend_ini_sort_entries(TSRMLS_D);
 ZEND_API int zend_register_ini_entries(const zend_ini_entry *ini_entry, int module_number TSRMLS_DC);
 ZEND_API void zend_unregister_ini_entries(int module_number TSRMLS_DC);
 ZEND_API void zend_ini_refresh_caches(int stage TSRMLS_DC);
-ZEND_API int zend_alter_ini_entry(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage);
-ZEND_API int zend_alter_ini_entry_ex(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage, int force_change TSRMLS_DC);
-ZEND_API int zend_restore_ini_entry(char *name, uint name_length, int stage);
+ZEND_API int zend_alter_ini_entry(char *name, zend_size_t name_length, char *new_value, zend_size_t new_value_length, int modify_type, int stage);
+ZEND_API int zend_alter_ini_entry_ex(char *name, zend_size_t name_length, char *new_value, zend_size_t new_value_length, int modify_type, int stage, int force_change TSRMLS_DC);
+ZEND_API int zend_restore_ini_entry(char *name, zend_size_t name_length, int stage);
 ZEND_API void display_ini_entries(zend_module_entry *module);
 
-ZEND_API long zend_ini_long(char *name, uint name_length, int orig);
-ZEND_API double zend_ini_double(char *name, uint name_length, int orig);
-ZEND_API char *zend_ini_string(char *name, uint name_length, int orig);
-ZEND_API char *zend_ini_string_ex(char *name, uint name_length, int orig, zend_bool *exists);
+ZEND_API zend_int_t zend_ini_int(char *name, zend_size_t name_length, int orig);
+ZEND_API double zend_ini_double(char *name, zend_size_t name_length, int orig);
+ZEND_API char *zend_ini_string(char *name, zend_size_t name_length, int orig);
+ZEND_API char *zend_ini_string_ex(char *name, zend_size_t name_length, int orig, zend_bool *exists);
 
-ZEND_API int zend_ini_register_displayer(char *name, uint name_length, void (*displayer)(zend_ini_entry *ini_entry, int type));
+ZEND_API int zend_ini_register_displayer(char *name, zend_size_t name_length, void (*displayer)(zend_ini_entry *ini_entry, int type));
 
 ZEND_API ZEND_INI_DISP(zend_ini_boolean_displayer_cb);
 ZEND_API ZEND_INI_DISP(zend_ini_color_displayer_cb);
@@ -154,12 +154,12 @@ END_EXTERN_C()
 	ZEND_INI_ENTRY3_EX(name, default_value, modifiable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr, NULL, zend_ini_boolean_displayer_cb)
 #endif
 
-#define INI_INT(name) zend_ini_long((name), sizeof(name), 0)
+#define INI_INT(name) zend_ini_int((name), sizeof(name), 0)
 #define INI_FLT(name) zend_ini_double((name), sizeof(name), 0)
 #define INI_STR(name) zend_ini_string_ex((name), sizeof(name), 0, NULL)
 #define INI_BOOL(name) ((zend_bool) INI_INT(name))
 
-#define INI_ORIG_INT(name)	zend_ini_long((name), sizeof(name), 1)
+#define INI_ORIG_INT(name)	zend_ini_int((name), sizeof(name), 1)
 #define INI_ORIG_FLT(name)	zend_ini_double((name), sizeof(name), 1)
 #define INI_ORIG_STR(name)	zend_ini_string((name), sizeof(name), 1)
 #define INI_ORIG_BOOL(name) ((zend_bool) INI_ORIG_INT(name))

Zend/zend_ini_parser.y

@@ -49,7 +49,7 @@ static void zend_ini_do_op(char type, zval *result, zval *op1, zval *op2)
 {
 	int i_result;
 	int i_op1, i_op2;
-	char str_result[MAX_LENGTH_OF_LONG];
+	char str_result[MAX_LENGTH_OF_ZEND_INT];
 
 	i_op1 = atoi(Z_STRVAL_P(op1));
 	free(Z_STRVAL_P(op1));
@@ -81,10 +81,10 @@ static void zend_ini_do_op(char type, zval *result, zval *op1, zval *op2)
 			break;
 	}
 
-	Z_STRLEN_P(result) = zend_sprintf(str_result, "%d", i_result);
-	Z_STRVAL_P(result) = (char *) malloc(Z_STRLEN_P(result)+1);
-	memcpy(Z_STRVAL_P(result), str_result, Z_STRLEN_P(result));
-	Z_STRVAL_P(result)[Z_STRLEN_P(result)] = 0;
+	Z_STRSIZE_P(result) = zend_sprintf(str_result, "%d", i_result);
+	Z_STRVAL_P(result) = (char *) malloc(Z_STRSIZE_P(result)+1);
+	memcpy(Z_STRVAL_P(result), str_result, Z_STRSIZE_P(result));
+	Z_STRVAL_P(result)[Z_STRSIZE_P(result)] = 0;
 	Z_TYPE_P(result) = IS_STRING;
 }
 /* }}} */
@@ -95,7 +95,7 @@ static void zend_ini_init_string(zval *result)
 {
 	Z_STRVAL_P(result) = malloc(1);
 	Z_STRVAL_P(result)[0] = 0;
-	Z_STRLEN_P(result) = 0;
+	Z_STRSIZE_P(result) = 0;
 	Z_TYPE_P(result) = IS_STRING;
 }
 /* }}} */
@@ -104,12 +104,12 @@ static void zend_ini_init_string(zval *result)
 */
 static void zend_ini_add_string(zval *result, zval *op1, zval *op2)
 {
-	int length = Z_STRLEN_P(op1) + Z_STRLEN_P(op2);
+	zend_size_t length = Z_STRSIZE_P(op1) + Z_STRSIZE_P(op2);
 
 	Z_STRVAL_P(result) = (char *) realloc(Z_STRVAL_P(op1), length+1);
-	memcpy(Z_STRVAL_P(result)+Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2));
+	memcpy(Z_STRVAL_P(result)+Z_STRSIZE_P(op1), Z_STRVAL_P(op2), Z_STRSIZE_P(op2));
 	Z_STRVAL_P(result)[length] = 0;
-	Z_STRLEN_P(result) = length;
+	Z_STRSIZE_P(result) = length;
 	Z_TYPE_P(result) = IS_STRING;
 }
 /* }}} */
@@ -121,12 +121,12 @@ static void zend_ini_get_constant(zval *result, zval *name TSRMLS_DC)
 	zval z_constant;
 
 	/* If name contains ':' it is not a constant. Bug #26893. */
-	if (!memchr(Z_STRVAL_P(name), ':', Z_STRLEN_P(name))
-		   	&& zend_get_constant(Z_STRVAL_P(name), Z_STRLEN_P(name), &z_constant TSRMLS_CC)) {
+	if (!memchr(Z_STRVAL_P(name), ':', Z_STRSIZE_P(name))
+		   	&& zend_get_constant(Z_STRVAL_P(name), Z_STRSIZE_P(name), &z_constant TSRMLS_CC)) {
 		/* z_constant is emalloc()'d */
 		convert_to_string(&z_constant);
-		Z_STRVAL_P(result) = zend_strndup(Z_STRVAL(z_constant), Z_STRLEN(z_constant));
-		Z_STRLEN_P(result) = Z_STRLEN(z_constant);
+		Z_STRVAL_P(result) = zend_strndup(Z_STRVAL(z_constant), Z_STRSIZE(z_constant));
+		Z_STRSIZE_P(result) = Z_STRSIZE(z_constant);
 		Z_TYPE_P(result) = Z_TYPE(z_constant);
 		zval_dtor(&z_constant);
 		free(Z_STRVAL_P(name));
@@ -144,14 +144,14 @@ static void zend_ini_get_var(zval *result, zval *name TSRMLS_DC)
 	char *envvar;
 
 	/* Fetch configuration option value */
-	if (zend_get_configuration_directive(Z_STRVAL_P(name), Z_STRLEN_P(name)+1, &curval) == SUCCESS) {
-		Z_STRVAL_P(result) = zend_strndup(Z_STRVAL(curval), Z_STRLEN(curval));
-		Z_STRLEN_P(result) = Z_STRLEN(curval);
+	if (zend_get_configuration_directive(Z_STRVAL_P(name), Z_STRSIZE_P(name)+1, &curval) == SUCCESS) {
+		Z_STRVAL_P(result) = zend_strndup(Z_STRVAL(curval), Z_STRSIZE(curval));
+		Z_STRSIZE_P(result) = Z_STRSIZE(curval);
 	/* ..or if not found, try ENV */
-	} else if ((envvar = zend_getenv(Z_STRVAL_P(name), Z_STRLEN_P(name) TSRMLS_CC)) != NULL ||
+	} else if ((envvar = zend_getenv(Z_STRVAL_P(name), Z_STRSIZE_P(name) TSRMLS_CC)) != NULL ||
 			   (envvar = getenv(Z_STRVAL_P(name))) != NULL) {
 		Z_STRVAL_P(result) = strdup(envvar);
-		Z_STRLEN_P(result) = strlen(envvar);
+		Z_STRSIZE_P(result) = strlen(envvar);
 	} else {
 		zend_ini_init_string(result);
 	}
@@ -163,7 +163,7 @@ static void zend_ini_get_var(zval *result, zval *name TSRMLS_DC)
 static void ini_error(char *msg)
 {
 	char *error_buf;
-	int error_buf_len;
+	zend_size_t error_buf_len;
 	char *currently_parsed_filename;
 	TSRMLS_FETCH();
 

Zend/zend_ini_scanner.c

@@ -57,7 +57,7 @@
 #define yytext       ((char*)SCNG(yy_text))
 #define yyleng       SCNG(yy_leng)
 #define yyless(x)    do {	YYCURSOR = (unsigned char*)yytext + x; \
-							yyleng   = (unsigned int)x; } while(0)
+							yyleng   = (zend_size_t)x; } while(0)
 
 /* #define yymore()     goto yymore_restart */
 
@@ -135,7 +135,7 @@ ZEND_API zend_ini_scanner_globals ini_scanner_globals;
 
 #define zend_ini_copy_value(retval, str, len) {  \
 	Z_STRVAL_P(retval) = zend_strndup(str, len); \
-	Z_STRLEN_P(retval) = len;                    \
+	Z_STRSIZE_P(retval) = len;                    \
 	Z_TYPE_P(retval) = IS_STRING;                \
 }
 
@@ -263,7 +263,7 @@ int zend_ini_prepare_string_for_scanning(char *str, int scanner_mode TSRMLS_DC)
 
 /* {{{ zend_ini_escape_string()
  */
-static void zend_ini_escape_string(zval *lval, char *str, int len, char quote_type TSRMLS_DC)
+static void zend_ini_escape_string(zval *lval, char *str, zend_size_t len, char quote_type TSRMLS_DC)
 {
 	register char *s, *t;
 	char *end;
@@ -272,7 +272,7 @@ static void zend_ini_escape_string(zval *lval, char *str, int len, char quote_ty
 
 	/* convert escape sequences */
 	s = t = Z_STRVAL_P(lval);
-	end = s + Z_STRLEN_P(lval);
+	end = s + Z_STRSIZE_P(lval);
 
 	while (s < end) {
 		if (*s == '\\') {
@@ -291,7 +291,7 @@ static void zend_ini_escape_string(zval *lval, char *str, int len, char quote_ty
 				case '\\':
 				case '$':
 					*t++ = *s;
-					Z_STRLEN_P(lval)--;
+					Z_STRSIZE_P(lval)--;
 					break;
 				default:
 					*t++ = '\\';