Revert "Prefix error_code with underscore in FastZPP implementation"

This reverts commit 6305119a5193d4318add01190ca4afbb49ded102.

This is a source-compatibility break for extensions that define
custom FastZPP macros, such as ext/uv:

https://github.com/bwoebi/php-uv/blob/a983eb17b69f74a45d785ddc6a7bff3d4531b88c/php_uv.c#L75

I don't think that FastZPP was intended to be used this way, but
let's revert this from release branches to avoid extension breakage.

Prefix error_code with underscore in FastZPP implementation

To avoid conflicts with parameter names.

Future-proof email addresses

Remove unused Git attributes ident

The $Id$ keywords were used in Subversion where they can be substituted
with filename, last revision number change, last changed date, and last
user who changed it.

In Git this functionality is different and can be done with Git attribute
ident. These need to be defined manually for each file in the
.gitattributes file and are afterwards replaced with 40-character
hexadecimal blob object name which is based only on the particular file
contents.

This patch simplifies handling of $Id$ keywords by removing them since
they are not used anymore.

API cleanup.
Removed useless filename and lineno arguments, used in DEBUG build.
The patch doesn't break source compatibility of public API (only binary compatibility).

Merge zend_class_entry.create_object and zend_class_entry.interface_gets_implemented into the same memory lacation. The first used only by classes, the second only by magic interfaces.

Improved user iterator implementation to reduce zend_class_entry memory consumption and avoid race condition during resolving/caching of user iterator functions of internal classes in ZTS build.

Avoid useless checks in object_init()

Add zend_update_static_property_ex API

And cleanup the implementation to perform a normal by-value
assignment.

Add zend_read_static_property_ex API

For symmetry with zend_read_property_ex.

Fix build

These were changed in 6e77a60a75445c863f85f81a83e5c2dd28f0e877.

Removed INIT_OVERLOADED_CLASS... macros

Add is_countable function

RFC: https://wiki.php.net/rfc/is-countable

Fixed unintended API break

Remove duplicated assignment

Added missed "return"

Improved ZPP to reduce amount of generated code.

Fix some misspellings

Use bool instead of boolean while throwing a type error

PHP requires boolean typehints to be written "bool" and disallows
"boolean" as an alias. This changes the error messages to match
the actual type name and avoids confusing messages like "must be
of type boolean, boolean given".

This a followup to ce1d69a1f6dcf15d43029301059c25e5bc09a577, which
implements the same change for integer->int.

Use int instead of integer in type errors

PHP requires integer typehints to be written "int" and does not
allow "integer" as an alias. This changes type error messages to
match the actual type name and avoids confusing messages like
"must be of the type integer, integer given".

Use Z_EXPECTED_LONG to initialize FAST_ZPP parsing loop

year++

year++

year++

zend_fcall_info_cache.initialized is removed (zend_fcall_info_cache is initialized if zend_fcall_info_cache.function_handler is set).

Use "fastcal" calling convention for internal PHP functions on x86

Remove zend_get_parameters(_ex) APIs

zend_get_parameters_ex() has been marked as deprecated for a long
time already. What zend_get_paramers() does is even more
questionable under PHP7. Both functions are obsoleted by the ZPP
mechanism, so I'm dropping them.

Extend zend_register_class_alias_ex() with additional argument to allow creating persistent or per-request aliases

Encapsulate reference-counting primitives.
Prohibit direct update of GC_REFCOUNT(), GC_SET_REFCOUNT(), GC_ADDREF() and GC_DELREF() shoukf be instead.
Added mactros to validate reference-counting (disabled for now).
These macros are going to be used to eliminate race-condintions during reference-counting on data shared between threads.

Extend zend_string API to avoid reallocation in zend_string_init_interned()

Refactored array creation API. array_init() and array_init_size() are converted into macros calling zend_new_array(). They are not functions anymore and don't return any values.

Fix fast ZPP macro definition

FAST_ZPP variant of zend_parse_parameters_none(), ZEND_PARSE_PARAMETERS_NONE()

further sync for vim mode lines

Fixed ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO macro

The macro was expanding to a wrong macro and thus leads to compile errors upon
usage. Changed it to expand to the correct macro.

Extract zend_get_callable_name() API

Instead of interleaving this inside zend_is_callable(), implement
this in a separate function instead.

Also add _deref() hash APIs. I've wanted these for a while, and
this is another place where they're useful, so finally do it...

Introduced "zif_handler" type (zif = zend internal function).

Improved new Zend Parameter Parsing API to avoid useless dereferences.
This derefernce made sense only for explicit paramter passing by reference, but this feature was removed in PHP-7.
The improvement is 100% backward compatible, only few "tricky" functions may be affected (e.g. extract and usort).

Constify str in add_assoc_string_ex and add_assoc_stringl_ex

Remove accidently added byte

Added zend_parse_parameters_none_throw()

Added ZEND_GET_CLASS, ZEMD_GET_CALLED_CLASS, ZEND_GET_TYPE instructions, to implement corresponding builtin functions.

Add variadic type and obj info macros

Introduced "zend_type" - an abstraction for type-hinting representation.

Update copyright headers to 2017

Update copyright headers to 2017

Update copyright headers to 2017

Support ZEND_PARSE_PARAMS_THROW in new ZPP API

further normalizations, uint vs uint32_t

fix merge mistake

yet one more replacement run

add missing RETURN_STRINGL_CHECK

As RETVAL_STRINGL_CHECK is already there, this one is needed for
completion. One place in ext/bz2 is missing that, so it will likely
be useful for other possible fixes.

Fix bug #73147: Use After Free in PHP7 unserialize()

(cherry picked from commit 0e6fe3a4c96be2d3e88389a5776f878021b4c59f)
(cherry picked from commit f42cbd749cde1f91274c1d03df9024baba141a8f)

Fix bug #73147: Use After Free in PHP7 unserialize()

(cherry picked from commit 0e6fe3a4c96be2d3e88389a5776f878021b4c59f)

Fix bug #73293 - NULL pointer dereference in SimpleXMLElement::asXML()

Fix bug #73147: Use After Free in PHP7 unserialize()

missed semicolon

fix C89 conformity

Fix various int size overflows.

Add function for detection of string zvals with length that does not fit
INT_MAX.

Remove zpp fallback code (always use Fast ZPP)

Squashed commit of the following:

commit 3e27fbb3d22b42d181e15c345f1c59a007b6b58c
Author: Andrea Faulds <ajf@ajf.me>
Date: Sun Sep 11 19:14:37 2016 +0100

Keep dummy FAST_ZPP macro for compatibility

commit 8a7cfd00deaa4a3c5026c97580c49c886c72a5b4
Author: Andrea Faulds <ajf@ajf.me>
Date: Mon Sep 5 22:36:03 2016 +0100

Remove FAST_ZPP macro and plain zpp fallback code

Fix for bug #72807 - do not produce strings with negative length

improve ZEND_MODULE_GLOBALS_BULK macro, fix data type

Fixed compilation warnings

Fixed bug #71266 (Missing separation of properties HT in foreach etc).

Add iterable pseudo-type

Forbid dynamic calls to scope introspection functions

Per RFC:
https://wiki.php.net/rfc/forbid_dynamic_scope_introspection

Intern some known (and offten used) strings.

correct wording

Removed "zend_fcall_info.function_table". It was assigned in many places, but is never used.

Merge zend_execute_data->called_scope into zend_execute_data->This.
"called_scope" made sense only for static method calls, for dynamic calls it was always equal to the class of $this.
Now EG(This) may store IS_OBJECT + $this or IS_UNUSED + "called_scope" (of course, "called_scope" may be NULL).
Some code might need to be adopted to support this change.
Checks (Z_OBJ(EX(This))) might need to be converted into (Z_TYPE(EX(This)) == IS_OBJECT).

Removed zend_fcall_info.symbol_table

bump year which is missed in rev 49493a2

bump year which is missed in rev 49493a2

Implemented the RFC `Support Class Constant Visibility`.

Squashed commit of the following:

commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9
Author: Dmitry Stogov <dmitry@zend.com>
Date: Tue Dec 8 12:38:42 2015 +0300

Fixed test expectation

commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d
Author: Dmitry Stogov <dmitry@zend.com>
Date: Tue Dec 8 12:28:38 2015 +0300

Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags

commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b
Author: Dmitry Stogov <dmitry@zend.com>
Date: Mon Dec 7 11:18:55 2015 +0300

Fixed issues found by Nikita

commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723
Author: Dmitry Stogov <dmitry@zend.com>
Date: Sat Dec 5 02:41:05 2015 +0300

Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility
@reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.

Revert "fix typos "paramer" -> "parameters""

ABI BC break

This reverts commit 6ac12f13379f3fc19f07abb9d1055274e5f98838.

fix typos "paramer" -> "parameters"

fix typos "paramer" -> "parameters"

Short-circuit zend_parse_parameters_none() so that expensive zpp() call never happens in non-exceptional case

Add myself into list of authors of the most refactored files.

Mark error and exception functions as "cold" (Matt's idea)

Removed unused code

add macro to access globals as whole

add unified globals accessor macro

Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).

Improved zend_string API (Francois Laupretre)

Squashed commit of the following:

commit d96eab8d79b75ac83d49d49ae4665f948d15a804
Author: Francois Laupretre <francois@tekwire.net>
Date: Fri Jun 26 01:23:31 2015 +0200

Use the new 'ZSTR' macros in the rest of the code.

Does not change anything to the generated code (thanks to compat macros) but cleaner.

commit b3526439104ac7a89a8e0c79dbebf33b22bd01b8
Author: Francois Laupretre <francois@tekwire.net>
Date: Thu Jun 25 13:45:06 2015 +0200

Improve zend_string API

Add missing methods

Cache the class_name typehint key in arg_info
This leads to up to 2% improvement on one tested real world application by not having to always recalculate the lowercased string and its hash

Avoid zval duplication in ZVAL_ZVAL() macro (it was necessary only in few places).
Switch from ZVAL_ZVAL() to simpler macros where possible (it makes sense to review remaining places)

Add consistency check in FAST_ZPP call
So ensure Z_PARAM_OPTIONAL is correctly call at the right place
Only in DEBUG build

Will raise 'Assertion `_i > _min_num_args || _optional==0' failed.'
or 'Assertion `_i <= _min_num_args || _optional==1' failed.'
Thus will allow to detect bad code early.

Eliminated useless check in FAST_ZPP (this also fixed few wrong -Wmaybe-uninitialized compilation warnings) (Remi)

Use zend_string to represent pdo_column_data.name and avoid duplication.

Added RETURN_ARR and RETVAL_ARR macros

Always throw TypeException on throwing zpp failures

Introduces a ZEND_PARSE_PARAMS_THROW flag for zpp, which forces to
report FAILURE errors using a TypeException instead of a Warning,
like it would happen in strict mode.

Adds a zend_parse_parameters_throw() convenience function, which
invokes zpp with this flag.

Converts all cases I could identify, where we currently have
throwing zpp usage in constructors and replaces them with this API.
Error handling is still replaced to EH_THROW in some cases to handle
other, domain-specific errors in constructors.

Revert "Merge branch 'PHP-5.4' of https://git.php.net/repository/php-src into PHP-5.4"

This reverts commit fe0ca2745f00940a27bfc8e87db534541a19af70, reversing
changes made to 968fbc6acf0bc27be17c0209be7f966e89a55943.

Convert fatal errors into EngineExceptions
Make zval_update_constant_ex(), zval_update_constant(), zend_update_class_constants() and zend_ast_evaluate() return SUCCESS or FAILURE.

Reclassify E_STRICT notices

Per RFC https://wiki.php.net/rfc/reclassify_e_strict

While reviewing this, found that there are still three E_STRICTs
left in libraries - need to discuss those.

Patch improvement:

Removed the corresponding core code.
Fixed ext/com_dotnet and ext/date.
Refactored ext/intl changes.
Improved ext/fileinfo and ext/pdo changes.
Fixed tests.

Constness to zend_get_object_type(), thanks Michael!

Change "Cannot redeclare class X" into "Cannot redeclare class/interface/trait X", meaning that the following:

C:\> php -r "trait A { } trait A { }"

Will now properly print "Cannot redeclare trait A" instead of "Cannot redeclare class A" to make error messages a tiny bit clearer. Admittedly, a better solution can most likely be made by actually telling what the colliding object is a type of.

Internally this adds a new function:
zend_get_object_type()

cleanup

Revert "Use E_ERROR | E_EXCEPTION in FAST_ZPP mode too"

This reverts commit d4da7c20d2d642a6f0f81bde836576b9970969af.

The argument passed to this function refers to the weak mode
severity, strict mode will get an exception in any case.

Use E_ERROR | E_EXCEPTION in FAST_ZPP mode too

ZPP changed to lazely check for "strict/weak" only if it's really necessary.
Cleanup.

Imroved ZPP rules (condititins reoredered to prevent duplicate checks)

Improved type hinting:

EX_PREV_USES_STRICT_TYPES() and family changed/renamed to fit with other macros
Optimized zend_verify_internal_arg_type() and family (they don't need "strict" argument anymore)
Standerd ZPP is called from VM only for weak type check or strict exception (int -> double)
Fixed ZEND_RECV_VARIADIC
Fixed ZEND_STRLEN

TODO: should we accept IS_NULL for non-nullable arguments?

Refactor as to not use call info, but add the flag to the op_array.

Fix severity issues with callbacks, start work porting ZEND_STRLEN opcode to work with strict mode, more refactoring to come

Style cleanup, as well as fixing bug with missing argument for WRONG_PARAM_COUNT_WITH_RETVAL

Clean up API renames for zend_wrong_param_count to maintain BC, introducing a zend_wrong_param_count_ex() function when you know strict value

Use specialized macro for string zval creation

Add ZEND_ARG_CALLABLE_INFO to allow internal function to type hint against callable

Move declare() to the top of the file only, and allow int->float generalization

fix data types

Fix Gd usages of ZEND_WRONG_PARAM_COUNT, add usage note

Prefix zend_wrong_param_count with _ to discourage use

Partial ZPP strictness implementation

Padding

Implemented internal function return types

zend_read_property() has to provide a holder for return value.
Previously it was possible that zend_read_property() returned pointer to zval allocated on stack.

typo

bump year

bump year

Bump year

trailing whitespace removal

Make zend_parse_parameters share fast zpp implementation where possible

Rename shared implementation functions and build them unconditionally

Don't fail on empty path for zend_parse_arg_path

Update type names

Fix behaviour of by-reference "z"

Make 'o' use zend_parse_arg_object

Fix NULL string check in zend_parse_arg_path(_str)

Micro optimaztion (yeah, I know compiler supposed to do that)

Use "float" and "integer" in typehint and zpp errors

first shot remove TSRMLS_* things

Fixed compilation warnings

Use zend_string* for op_array->arg_info[]->name and op_array->arg_info[]->class_name. For internal functions we still use char*.

Refactor ZEND_LONG_MAX/MIN checks into ZEND_DOUBLE_FITS_LONG()

Fixed copy-and-paste error

Pack EX(num_args) into EX(This).u2.num_args

fix datatype mismatches

and convert len args to size_t where the underlaying API uses zend_string

move key lengths to use size_t as zend_string is used internally anyway

fix several datatype mismatches

all the key_len use uint, fix the warning when using strlen on 64 bit

Fix procedural finfo calls in methods

getThis() will return the $this of the calling method.

DLL export several APIs needed for phpdbg

Update get_class_name semantics

* get_class_name is now only used for displaying the class name
in debugging functions like var_dump, print_r, etc. It is no
longer used in get_class() etc.
* As it is no longer used in get_parent_class() the parent
argument is now gone. This also fixes incorrect parent classes
being reported in COM.
* get_class_name is now always required (previously some places
made it optional and some required it) and is also required
to return a non-NULL value.
* Remove zend_get_object_classname. This also fixes a number of
potential leaks due to incorrect usage of this function.

Remove zend_get_class_entry function

Replaced EG(This) and EX(object) with EX(This).
Internal functions now recieves zend_execute_data as the first argument.

reworked the patch, less new stuff but worky

TLS is already used in TSRM, the way exporting the tsrm cache through
a thread local variable is not portable. Additionally, the current
patch suffers from bugs which are hard to find, but prevent it to
be worky with apache. What is done here is mainly uses the idea
from the RFC patch, but

- __thread variable is removed
- offset math and declarations are removed
- extra macros and definitions are removed

What is done merely is

- use an inline function to access the tsrm cache. The function uses
the portable tsrm_tls_get macro which is cheap
- all the TSRM_* macros are set to placebo. Thus this opens the way
remove them later

Except that, the logic is old. TSRMLS_FETCH will have to be done once
per thread, then tsrm_get_ls_cache() can be used. Things seeming to be
worky are cli, cli server and apache. I also tried to enable bz2
shared and it has worked out of the box. The change is yet minimal
diffing to the current master bus is a worky start, IMHO. Though will
have to recheck the other previously done SAPIs - embed and cgi.

The offsets can be added to the tsrm_resource_type struct, then
it'll not be needed to declare them in the userspace. Even the
"done" member type can be changed to int16 or smaller, then adding
the offset as int16 will not change the struct size. As well on the
todo might be removing the hashed storage, thread_id != thread_id and
linked list logic in favour of the explicit TLS operations.

basic windows fix

Make zpp fail if NaN passed for int, or out-of-range float for non-capping int

native tls initial patch

fix condition

A char array like val[1] would always be valid when checking like
!val. Probably better were to check for ->len, but actually ->val[0]
is fine as the actual zend_string should have been initalized
before.

reduce the struct size by 8 byte on 64 bit

make array/object APIs accept large strings as values of elements/props

first show to make 's' work with size_t

master renames phase 3

master renames phase 2

master renames phase 1

Fixed ext/pdo_*/tests/pdo_005.phpt tests failure

fix typo

renamed _z_param_long

Fixed parameter parsing

some more pure naming replacements

several fixes -

- param parsing Z_PARAM_STR vs Z_PARAM_STRING
- some functions for new params
- etc

first shot on merging the core fro the int64 branch

cleanup

Fixed compilation warnings about unused labels

Fixed ZTS build

Fast parameter parsing API

This API is experemental. It may be changed or removed.
It should be used only for really often used functions.
(Keep the original parsing code and wrap usage with #ifndef FAST_ZPP)

Partial fix that allows internal constructors to set $this to null.
The address of $this passed to drectly called internal constructor in execute_data->return_value.
Internal constructors should use ZEND_CTOR_MAKE_NULL() macro (insted of previous ZEND_NULL(EG(This))) to do the work.

This patch doesn't fix the problem for indirectly called constructors. e.g. parant::__construct().

Removed EG(active_symbol_table) and use corresponding value from EG(current_execute_data)

Fixed _zend_get_parameters_array

it should not decrease the refcount (spotted by
register_shutdown_function in ext/mysqli/tests/bug49442.phpt)

Avoid useless merge

ext/soap support for phpng (incomplete - just compilable)

Refactor MySQLi (incompleted, only compilable now)

Make they are in the same style of Z_ISREF

Split IS_BOOL into IS_FALSE and IS_TRUE

Optimized zend_leave_helper()

Cleanup (1-st round)

Fix ZTS build

This only makes it compile, it doesn't actually work, presumably
because interned strings are assumed in some places.

Various VM optimizations

Refactored ZVAL flags usage to simplify various checks (e.g. Z_REFCOUNTED(), candidate for GC, etc)

Avoid unnecessry reallocations

Refactored data structures to keep zend_object* instead of a whole zval in some places

Refactor session (incompleted)

Refactored IS_INDIRECT usage for CV and object properties to support HashTable resizing

Refactored EG(active_symbol_table) to be zend_array* instead of HashTable*

Fixed reference support

Fixed refcounted

Fixied calling object closures from internal functions

Changes zend_is_callable() to use zend_string* instead of char*

Fixed exception constructor

Refacting smart_str

Add __debugInfo() magic method

class Foo {
private $val = 'Random, meaningless data';

public function count() { return 42; }

public function __debugInfo() {
return ['count' => $this->count()];
}
}

$f = new Foo;
var_dump($f);

Use better data structures (incomplete)

Use better data structures (incomplete)

backported Zend

Use better data structures (incomplete)

Use better data structures (incomplete)

Use better data structures (incomplete)

Use better data structures (incomplete)

Add ZEND_ARG_CALLABLE_INFO to allow internal function to type hint against callable.

Bump year

Bump year

Bump year

revamp the hash api once more

more semantical replacements LONG vs. INT

massive update semantical LONG vs INT replacements

mass replacement for zend_size_t/php_size_t

Eliminate another straight forward TSRMLS_FETCH() in zend_startup_module()

# For THTTPD:
# The code that uses a call to this function is for older versions of PHP anyway so its not covered

# For Zend OpCache:
# Added a new define for 5.6 and wrapped the code around that so its still compatible with older version

fix 64 bit integer values

first shot for 64 bit array indexes, more broken things to fix

Get basic language tests to all pass (minus xfails)

Re-do a lot of it using a conditional define, and legacy type information for APIs

Always pass return_value_ptr to internal functions

Previous some places passed return_value_ptr only if the function
returned by reference. Now return_value_ptr is always set, even
for functions returning by-value.

This allows you to return zvals without copying their contents. For
this purpose two new macros RETVAL_ZVAL_FAST and RETURN_ZVAL_FAST
are added:

RETVAL_ZVAL_FAST(zv); /* Analog to RETVAL_ZVAL(zv, 1, 0) */
RETURN_ZVAL_FAST(zv); /* Analog to RETURN_ZVAL(zv, 1, 0) */

These macros behave similarly to the non-FAST versions with
copy=1 and dtor=0, with the difference that the FAST versions
will try return the zval without copying by utilizing return_value_ptr.

Evaluate ZVAL_ZVAL arguments only once

Also remove some isref/refcount assignments, which are no longer
necessary (as ZVAL_COPY_VALUE is used now).

Implement variadic function syntax

As per RFC: https://wiki.php.net/rfc/variadics

Always pass return_value_ptr to internal functions

Previous some places passed return_value_ptr only if the function
returned by reference. Now return_value_ptr is always set, even
for functions returning by-value.

This allows you to return zvals without copying their contents. For
this purpose two new macros RETVAL_ZVAL_FAST and RETURN_ZVAL_FAST
are added:

RETVAL_ZVAL_FAST(zv); /* Analog to RETVAL_ZVAL(zv, 1, 0) */
RETURN_ZVAL_FAST(zv); /* Analog to RETURN_ZVAL(zv, 1, 0) */

These macros behave similarly to the non-FAST versions with
copy=1 and dtor=0, with the difference that the FAST versions
will try return the zval without copying by utilizing return_value_ptr.

Evaluate ZVAL_ZVAL arguments only once

Also remove some isref/refcount assignments, which are no longer
necessary (as ZVAL_COPY_VALUE is used now).

Get basic language tests to all pass (minus xfails)

Re-do a lot of it using a conditional define, and legacy type information for APIs

typo fixes (argument)

Don't double-quote name of namespaced function.

ZEND_NS_NAMED_FE(ns, zend_name, name, arg_info)

was resulting in a function declaration of:

ns\"zend_name"()

including the errant quotes.

This diff corrects that. There are currently no uses of ZEND_NS_NAMED_FE
in core and reason to believe that there are no uses in the wild either.

Fixed bug #64239 (Debug backtrace changed behavior since 5.4.10 or 5.4.11)

Add support for non-scalar Iterator keys in foreach

RFC: https://wiki.php.net/rfc/foreach-non-scalar-keys

Fix build problem in C++11

Fix build problem in C++11

Fix build problem in C++11

Fix bug #64099 (Wrong TSRM usage in zend_register_class_alias)

Export zend_parse_parameter()

Happy New Year

Happy New Year

Happy New Year

Fixed bug #62744 (dangling pointers made by zend_disable_class)

the test will be added while commit the fix for #62737

Expose zend_parse_arg() as zend_parse_parameter()

Sometimes, one wants to accept several types for a given parameter. zpp
has special functionality for detecting the NULL type, since the NULL
type is frequently used to skip parameters.

However, supporting several types is otherwise very tedious. There are
many cases where this situation arises -- for instance one may want
to accept an arbitrary number of integer and expect them in an array,
but allow a bare integer too; one may want to accept something that
will be used as an array key (which can be either and int or a string);
one may want to accept integer and double numbers. A search for IS_LONG
reveals many situations where this need arises.

The usual solution is to fetch the argument with 'z'/'Z', check its
type, and then convert the argument, e.g. with convert_to_long_ex().
As explain in the last commit, this has different behavior and
generates inconsistency.

Another -- even more flawed strategy --, is to try zpp with a specific
format, forcing it quiet, and if it fails retrying with another form.
But because zpp changes the arguments directly in the stack (for
instance, using "l" converts the zval in the stack to IS_LONG), the
arguments may look different after the first zpp, leaving subtle bugs.

This commit also allows more complex scenarios, for instance where the
expected type of one parameter depends on other parameters.

- Year++

- Year++

- Year++

Fixed ZE specific compile warnings (Bug #55629)

Fixed ZE specific compile warnings (Bug #55629)

- Added new macro to be used in the end of zend_function_entry declaration (Gwynne)

- Added new macro to be used in the end of zend_function_entry declaration (Gwynne)

- Added new macro to be used in the end of zend_function_entry declaration (Gwynne)

- Added new parameter parsing option (p - for valid path (string without null byte in the middle))
# The tests will be fixed in the next commits

- Added new parameter parsing option (p - for valid path (string without null byte in the middle))
# The tests will be fixed in the next commits

scalar types cleanup

scalar types cleanup

- Year++

- Year++

zend_collect_module_handlers() has to be called after zend_extensions startup, because they can register additional 'hidden' extensions

marked char pointer arguments as const in lots of
places where strings pointed to are not modified
to prevent compiler warnings about discarded qualifiers ...

- Improved memory usage
. zend_function.pass_rest_by_reference is replaced by
ZEND_ACC_PASS_REST_BY_REFERENCE in zend_function.fn_flags
. zend_function.return_reference is replaced by ZEND_ACC_RETURN_REFERENCE
in zend_function.fn_flags
. zend_arg_info.required_num_args removed. it was needed only for internal
functions. Now the first arg_info for internal function (which has special
meaning) is represented by zend_internal_function_info structure.
. zend_op_array.size, size_var, size_literal, current_brk_cont,
backpatch_count moved into CG(context), because they are used only during
compilation.
. zend_op_array.start_op is moved into EG(start_op), because it's used
only for 'interactive' execution of single top-level op-array.
. zend_op_array.done_pass_two is replaced by ZEND_ACC_DONE_PASS_TWO in
zend_op_array.fn_flags.
. op_array.vars array is trimmed (reallocated) during pass_two.
. zend_class_entry.constants_updated is replaced by
ZEND_ACC_CONSTANTS_UPDATED in zend_class_entry.ce_flags
. the size of zend_class_entry is reduced by sharing the same memory space
by different information for internal and user classes.
See zend_class_inttry.info union.

- Missing traits data initialization for internal classes (causing Reflection to crash)

- Fix warning because the comparsion with literal (e.g. INIT_CLASS_ENTRY(..., "Foo", ...))

- Fixed ZTS build (Kalle)

Use interned strings for class names

eliminated unnecessary iterations during request startup/shutdown

Fixed ZTS build

Added caches to eliminate repeatable run-time bindings of functions, classes, constants, methods and properties

- Added scalar typehinting.

spread some more const

Added a number of small performance tweaks and optimizations
. ZEND_RECV now always has IS_CV as its result
. ZEND_CATCH now has to be used only with constant class names
. ZEND_FETCH_DIM_? may fetch array and dimension operans in a different order

sed -i "s#1998-2009#1998-2010#g" **/*.c **/*.h **/*.php

sed -i "s#1998-2009#1998-2010#g" **/*.c **/*.h **/*.php

sed -i "s#1998-2009#1998-2010#g" **/*.c **/*.h **/*.php

- Fixed bug #48971 (Missing ZEND_NS_NAMED_FE macro)

- Fixed bug #48971 (Missing ZEND_NS_NAMED_FE macro)

- Dropped *_TEXT* macros in favor of unicode macros direct usage

- Fixed macro (thanks Kalle)

- Removed:
- UG(unicode) checks
- pcre_cache_entry.unicode_mode
- Changed:
- ZEND_STR_TYPE -> IS_UNICODE
- convert_to_text -> convert_to_unicode
- convert_to_text_ex -> convert_to_unicode_ex

(Felipe, Steph)

MFH: Bump copyright year, 3 of 3.

MFH: Bump copyright year, 3 of 3.

Bump copyright year, 3 of 3.

This commit was manufactured by cvs2svn to create tag 'NEWS'.

Fixed bug #46409 (__invoke method called outside of object context when using array_map)

Fixed bug #46409 (__invoke method called outside of object context when using array_map)

- MFH: Added 'static' into ZEND_BEGIN_ARG_INFO_EX macro

- Added 'static' into ZEND_BEGIN_ARG_INFO_EX macro (again!)

- Next step in namespaces, using / as namespace separator.

- Revert ZEND_BEGIN_ARG_INFO change

- Revert ZEND_BEGIN_ARG_INFO change

- MFH: Added 'static' into ZEND_BEGIN_ARG_INFO_EX macro

- Added 'static' into ZEND_BEGIN_ARG_INFO_EX macro

MFB: move empty_fcall_info* to const table

mark empty_fcall_info and empty_fcall_info_cache as constant. a few less bytes in the dirty page :P

- MFH: Constness (Added const qualifier to several function parameters)

- Constness (Added const qualifier to several function parameters)

- MFH: Added parameter TSRMLS_DC in zend_is_callable()

- Added parameter TSRMLS_DC in zend_is_callable()

add zend_u_read_property() and zend_u_update_property()

Fixed is_callable/call_user_func mess that had done different things for very similar arguments e.g. array("A","B") and "A::B"

Fixed is_callable/call_user_func mess that had done different things for very similar arguments e.g. array("A","B") and "A::B"

LSB parent/self forwarding

LSB parent/self forwarding

deprecate zend_get_parameters_ex

deprecate zend_get_parameters_ex

MFH: Add array_init_size() and use it where array size is known at initialization

Add array_init_size() and use it where array size is known at initialization

Added API to use namesapces in internal extensions

Added API to use namesapces in internal extensions

Lazy EG(active_symbol_table) initialization

Lazy EG(active_symbol_table) initialization

MFH: Added new macro for check void parameters.
(deprecating ZEND_WRONG_PARAM_COUNT for this cases)

Added new macro for check void parameters.
(deprecating ZEND_WRONG_PARAM_COUNT for this cases)

- MFB static callable message mess

[DOC]
- Fix callable/static mess, the following will now all result in a E_STRICT
. binding a dynamic function as a static callback
. static call of a dynamic function
. is_callable() on a static binding to a dynamic function
# [marcus@frodo PHP_5_3]$ php -a -d error_reporting=8191
# make: `sapi/cli/php' is up to date.
# Interactive shell
#
# php > class t{ function f() { echo "Funny\n"; } }
# php > $c = array("t","f");
# php > call_user_func($c);
#
# Strict Standards: call_user_func() expects parameter 1 to be a valid callback, non-static method t::f() cannot be called statically in php shell code on line 1
# Funny
# php > var_dump(is_callable($c));
#
# Strict Standards: Non-static method t::f() cannot be called statically in php shell code on line 1
# bool(true)
# php > t::f();
#
# Strict Standards: Non-static method t::f() should not be called statically in php shell code on line 1
# Funny
# php >

Fixed compilation warnings

Fixed comilation warnings

MFH: Bump copyright year, 2 of 2.

MFH: Bump copyright year, 2 of 2.

Bump copyright year, 2 of 2.

- MFH from HEAD:
. Folding tags
. Parameter parsing
. SPL debug info
. array function improvements (not all yet)
. Improvements to function calling with call_user_* functions
. Improvements to debugging info in var_dump/print_r
# I propably forgot already something but this all was pretty close tied
# to each other so it wasn't possible to do it in parts.

ws + cs

MFH: Added macros for managing zval refcounts and is_ref statuses

Added macros for managing zval refcounts and is_ref statuses

Added support for __callstatic() magic method (missing part). (Sara)

Added support for __callstatic() magic method. (Sara)

Improved memory usage by movig constants to read only memory. (Dmitry, Pierre)

Improved memory usage by movig constants to read only memory. (Dmitry, Pierre)

fix C++ extensions build
C++ doesn't allow implicit casting of void* to Uchar*, we have to do it explicitly

Add support got zend_class_entry->get_static_method() and matching __callStatic() userspace method @doc

Fixed ascii->unicode conversion (terminating unicode character must be 0)

add SET_VAR_ASCII_STRINGL()

WIN64 support

WIN64 support

- Fix potential issue with 'f'-parameter parsing
- Complete zend_fcall_info_*() API

- More ZEND_API's

Typos.

- Add ^ specifier that returns original string type before conversion.
- Add ZVAL_ENC_STRING[L] macro that allows returning either a binary
string or an encoded strings as Unicode based on type, instead of
UG(unicode)

- Consistency: macros shall be uppercased (as requested by Andrei)

- Add zstrlen() helper

Remove const warnings. (Andrey)

Add add_property_zstr(l)(_ex)()

MFH: Bump year.

Bump year.

fix typo

MFB:
- Fixed incorrect function names on FreeBSD where inet_pton() was named
__inet_pton() and inet_ntop() was named __inet_ntop()
- Fixed bug #39685 (iconv() - undefined function)
- Fixed bug #38852 (XML-RPC Breaks iconv)

- Fixed incorrect function names on FreeBSD where inet_pton() was named
__inet_pton() and inet_ntop() was named __inet_ntop()
- Fixed bug #39685 (iconv() - undefined function)
- Fixed bug #38852 (XML-RPC Breaks iconv)

- Marcus was too quick. Let's put type before zstr in the macros.
- Also mark get_include_path() and restore_include_path() with U.

- Fix ZVAL_ZSTRL

Fix ZTS build

Make all macros (RETURN_*, RETVAL_*, ZVAL_*, add_*) that convert binary
strings to Unicode actually issues errors on failure. I'm surprised we
haven't done this already.

Guard against ambiguous 'else' clauses.

Unicode support.
Now the real UG(unicode) value is available during MINIT calls.

fix typo (patch by Mike Wallner)

Turn doc comments into zstr strings with corresponding adjustments.

fix add_u_assoc_null() macro

Fix potential (and real) leaks due to bad macro writing. Grrr.

Fix possible double macro expansion.

Fix thread safety.

Implement add_utf8_property_* API.

Extend zend_fcall_info_args functions. (Patch from Mike Wallner)

Hash functions for UTF-8 keys.

Disabled autoconversion of hash keys (from string to unicode) for PHP arrays

More work on Unicode support in PCRE. When UG(unicode) is on, all
strings passed to PCRE have to be IS_UNICODE or IS_STRING in UTF-8
encoding. Failure to do so will result in unpredictable results.

Add a couple more UTF-8 functions.

Add APIs for UTF-8 strings (common with XML, PCRE, etc)

Fix some API definitions.

add_next_index_zstr[l]()

implement zend_unicode_to_string() and zend_string_to_unicode()
part #1 (of 2)

Add add_assoc_zstr_ex() and related.

Add macros to be able to initialize/return values based on zstr.

- Add new unicode functions: add_u_assoc_*[_ex]() which allow to add values
using a unicode key.

Rewrite array_map() to use params API with fci cache and mark it with U.

New memory manager

New memory manager

- Upgrade usort() to support Unicode (including valid Unicode callbacks).
- Make usort() use 'f' specifier for function call info/cache.

MFH: Added automatic module globals management.

Added automatic module globals management.

- MFH zend_fcall_info_*() and parameter parsing option 'f'
# Right now i see this as the best option but we might shuffle code around
# later if someone comes up with a better solution.

- Take care of refcounting in zend_fcall_info_*() functions
- Add docu
# I know it is unpopular to add docu here but i think we should add more

- Ease writing functions that deal with php function 'pointers'

MFB: fix error messages when converting objects to other types

fix error messages when converting objects to other types
add new function
MFB will follow soon

- MFH as discussed
. zend_exception_get_default() -> zend_exception_get_default(TSRMLS_D)
. zend_get_error_exception() -> zend_get_error_exception(TSRMLS_D)
. added E_RECOVERABLE_ERROR
. added ZEND_TOSTRING_FUNC_NAME
. added __tostring function cache to zend_class_entry
. added ZEND_NAMED_ME
. modified ZEND_ME_MAPPING to support method flags
. added ZEND_MN
. method entries now use prefix "zim_" instead of "zif_"
. drop EG(ze1_compatibility_mode)
. changed cast handler, now without (int should_free):
typedef int (*zend_object_cast_t)(zval *readobj, zval *retval, int type TSRMLS_DC);
. changed get_iterator, now receives whether value is by ref:
zend_object_iterator *(*get_iterator)(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
. added zend_objects_store_add_ref_by_handle
. added zend_objects_store_del_ref_by_handle
. convert_to_explicit_type(pzv, type)

- Methods have flags

- MFB: WS

Add a global ASCII connverter, macros to return single codepoints
(UCHAR32), and zend_unicode_to_ascii() function.

Overload 'duplicate' arg as applied to:
add_((next_)?index|assoc)_(ascii|rt)_stringl?(_ex)?
and
(ZVAL|RETVAL|RETURN)_(ASCII|RT|U)_STRINGL?

#define ZSTR_DUPLICATE (1<<0)
#define ZSTR_AUTOFREE (1<<1)

Duplicate keeps traditional value of '1', additional bit '2' tells
unicode mode conversion to automatically free the original string
in order to avoid leaks due to conversion on a value otherwise being
"given" to the engine.

/* Uses s as-is for non-unicode, or frees s after converting to unicode */
{
char *s = estrdup("Hello");
ZVAL_RT_STRING(pzv, s, ZSTR_AUTOFREE);
}

/* Duplicates for non-unicode, or converts (but doesn't free original) */
{
char *s = "Hello";
ZVAL_RT_STRING(pzv, s, ZSTR_DUPLICATE);
}

/* Uses as-is for non-unicode, or converts (but doesn't free original) */
{
char *s = "Hello";
zval zv;
ZVAL_RT_STRING(&zv, s, 0);

/* use zv for some temporary purpose */

/* It's now necessary to manually free this generated value */
if (UG(unicode)) {
zval_dtor(&zv);
}
}

Added RETVAL_EMPTRY_TEXT() and RETURN_EMPTY_TEXT() macroses

- Add missing function for completeness

- Add missing function for completeness

- Separate ZEND_METHOD from ZEND_FUNCTION

Unicode support: MS Visual C compatibility

- MFH: Function deprecation flag

- Add macros to mark functions/alias functions as deprecated
(mentioned by Sara and obviously neccessary)
- Fix function/method flag error detection logic

Unicode support

Portable unicode string API:
- use the same type (int) for zval.value.usr.len and zval.value.str.len
- use union "zstr" as char*/UChar* mixture instead of void*
- Z_UNISTR() and Z_UNILEN() no longer check for Z_TYPE()
- nuke int32_t from ZE (not finisned)

WS

Preparation for portable string API (use macroses to access zval).

Made server wide switch for unicode on/off (according to PDM).

Unicode stuff is changed according to decision maden on PDM.
Now IS_BINRAY data type is removed and IS_STRING starts behave as IS_BINARY in unicode mode. IS_STRING is incompatible with IS_UNICODE, so ALL functions should be improved to support unicode mode.

- Update copyright notices to 2006

- Update copyright notices to 2006

- Add new const

- Simplify and synch is_callable_ex() with actual execution code
. Allow array($this, 'parent::method') for function 'pointers'
. Spit out E_STRICT in case of erroneous use of function 'pointers'

Fixed bug #34729 (Crash in ZTS mode under Apache)

Fixed bug #34729 (Crash in ZTS mode under Apache)

Fixed bug #34879 (str_replace, array_map corrupt negative array indexes on 64-bit platforms)

Fixed bug #34879 (str_replace, array_map corrupt negative array indexes)

- MFH zend_is_callable_ex() returns zend_class_entry* if available

- Make zend_is_callable_ex() return the class netry if available

- Add propper casting

Changed __toString() behavior to call it in all necessary places

- WS fix

Support for class constants and static members for internal classes

Support for class constants and static members for internal classes

Unicode support

Unicode support cleanup

zend_is_callable() and zend_make_callable() were changed to return readable function name as zval (instead of string).

*** empty log message ***

Unicode support cleanup

- Implement zend_codepoint_to_uchar().
- Rename and fix zend_get_unified_string_type() so that it does not
allow mixing of binary and Unicode types.

Suppoer for unicode exception messages

Unicode support for extract()

Fixed several unicode related bugs

Unicode support

ZTS fixes.

Unicode support

Bump up the year

- Add convenience function zend_is_callable_ex() and base zend_is_callable
and zend_make_callable on it. This functions allows to check if a php
variable is a callable function and returns its function pointer as well
as object if possible.
# Commit this now so we can use it in 5.1.* series as discussed with Andi.

Fixed bug in new module statrup mechanism

Fixed bug #33512 (Add missing support for isset()/unset() overloading to complement the property get/set methods)

Fixed bug #31158 (array_splice on $GLOBALS crashes)

Restored old behavior of zend_statup_module()

fix various "Class entry requested for an object without PHP class" messages
when working with non-PHP objects.
# Using Z_OBJCE(object)->name is usually bad idea unless you know it's
# a pure PHP object

Improved PHP extension loading mechanism with support for module dependencies and conflicts.

Allowed return by refrence from internal functions

Added array type hinting. (This patch requires full re-make)

Fixed bug #29210 (Function: is_callable - no support for private and protected classes)

- Add ReflectionProperty::getDocComment()

- These must be initailized

added some missing zend_[declare|update]_property_...() convenience
functions for bool, double and binary safe string data

- Fix #31651 (ReflectionClass::getDefaultProperties segfaults with arrays.)

- Rename delete_global_variable() to zend_delete_global_variable()

- Commit the variable fetch optimization.
- Extensions which delete global variables need to use new special function
- delete_global_variable() (I'm about to rename it) to remove them.
- Will post to internals@ or via commit messages if there's anything else.

Simplify/Optmize magic method calls (__get/__set/__call/__clone/__destruct)

- Recommit:
- Check signature of magic methods
- Register __get/__set/__call for internal classes

- Roll back VM commit

- Check signature of magic methods
- Register __get/__set/__call for internal classes

- Nuke empty_string. It is a reminanent from the time where RETURN_FALSE()
used to return "" and not bool(false). It's not worth keeping it because
STR_FREE() and zval_dtor() always have to check for it and it slows down
the general case. In addition, it seems that empty_string has been abused
quite a lot, and was used not only for setting zval's but generally in
PHP code instead of "", which wasn't the intention. Last but not least,
nuking empty_string should improve stability as I doubt every place
correctly checked if they are not mistakenly erealloc()'ing it or
calling efree() on it.
NOTE: Some code is probably broken. Each extension maintainer should
check and see that my changes are OK. Also, I haven't had time to touch
PECL yet. Will try and do it tomorrow.

Add missing declaration

Fix order of macro parameter (synch with other macros)

- Fix Reflection class names
- Add ability to get the extension an internal class was defined in
# This is the patch Andi and me used to search for underscrores...

- Replaced the exec_finished hook by the zend_post_deactive hook for
extensions. The new hook will be run after the symbol table and destructors
are run. (Derick)

Fix zend_parse_method_parameters_ex() and make it consistant with
zend_parse_method_parameters().
# Obviously its only place of use is in pdo just right now.

- Improve ARG_INFO() macros to support supplying required_num_args
- Initial fix for foreach($o->mthd()->arr) crash (now leaks)

more EXTERN_C wrapping of ZEND_API prototypes

- Check return-by-reference bit when implementing interface prototypes
- Add infrastructure for built-in functions to hint whether they
return by reference or not. It is NOT currently used for anything,
except for interface prototypes (you can use it to request that the
function that implements your prototype returns by reference or
doesn't return by reference).
For downwards compatibility - by default, interface prototypes are
agnostic as to whether the function that implements them returns
by reference or not. Use ZEND_BEGIN_ARG_INFO_EX() with
ZEND_RETURN_VALUE/ZEND_RETURN_REFERENCE to change that.
- Fix ArrayAccess::getOffset() to conduct additional checks.
If your getOffset() should work with multidimensional arrays - it
must return by reference.

Add zend_get_module_started() to quickly check whether a module is present
and its MINIT function has been called.

Add missing macro
# by popular demand, more and more exts need this

- Happy new year and PHP 5 for rest of the files too..
# Should the LICENSE and Zend/LICENSE dates be updated too?

Fix order of class_entry member initialization (needed for example for DOM)
# You need to completley rebuild PHP after this patch.

export these symbols for use by SPL as a shared extension

Free the zval container only if it should be freed and was not copied.

This takes the address of a zval ptr

Add macros to return values of other zvals.
This is needed because one cannot use REPLACE_ZVAL_VALUE with return_value.

Add method alias macro

Add zend_make_callable() which allows to make zval's callable zval's.
At the moment this function only converts strings of the form class::method
to an array(class,method).

Expand Interface C API.
In short: zend_class_entry->interface_gets_implemented() allows to modify
the class entry of a class when an interface gets implemented.

Fix class/iterator relationship & handling

Added c-api for iterators
# After 4 Month work and endless discussions...

Add oo support function zend_class_implements()

this little piggy broke lots of things...eg. _function_check_flag in reflection api.

Ensure lval to have a *boolean* value.

Fix handling of static properties initialized to arrays

- Add zend_merge_properties() which is designed to serve *_fetch_object().
- Explain drawbacks of object_and_properties_init and zend_merge_properties.
#
# I guess we can live with the purity problem of potentially calling __set()
# of an object which wasn't already ctored.
#

- Provide appropriate way to destroy internal zval's.
- Allow internal zval's of type string and disallow complex types.
- Define the default string for extensions at class level instead of ctor.

Don't identify alias'ed functions

One of PPP is needed, too

- Add fn_flag ZEND_ACC_ALIAS
- Unify way of function_entry generation by new macro ZEND_FENTRY

Add property read code and use that in default exception class

Internal classes can now have default properties.

Fix warnings

explicitly cast size_t to zend_uint to avoid warnings on 64 bit platforms.

Simplify abstract method declaration

Try to put an end to the endless number of call_user_function variants.
zend_call_function() now takes a structure that should contain all of the
necessary information. If further information is necessary in the future,
then we'll be able to add it without having to introduce a new function.

As for caching - the 2nd, optional argument is a struct that can hold all
of the information that's necessary to invoke the function, including its
handler, scope and object it operates on (if any). Note that you may only
use a cache if the arguments you provide to zend_call_function() are
identical to the ones of the last call, except for the argument and return
value information.


The recently introduced fast_call_user_function() was removed

I fixed most of the places that used fast_call_user_function() to use caching
but there are still some that need to be fixed (XML and reflection)

ntroduce infrastructure for supplying information about arguments,
including:

- Whether or not to pass by ref (replaces the old arg_types, with arg_info)
- Argument name (for future use, maybe introspection)
- Class/Interface name (for type hints)
- If a class/interface name is available, whether to allow a null instance

Both user and builtin functions share the same data structures.

To declare a builtin function that expects its first arg to be an instance
of class 'Person', its second argument as a regular arg, and its third by
reference, use:

ZEND_BEGIN_ARG_INFO(my_func_arg_info, 0)
ZEND_ARG_OBJ_INFO(0, someone, Person, 1)
ZEND_ARG_PASS_INFO(0)
ZEND_ARG_PASS_INFO(1)
ZEND_END_ARG_INFO();

and use my_func_arg_info as the arg_info parameter to the ZEND_FE() family
of macros.

The first arg to each ZEND_ARG_*() macro is whether or not to pass by ref.

The boolean arg to ZEND_BEGIN_ARG_INFO() tells the engine whether to treat
the arguments for which there's no explicit information as pass by reference
or not.
The boolean argument to ZEND_ARG_OBJ_INFO() (4th arg) is whether or not to allownull values.

Add exec_finished() callback for modules - this is the last place where the
modules may touch the symbol table reliably

reverted at Andi's request. replaced with more generic wrapper.

Rework zend_do_declare_property and related code into one code base

add convenience functions or adding class properties. Ok'd for commit by Andi.

updating license information in the headers.

rm namespace leftovers

MEGA-patch: namespaces are R.I.P.

Revert to sizeof()

add fast_call_user_function()

C++ compile fixes

Allow functions in internal namespaces (for example factories)

Change get_class() so that it returns qualified names for namespaced
classes.

*HEADS UP*: get_class_name() handler interface is changed, now it should
allocate the space it returns with emalloc, and the users free it. If
anyone has problems with it or has suggestions how to do it without this -
please tell.

Also: make function_exists() understand namespaces.

Rename zend_register_internal_class_in_ns() to a better, less filling,
but with the same great taste zend_register_internal_ns_class().

Introduce ZEND_ME() and ZEND_METHOD() macros. Use these for declaring
class methods to avoid name collisions.

Fix namespace issues