test.c

/*
 +----------------------------------------------------------------------+
 | Copyright (c) The PHP Group |
 +----------------------------------------------------------------------+
 | This source file is subject to version 3.01 of the PHP license, |
 | that is bundled with this package in the file LICENSE, and is |
 | available through the world-wide-web at the following url: |
 | https://www.php.net/license/3_01.txt |
 | If you did not receive a copy of the PHP license and are unable to |
 | obtain it through the world-wide-web, please send a note to |
 | license@php.net so we can mail you a copy immediately. |
 +----------------------------------------------------------------------+
 | Author: |
 +----------------------------------------------------------------------+
*/

#include"zend_modules.h"
#ifdefHAVE_CONFIG_H
# include"config.h"
#endif

#include"php.h"
#include"php_ini.h"
#include"ext/standard/info.h"
#include"php_test.h"
#include"observer.h"
#include"fiber.h"
#include"iterators.h"
#include"object_handlers.h"
#include"zend_attributes.h"
#include"zend_enum.h"
#include"zend_interfaces.h"
#include"zend_weakrefs.h"
#include"Zend/Optimizer/zend_optimizer.h"
#include"Zend/zend_alloc.h"
#include"test_arginfo.h"
#include"zend_call_stack.h"
#include"zend_exceptions.h"
#include"zend_mm_custom_handlers.h"

// `php.h` sets `NDEBUG` when not `PHP_DEBUG` which will make `assert()` from
// assert.h a no-op. In order to have `assert()` working on NDEBUG builds, we
// undefine `NDEBUG` and re-include assert.h
#undef NDEBUG
#include"assert.h"

#if defined(HAVE_LIBXML) && !defined(PHP_WIN32)
# include<libxml/globals.h>
# include<libxml/parser.h>
#endif

ZEND_DECLARE_MODULE_GLOBALS(zend_test)

staticzend_class_entry*zend_test_interface;
staticzend_class_entry*zend_test_class;
staticzend_class_entry*zend_test_child_class;
staticzend_class_entry*zend_attribute_test_class;
staticzend_class_entry*zend_test_trait;
staticzend_class_entry*zend_test_attribute;
staticzend_class_entry*zend_test_repeatable_attribute;
staticzend_class_entry*zend_test_parameter_attribute;
staticzend_class_entry*zend_test_property_attribute;
staticzend_class_entry*zend_test_attribute_with_arguments;
staticzend_class_entry*zend_test_class_with_method_with_parameter_attribute;
staticzend_class_entry*zend_test_child_class_with_method_with_parameter_attribute;
staticzend_class_entry*zend_test_class_with_property_attribute;
staticzend_class_entry*zend_test_forbid_dynamic_call;
staticzend_class_entry*zend_test_ns_foo_class;
staticzend_class_entry*zend_test_ns_unlikely_compile_error_class;
staticzend_class_entry*zend_test_ns_not_unlikely_compile_error_class;
staticzend_class_entry*zend_test_ns2_foo_class;
staticzend_class_entry*zend_test_ns2_ns_foo_class;
staticzend_class_entry*zend_test_unit_enum;
staticzend_class_entry*zend_test_string_enum;
staticzend_class_entry*zend_test_int_enum;
staticzend_class_entry*zend_test_magic_call;
staticzend_object_handlerszend_test_class_handlers;

staticintle_throwing_resource;

staticZEND_FUNCTION(zend_test_func)
{
RETVAL_STR_COPY(EX(func)->common.function_name);

/* Cleanup trampoline */
ZEND_ASSERT(EX(func)->common.fn_flags&ZEND_ACC_CALL_VIA_TRAMPOLINE);
zend_string_release(EX(func)->common.function_name);
zend_free_trampoline(EX(func));
EX(func) =NULL;
}

staticZEND_FUNCTION(zend_test_array_return)
{
ZEND_PARSE_PARAMETERS_NONE();
}

staticZEND_FUNCTION(zend_test_nullable_array_return)
{
ZEND_PARSE_PARAMETERS_NONE();

RETURN_NULL();
}

staticZEND_FUNCTION(zend_test_void_return)
{
/* dummy */
ZEND_PARSE_PARAMETERS_NONE();
}

staticvoidpass1(zend_script*script, void*context)
{
php_printf("pass1\n");
}

staticvoidpass2(zend_script*script, void*context)
{
php_printf("pass2\n");
}

staticZEND_FUNCTION(zend_test_deprecated)
{
zval*arg1;

zend_parse_parameters(ZEND_NUM_ARGS(), "|z", &arg1);
}

staticZEND_FUNCTION(zend_test_deprecated_attr)
{
ZEND_PARSE_PARAMETERS_NONE();
}

/* Create a string without terminating null byte. Must be terminated with
 * zend_terminate_string() before destruction, otherwise a warning is issued
 * in debug builds. */
staticZEND_FUNCTION(zend_create_unterminated_string)
{
zend_string*str, *res;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &str) ==FAILURE) {
RETURN_THROWS();
 }

res=zend_string_alloc(ZSTR_LEN(str), 0);
memcpy(ZSTR_VAL(res), ZSTR_VAL(str), ZSTR_LEN(str));
/* No trailing null byte */

RETURN_STR(res);
}

/* Enforce terminate null byte on string. This avoids a warning in debug builds. */
staticZEND_FUNCTION(zend_terminate_string)
{
zend_string*str;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &str) ==FAILURE) {
RETURN_THROWS();
 }

ZSTR_VAL(str)[ZSTR_LEN(str)] ='\0';
}

/* Cause an intentional memory leak, for testing/debugging purposes */
staticZEND_FUNCTION(zend_leak_bytes)
{
zend_longleakbytes=3;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &leakbytes) ==FAILURE) {
RETURN_THROWS();
 }

emalloc(leakbytes);
}

/* Leak a refcounted variable */
staticZEND_FUNCTION(zend_leak_variable)
{
zval*zv;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zv) ==FAILURE) {
RETURN_THROWS();
 }

if (!Z_REFCOUNTED_P(zv)) {
zend_error(E_WARNING, "Cannot leak variable that is not refcounted");
return;
 }

Z_ADDREF_P(zv);
}

/* Tests Z_PARAM_OBJ_OR_STR */
staticZEND_FUNCTION(zend_string_or_object)
{
zend_string*str;
zend_object*object;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_OBJ_OR_STR(object, str)
ZEND_PARSE_PARAMETERS_END();

if (str) {
RETURN_STR_COPY(str);
 } else {
RETURN_OBJ_COPY(object);
 }
}

/* Tests Z_PARAM_OBJ_OR_STR_OR_NULL */
staticZEND_FUNCTION(zend_string_or_object_or_null)
{
zend_string*str;
zend_object*object;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_OBJ_OR_STR_OR_NULL(object, str)
ZEND_PARSE_PARAMETERS_END();

if (str) {
RETURN_STR_COPY(str);
 } elseif (object) {
RETURN_OBJ_COPY(object);
 } else {
RETURN_NULL();
 }
}

/* Tests Z_PARAM_OBJ_OF_CLASS_OR_STR */
staticZEND_FUNCTION(zend_string_or_stdclass)
{
zend_string*str;
zend_object*object;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_OBJ_OF_CLASS_OR_STR(object, zend_standard_class_def, str)
ZEND_PARSE_PARAMETERS_END();

if (str) {
RETURN_STR_COPY(str);
 } else {
RETURN_OBJ_COPY(object);
 }
}

staticZEND_FUNCTION(zend_test_compile_string)
{
zend_string*source_string=NULL;
zend_string*filename=NULL;
zend_longposition=ZEND_COMPILE_POSITION_AT_OPEN_TAG;

ZEND_PARSE_PARAMETERS_START(3, 3)
Z_PARAM_STR(source_string)
Z_PARAM_STR(filename)
Z_PARAM_LONG(position)
ZEND_PARSE_PARAMETERS_END();

zend_op_array*op_array=NULL;

op_array=compile_string(source_string, ZSTR_VAL(filename), position);

if (op_array) {
zvalretval;

zend_try {
ZVAL_UNDEF(&retval);
zend_execute(op_array, &retval);
 } zend_catch {
destroy_op_array(op_array);
efree_size(op_array, sizeof(zend_op_array));
zend_bailout();
 } zend_end_try();

destroy_op_array(op_array);
efree_size(op_array, sizeof(zend_op_array));
 }

return;
}

/* Tests Z_PARAM_OBJ_OF_CLASS_OR_STR_OR_NULL */
staticZEND_FUNCTION(zend_string_or_stdclass_or_null)
{
zend_string*str;
zend_object*object;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_OBJ_OF_CLASS_OR_STR_OR_NULL(object, zend_standard_class_def, str)
ZEND_PARSE_PARAMETERS_END();

if (str) {
RETURN_STR_COPY(str);
 } elseif (object) {
RETURN_OBJ_COPY(object);
 } else {
RETURN_NULL();
 }
}

/* Tests Z_PARAM_NUMBER_OR_STR */
staticZEND_FUNCTION(zend_number_or_string)
{
zval*input;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_NUMBER_OR_STR(input)
ZEND_PARSE_PARAMETERS_END();

switch (Z_TYPE_P(input)) {
caseIS_LONG:
RETURN_LONG(Z_LVAL_P(input));
caseIS_DOUBLE:
RETURN_DOUBLE(Z_DVAL_P(input));
caseIS_STRING:
RETURN_STR_COPY(Z_STR_P(input));
EMPTY_SWITCH_DEFAULT_CASE();
 }
}

/* Tests Z_PARAM_NUMBER_OR_STR_OR_NULL */
staticZEND_FUNCTION(zend_number_or_string_or_null)
{
zval*input;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_NUMBER_OR_STR_OR_NULL(input)
ZEND_PARSE_PARAMETERS_END();

if (!input) {
RETURN_NULL();
 }

switch (Z_TYPE_P(input)) {
caseIS_LONG:
RETURN_LONG(Z_LVAL_P(input));
caseIS_DOUBLE:
RETURN_DOUBLE(Z_DVAL_P(input));
caseIS_STRING:
RETURN_STR_COPY(Z_STR_P(input));
EMPTY_SWITCH_DEFAULT_CASE();
 }
}

staticZEND_FUNCTION(zend_weakmap_attach)
{
zval*value;
zend_object*obj;

ZEND_PARSE_PARAMETERS_START(2, 2)
Z_PARAM_OBJ(obj)
Z_PARAM_ZVAL(value)
ZEND_PARSE_PARAMETERS_END();

if (zend_weakrefs_hash_add(&ZT_G(global_weakmap), obj, value)) {
Z_TRY_ADDREF_P(value);
RETURN_TRUE;
 }
RETURN_FALSE;
}

staticZEND_FUNCTION(zend_weakmap_remove)
{
zend_object*obj;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_OBJ(obj)
ZEND_PARSE_PARAMETERS_END();

RETURN_BOOL(zend_weakrefs_hash_del(&ZT_G(global_weakmap), obj) ==SUCCESS);
}

staticZEND_FUNCTION(zend_weakmap_dump)
{
ZEND_PARSE_PARAMETERS_NONE();
RETURN_ARR(zend_array_dup(&ZT_G(global_weakmap)));
}

staticZEND_FUNCTION(zend_get_current_func_name)
{
ZEND_PARSE_PARAMETERS_NONE();

zend_string*function_name=get_function_or_method_name(EG(current_execute_data)->prev_execute_data->func);

RETURN_STR(function_name);
}

#if defined(HAVE_LIBXML) && !defined(PHP_WIN32)
staticZEND_FUNCTION(zend_test_override_libxml_global_state)
{
ZEND_PARSE_PARAMETERS_NONE();

ZEND_DIAGNOSTIC_IGNORED_START("-Wdeprecated-declarations")
xmlLoadExtDtdDefaultValue=1;
xmlDoValidityCheckingDefaultValue=1;
 (void) xmlPedanticParserDefault(1);
 (void) xmlSubstituteEntitiesDefault(1);
 (void) xmlLineNumbersDefault(1);
 (void) xmlKeepBlanksDefault(0);
ZEND_DIAGNOSTIC_IGNORED_END
}
#endif

/* TESTS Z_PARAM_ITERABLE and Z_PARAM_ITERABLE_OR_NULL */
staticZEND_FUNCTION(zend_iterable)
{
zval*arg1, *arg2;

ZEND_PARSE_PARAMETERS_START(1, 2)
Z_PARAM_ITERABLE(arg1)
Z_PARAM_OPTIONAL
Z_PARAM_ITERABLE_OR_NULL(arg2)
ZEND_PARSE_PARAMETERS_END();
}

staticZEND_FUNCTION(zend_iterable_legacy)
{
zval*arg1, *arg2;

ZEND_PARSE_PARAMETERS_START(1, 2)
Z_PARAM_ITERABLE(arg1)
Z_PARAM_OPTIONAL
Z_PARAM_ITERABLE_OR_NULL(arg2)
ZEND_PARSE_PARAMETERS_END();

RETURN_COPY(arg1);
}

ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zend_iterable_legacy, 0, 1, IS_ITERABLE, 0)
ZEND_ARG_TYPE_INFO(0, arg1, IS_ITERABLE, 0)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, arg2, IS_ITERABLE, 1, "null")
ZEND_END_ARG_INFO()

staticconstzend_function_entryext_function_legacy[] = {
ZEND_FE(zend_iterable_legacy, arginfo_zend_iterable_legacy)
ZEND_FE_END
};

/* Call a method on a class or object using zend_call_method() */
staticZEND_FUNCTION(zend_call_method)
{
zend_string*method_name;
zval*class_or_object, *arg1=NULL, *arg2=NULL;
zend_object*obj=NULL;
zend_class_entry*ce=NULL;
intargc=ZEND_NUM_ARGS();

ZEND_PARSE_PARAMETERS_START(2, 4)
Z_PARAM_ZVAL(class_or_object)
Z_PARAM_STR(method_name)
Z_PARAM_OPTIONAL
Z_PARAM_ZVAL(arg1)
Z_PARAM_ZVAL(arg2)
ZEND_PARSE_PARAMETERS_END();

if (Z_TYPE_P(class_or_object) ==IS_OBJECT) {
obj=Z_OBJ_P(class_or_object);
ce=obj->ce;
 } elseif (Z_TYPE_P(class_or_object) ==IS_STRING) {
ce=zend_lookup_class(Z_STR_P(class_or_object));
if (!ce) {
zend_error_noreturn(E_ERROR, "Unknown class '%s'", Z_STRVAL_P(class_or_object));
return;
 }
 } else {
zend_argument_type_error(1, "must be of type object|string, %s given", zend_zval_value_name(class_or_object));
return;
 }

ZEND_ASSERT((argc >= 2) && (argc <= 4));
zend_call_method(obj, ce, NULL, ZSTR_VAL(method_name), ZSTR_LEN(method_name), return_value, argc-2, arg1, arg2);
}

/* Instantiate a class and run the constructor via object_init_with_constructor */
staticZEND_FUNCTION(zend_object_init_with_constructor)
{
zend_class_entry*ce=NULL;
zval*args;
uint32_tnum_args;
HashTable*named_args;

ZEND_PARSE_PARAMETERS_START(1, -1)
Z_PARAM_CLASS(ce)
Z_PARAM_VARIADIC_WITH_NAMED(args, num_args, named_args)
ZEND_PARSE_PARAMETERS_END();

zvalobj;
/* We don't use return_value directly to check for memory leaks of the API on failure */
zend_resultstatus=object_init_with_constructor(&obj, ce, num_args, args, named_args);
if (status==FAILURE) {
RETURN_THROWS();
 }
ZEND_ASSERT(!EG(exception));
ZVAL_COPY_VALUE(return_value, &obj);
}

staticZEND_FUNCTION(zend_get_unit_enum)
{
ZEND_PARSE_PARAMETERS_NONE();

RETURN_OBJ_COPY(zend_enum_get_case_cstr(zend_test_unit_enum, "Foo"));
}

staticZEND_FUNCTION(zend_test_zend_ini_parse_quantity)
{
zend_string*str;
zend_string*errstr;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STR(str)
ZEND_PARSE_PARAMETERS_END();

RETVAL_LONG(zend_ini_parse_quantity(str, &errstr));

if (errstr) {
zend_error(E_WARNING, "%s", ZSTR_VAL(errstr));
zend_string_release(errstr);
 }
}

staticZEND_FUNCTION(zend_test_zend_ini_parse_uquantity)
{
zend_string*str;
zend_string*errstr;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STR(str)
ZEND_PARSE_PARAMETERS_END();

RETVAL_LONG((zend_long)zend_ini_parse_uquantity(str, &errstr));

if (errstr) {
zend_error(E_WARNING, "%s", ZSTR_VAL(errstr));
zend_string_release(errstr);
 }
}

staticZEND_FUNCTION(zend_test_zend_ini_str)
{
ZEND_PARSE_PARAMETERS_NONE();

RETURN_STR(ZT_G(str_test));
}

staticZEND_FUNCTION(zend_test_is_string_marked_as_valid_utf8)
{
zend_string*str;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STR(str)
ZEND_PARSE_PARAMETERS_END();

RETURN_BOOL(ZSTR_IS_VALID_UTF8(str));
}

staticZEND_FUNCTION(ZendTestNS2_namespaced_func)
{
ZEND_PARSE_PARAMETERS_NONE();
RETURN_TRUE;
}

staticZEND_FUNCTION(ZendTestNS2_namespaced_deprecated_func)
{
ZEND_PARSE_PARAMETERS_NONE();
}

staticZEND_FUNCTION(ZendTestNS2_ZendSubNS_namespaced_func)
{
ZEND_PARSE_PARAMETERS_NONE();
RETURN_TRUE;
}

staticZEND_FUNCTION(ZendTestNS2_ZendSubNS_namespaced_deprecated_func)
{
ZEND_PARSE_PARAMETERS_NONE();
}

staticZEND_FUNCTION(zend_test_parameter_with_attribute)
{
zend_string*parameter;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STR(parameter)
ZEND_PARSE_PARAMETERS_END();

RETURN_LONG(1);
}

staticZEND_FUNCTION(zend_test_attribute_with_named_argument)
{
ZEND_PARSE_PARAMETERS_NONE();
}

#ifdefZEND_CHECK_STACK_LIMIT
staticZEND_FUNCTION(zend_test_zend_call_stack_get)
{
zend_call_stackstack;

ZEND_PARSE_PARAMETERS_NONE();

if (zend_call_stack_get(&stack)) {
zend_string*str;

array_init(return_value);

str=strpprintf(0, "%p", stack.base);
add_assoc_str(return_value, "base", str);

str=strpprintf(0, "0x%zx", stack.max_size);
add_assoc_str(return_value, "max_size", str);

str=strpprintf(0, "%p", zend_call_stack_position());
add_assoc_str(return_value, "position", str);

str=strpprintf(0, "%p", EG(stack_limit));
add_assoc_str(return_value, "EG(stack_limit)", str);

return;
 }

RETURN_NULL();
}

zend_long (*volatilezend_call_stack_use_all_fun)(void*limit);

staticzend_longzend_call_stack_use_all(void*limit)
{
if (zend_call_stack_overflowed(limit)) {
return1;
 }

return1+zend_call_stack_use_all_fun(limit);
}

staticZEND_FUNCTION(zend_test_zend_call_stack_use_all)
{
zend_call_stackstack;

ZEND_PARSE_PARAMETERS_NONE();

if (!zend_call_stack_get(&stack)) {
return;
 }

zend_call_stack_use_all_fun=zend_call_stack_use_all;

void*limit=zend_call_stack_limit(stack.base, stack.max_size, 4096);

RETURN_LONG(zend_call_stack_use_all(limit));
}
#endif/* ZEND_CHECK_STACK_LIMIT */

staticZEND_FUNCTION(zend_get_map_ptr_last)
{
ZEND_PARSE_PARAMETERS_NONE();
RETURN_LONG(CG(map_ptr_last));
}

staticZEND_FUNCTION(zend_test_crash)
{
zend_string*message=NULL;

ZEND_PARSE_PARAMETERS_START(0, 1)
Z_PARAM_OPTIONAL
Z_PARAM_STR_OR_NULL(message)
ZEND_PARSE_PARAMETERS_END();

if (message) {
php_printf("%s", ZSTR_VAL(message));
 }

char*invalid= (char*) 1;
php_printf("%s", invalid);
}

staticboolhas_opline(zend_execute_data*execute_data)
{
returnexecute_data
&&execute_data->func
&&ZEND_USER_CODE(execute_data->func->type)
&&execute_data->opline
 ;
}

void*zend_test_custom_malloc(size_tlenZEND_FILE_LINE_DCZEND_FILE_LINE_ORIG_DC)
{
if (has_opline(EG(current_execute_data))) {
assert(EG(current_execute_data)->opline->lineno!= (uint32_t)-1);
 }
return_zend_mm_alloc(ZT_G(zend_orig_heap), lenZEND_FILE_LINE_EMPTY_CCZEND_FILE_LINE_EMPTY_CC);
}

voidzend_test_custom_free(void*ptrZEND_FILE_LINE_DCZEND_FILE_LINE_ORIG_DC)
{
if (has_opline(EG(current_execute_data))) {
assert(EG(current_execute_data)->opline->lineno!= (uint32_t)-1);
 }
_zend_mm_free(ZT_G(zend_orig_heap), ptrZEND_FILE_LINE_EMPTY_CCZEND_FILE_LINE_EMPTY_CC);
}

void*zend_test_custom_realloc(void*ptr, size_tlenZEND_FILE_LINE_DCZEND_FILE_LINE_ORIG_DC)
{
if (has_opline(EG(current_execute_data))) {
assert(EG(current_execute_data)->opline->lineno!= (uint32_t)-1);
 }
return_zend_mm_realloc(ZT_G(zend_orig_heap), ptr, lenZEND_FILE_LINE_EMPTY_CCZEND_FILE_LINE_EMPTY_CC);
}

staticPHP_INI_MH(OnUpdateZendTestObserveOplineInZendMM)
{
if (new_value==NULL) {
returnFAILURE;
 }

intint_value=zend_ini_parse_bool(new_value);

if (int_value==1) {
// `zend_mm_heap` is a private struct, so we have not way to find the
// actual size, but 4096 bytes should be enough
ZT_G(zend_test_heap) =malloc(4096);
memset(ZT_G(zend_test_heap), 0, 4096);
zend_mm_set_custom_handlers(
ZT_G(zend_test_heap),
zend_test_custom_malloc,
zend_test_custom_free,
zend_test_custom_realloc
 );
ZT_G(zend_orig_heap) =zend_mm_get_heap();
zend_mm_set_heap(ZT_G(zend_test_heap));
 } elseif (ZT_G(zend_test_heap)) {
free(ZT_G(zend_test_heap));
ZT_G(zend_test_heap) =NULL;
zend_mm_set_heap(ZT_G(zend_orig_heap));
 }
returnOnUpdateBool(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
}

staticZEND_FUNCTION(zend_test_fill_packed_array)
{
HashTable*parameter;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_ARRAY_HT_EX(parameter, 0, 1)
ZEND_PARSE_PARAMETERS_END();

if (!HT_IS_PACKED(parameter)) {
zend_argument_value_error(1, "must be a packed array");
RETURN_THROWS();
 }

zend_hash_extend(parameter, parameter->nNumUsed+10, true);
ZEND_HASH_FILL_PACKED(parameter) {
for (inti=0; i<10; i++) {
zvalvalue;
ZVAL_LONG(&value, i);
ZEND_HASH_FILL_ADD(&value);
 }
 } ZEND_HASH_FILL_END();
}

staticZEND_FUNCTION(get_open_basedir)
{
ZEND_PARSE_PARAMETERS_NONE();
if (PG(open_basedir)) {
RETURN_STRING(PG(open_basedir));
 } else {
RETURN_NULL();
 }
}

staticZEND_FUNCTION(zend_test_is_pcre_bundled)
{
ZEND_PARSE_PARAMETERS_NONE();
#ifdefHAVE_BUNDLED_PCRE
RETURN_TRUE;
#else
RETURN_FALSE;
#endif
}

#ifdefPHP_WIN32
staticZEND_FUNCTION(zend_test_set_fmode)
{
boolbinary;
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_BOOL(binary)
ZEND_PARSE_PARAMETERS_END();

_fmode=binary ? _O_BINARY : _O_TEXT;
}
#endif

staticZEND_FUNCTION(zend_test_cast_fread)
{
zval*stream_zv;
php_stream*stream;
FILE*fp;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_RESOURCE(stream_zv);
ZEND_PARSE_PARAMETERS_END();

php_stream_from_zval(stream, stream_zv);

if (php_stream_cast(stream, PHP_STREAM_AS_STDIO, (void*) &fp, REPORT_ERRORS) ==FAILURE) {
return;
 }

size_tsize=10240; /* Must be large enough to trigger the issue */
char*buf=malloc(size);
boolbail= false;
zend_try {
 (void) !fread(buf, 1, size, fp);
 } zend_catch {
bail= true;
 } zend_end_try();

free(buf);

if (bail) {
zend_bailout();
 }
}

staticZEND_FUNCTION(zend_test_is_zend_ptr)
{
zend_longaddr;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_LONG(addr);
ZEND_PARSE_PARAMETERS_END();

RETURN_BOOL(is_zend_ptr((void*)addr));
}

staticZEND_FUNCTION(zend_test_log_err_debug)
{
zend_string*str;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STR(str);
ZEND_PARSE_PARAMETERS_END();

php_log_err_with_severity(ZSTR_VAL(str), LOG_DEBUG);
}

staticzend_object*zend_test_class_new(zend_class_entry*class_type)
{
zend_object*obj=zend_objects_new(class_type);
object_properties_init(obj, class_type);
obj->handlers=&zend_test_class_handlers;
returnobj;
}

staticzend_function*zend_test_class_method_get(zend_object**object, zend_string*name, constzval*key)
{
if (zend_string_equals_literal_ci(name, "test")) {
zend_internal_function*fptr;

if (EXPECTED(EG(trampoline).common.function_name==NULL)) {
fptr= (zend_internal_function*) &EG(trampoline);
 } else {
fptr=emalloc(sizeof(zend_internal_function));
 }
memset(fptr, 0, sizeof(zend_internal_function));
fptr->type=ZEND_INTERNAL_FUNCTION;
fptr->num_args=0;
fptr->scope= (*object)->ce;
fptr->fn_flags=ZEND_ACC_CALL_VIA_HANDLER;
fptr->function_name=zend_string_copy(name);
fptr->handler=ZEND_FN(zend_test_func);
fptr->doc_comment=NULL;

return (zend_function*)fptr;
 }
returnzend_std_get_method(object, name, key);
}

staticzend_function*zend_test_class_static_method_get(zend_class_entry*ce, zend_string*name)
{
if (zend_string_equals_literal_ci(name, "test")) {
zend_internal_function*fptr;

if (EXPECTED(EG(trampoline).common.function_name==NULL)) {
fptr= (zend_internal_function*) &EG(trampoline);
 } else {
fptr=emalloc(sizeof(zend_internal_function));
 }
memset(fptr, 0, sizeof(zend_internal_function));
fptr->type=ZEND_INTERNAL_FUNCTION;
fptr->num_args=0;
fptr->scope=ce;
fptr->fn_flags=ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_STATIC;
fptr->function_name=zend_string_copy(name);
fptr->handler=ZEND_FN(zend_test_func);
fptr->doc_comment=NULL;

return (zend_function*)fptr;
 }
returnzend_std_get_static_method(ce, name, NULL);
}

voidzend_attribute_validate_zendtestattribute(zend_attribute*attr, uint32_ttarget, zend_class_entry*scope)
{
if (target!=ZEND_ATTRIBUTE_TARGET_CLASS) {
zend_error(E_COMPILE_ERROR, "Only classes can be marked with #[ZendTestAttribute]");
 }
}

staticZEND_METHOD(_ZendTestClass, __toString)
{
ZEND_PARSE_PARAMETERS_NONE();
RETURN_EMPTY_STRING();
}

/* Internal function returns bool, we return int. */
staticZEND_METHOD(_ZendTestClass, is_object)
{
ZEND_PARSE_PARAMETERS_NONE();
RETURN_LONG(42);
}

staticZEND_METHOD(_ZendTestClass, returnsStatic) {
ZEND_PARSE_PARAMETERS_NONE();
object_init_ex(return_value, zend_get_called_scope(execute_data));
}

staticZEND_METHOD(_ZendTestClass, returnsThrowable)
{
ZEND_PARSE_PARAMETERS_NONE();
zend_throw_error(NULL, "Dummy");
}

staticZEND_METHOD(_ZendTestClass, variadicTest) {
intargc, i;
zval*args=NULL;

ZEND_PARSE_PARAMETERS_START(0, -1)
Z_PARAM_VARIADIC('*', args, argc)
ZEND_PARSE_PARAMETERS_END();

for (i=0; i<argc; i++) {
zval*arg=args+i;

if (Z_TYPE_P(arg) ==IS_STRING) {
continue;
 }
if (Z_TYPE_P(arg) ==IS_OBJECT&&instanceof_function(Z_OBJ_P(arg)->ce, zend_ce_iterator)) {
continue;
 }

zend_argument_type_error(i+1, "must be of class Iterator or a string, %s given", zend_zval_type_name(arg));
RETURN_THROWS();
 }

object_init_ex(return_value, zend_get_called_scope(execute_data));
}

staticZEND_METHOD(_ZendTestChildClass, returnsThrowable)
{
ZEND_PARSE_PARAMETERS_NONE();
zend_throw_error(NULL, "Dummy");
}

staticZEND_METHOD(ZendAttributeTest, testMethod)
{
ZEND_PARSE_PARAMETERS_NONE();
RETURN_TRUE;
}

staticZEND_METHOD(_ZendTestTrait, testMethod)
{
ZEND_PARSE_PARAMETERS_NONE();
RETURN_TRUE;
}

staticZEND_METHOD(ZendTestNS_Foo, method)
{
ZEND_PARSE_PARAMETERS_NONE();

RETURN_LONG(0);
}

staticZEND_METHOD(ZendTestNS_UnlikelyCompileError, method)
{
ZEND_PARSE_PARAMETERS_NONE();

RETURN_NULL();
}

staticZEND_METHOD(ZendTestNS_NotUnlikelyCompileError, method)
{
ZEND_PARSE_PARAMETERS_NONE();

RETURN_NULL();
}

staticZEND_METHOD(ZendTestNS2_Foo, method)
{
ZEND_PARSE_PARAMETERS_NONE();
}

staticZEND_METHOD(ZendTestNS2_ZendSubNS_Foo, method)