# define HANDLE_UNBLOCK_INTERRUPTIONS() ZEND_SIGNAL_UNBLOCK_INTERRUPTIONS()
#endif
-#define INTERNAL_FUNCTION_PARAMETERS zend_execute_data *execute_data, zval *return_value TSRMLS_DC
-#define INTERNAL_FUNCTION_PARAM_PASSTHRU execute_data, return_value TSRMLS_CC
+#define INTERNAL_FUNCTION_PARAMETERS zend_execute_data *execute_data, zval *return_value
+#define INTERNAL_FUNCTION_PARAM_PASSTHRU execute_data, return_value
#define USED_RET() \
(!EX(prev_execute_data) || \
# define _ZEND_BIN_ALLOCATOR(_num, _size, _elements, _pages, x, y) \
ZEND_API void* ZEND_FASTCALL _emalloc_ ## _size(void) { \
- TSRMLS_FETCH(); \
ZEND_MM_CUSTOM_ALLOCATOR(_size); \
return zend_mm_alloc_small(AG(mm_heap), _size, _num ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); \
}
#if ZEND_DEBUG
# define _ZEND_BIN_FREE(_num, _size, _elements, _pages, x, y) \
ZEND_API void ZEND_FASTCALL _efree_ ## _size(void *ptr) { \
- TSRMLS_FETCH(); \
ZEND_MM_CUSTOM_DEALLOCATOR(ptr); \
{ \
size_t page_offset = ZEND_MM_ALIGNED_OFFSET(ptr, ZEND_MM_CHUNK_SIZE); \
#else
# define _ZEND_BIN_FREE(_num, _size, _elements, _pages, x, y) \
ZEND_API void ZEND_FASTCALL _efree_ ## _size(void *ptr) { \
- TSRMLS_FETCH(); \
ZEND_MM_CUSTOM_DEALLOCATOR(ptr); \
{ \
zend_mm_chunk *chunk = (zend_mm_chunk*)ZEND_MM_ALIGNED_BASE(ptr, ZEND_MM_CHUNK_SIZE); \
return zend_mm_realloc_heap(AG(mm_heap), ptr, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
}
-ZEND_API size_t ZEND_FASTCALL _zend_mem_block_size(void *ptr TSRMLS_DC ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
+ZEND_API size_t ZEND_FASTCALL _zend_mem_block_size(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
{
if (UNEXPECTED(AG(mm_heap)->use_custom_heap)) {
return 0;
ZEND_API void* ZEND_FASTCALL _safe_realloc(void *ptr, size_t nmemb, size_t size, size_t offset);
ZEND_API char* ZEND_FASTCALL _estrdup(const char *s ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC;
ZEND_API char* ZEND_FASTCALL _estrndup(const char *s, size_t length ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC;
-ZEND_API size_t ZEND_FASTCALL _zend_mem_block_size(void *ptr TSRMLS_DC ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
+ZEND_API size_t ZEND_FASTCALL _zend_mem_block_size(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
#include "zend_alloc_sizes.h"
#define erealloc_recoverable(ptr, size) _erealloc((ptr), (size), 1 ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define estrdup(s) _estrdup((s) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define estrndup(s, length) _estrndup((s), (length) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
-#define zend_mem_block_size(ptr) _zend_mem_block_size((ptr) TSRMLS_CC ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
+#define zend_mem_block_size(ptr) _zend_mem_block_size((ptr) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
/* Relay wrapper macros */
#define emalloc_rel(size) _emalloc((size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define safe_erealloc_rel(ptr, nmemb, size, offset) _safe_erealloc((ptr), (nmemb), (size), (offset) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define estrdup_rel(s) _estrdup((s) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define estrndup_rel(s, length) _estrndup((s), (length) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
-#define zend_mem_block_size_rel(ptr) _zend_mem_block_size((ptr) TSRMLS_CC ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
+#define zend_mem_block_size_rel(ptr) _zend_mem_block_size((ptr) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
zend_always_inline static void * __zend_malloc(size_t len)
{
zend_string *zend_resolve_non_class_name(
zend_string *name, uint32_t type, zend_bool *is_fully_qualified,
- zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC
+ zend_bool case_sensitive, HashTable *current_import_sub
) {
char *compound;
*is_fully_qualified = 0;
void zend_eval_const_expr(zend_ast **ast_ptr);
void zend_const_expr_to_zval(zval *result, zend_ast *ast);
-#define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data TSRMLS_DC
-#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU execute_data TSRMLS_CC
+#define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data
+#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU execute_data
typedef int (*user_opcode_handler_t) (ZEND_OPCODE_HANDLER_ARGS);
typedef int (ZEND_FASTCALL *opcode_handler_t) (ZEND_OPCODE_HANDLER_ARGS);
#include "zend_compile.h"
#include "zend_build.h"
-#define INIT_FUNC_ARGS int type, int module_number TSRMLS_DC
-#define INIT_FUNC_ARGS_PASSTHRU type, module_number TSRMLS_CC
-#define SHUTDOWN_FUNC_ARGS int type, int module_number TSRMLS_DC
-#define SHUTDOWN_FUNC_ARGS_PASSTHRU type, module_number TSRMLS_CC
-#define ZEND_MODULE_INFO_FUNC_ARGS zend_module_entry *zend_module TSRMLS_DC
-#define ZEND_MODULE_INFO_FUNC_ARGS_PASSTHRU zend_module TSRMLS_CC
+#define INIT_FUNC_ARGS int type, int module_number
+#define INIT_FUNC_ARGS_PASSTHRU type, module_number
+#define SHUTDOWN_FUNC_ARGS int type, int module_number
+#define SHUTDOWN_FUNC_ARGS_PASSTHRU type, module_number
+#define ZEND_MODULE_INFO_FUNC_ARGS zend_module_entry *zend_module
+#define ZEND_MODULE_INFO_FUNC_ARGS_PASSTHRU zend_module
#define ZEND_MODULE_API_NO 20141001
#ifdef ZTS
#define ZEND_VM_LEAVE() return 2
#define ZEND_VM_DISPATCH(opcode, opline) return zend_vm_get_opcode_handler(opcode, opline)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data TSRMLS_CC
+#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data
ZEND_API void execute_ex(zend_execute_data *execute_data)
{
"VAR" => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)",
"CONST" => "EX_CONSTANT(opline->op1)",
"UNUSED" => "NULL",
- "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var)",
"TMPVAR" => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)",
);
"VAR" => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)",
"CONST" => "EX_CONSTANT(opline->op2)",
"UNUSED" => "NULL",
- "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var)",
"TMPVAR" => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)",
);
"VAR" => "_get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1)",
"CONST" => "NULL",
"UNUSED" => "NULL",
- "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var)",
"TMPVAR" => "???",
);
"VAR" => "_get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2)",
"CONST" => "NULL",
"UNUSED" => "NULL",
- "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var)",
"TMPVAR" => "???",
);
"VAR" => "_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1)",
"CONST" => "EX_CONSTANT(opline->op1)",
"UNUSED" => "NULL",
- "CV" => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op1.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op1.var)",
"TMPVAR" => "???",
);
"VAR" => "_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2)",
"CONST" => "EX_CONSTANT(opline->op2)",
"UNUSED" => "NULL",
- "CV" => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op2.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op2.var)",
"TMPVAR" => "???",
);
"VAR" => "_get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1)",
"CONST" => "NULL",
"UNUSED" => "NULL",
- "CV" => "_get_zval_ptr_cv_undef_\\1(execute_data, opline->op1.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_undef_\\1(execute_data, opline->op1.var)",
"TMPVAR" => "???",
);
"VAR" => "_get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2)",
"CONST" => "NULL",
"UNUSED" => "NULL",
- "CV" => "_get_zval_ptr_cv_undef_\\1(execute_data, opline->op2.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_undef_\\1(execute_data, opline->op2.var)",
"TMPVAR" => "???",
);
"VAR" => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)",
"CONST" => "EX_CONSTANT(opline->op1)",
"UNUSED" => "_get_obj_zval_ptr_unused(execute_data)",
- "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var)",
"TMPVAR" => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)",
);
"VAR" => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)",
"CONST" => "EX_CONSTANT(opline->op2)",
"UNUSED" => "_get_obj_zval_ptr_unused(execute_data)",
- "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var)",
"TMPVAR" => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)",
);
"VAR" => "_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1)",
"CONST" => "EX_CONSTANT(opline->op1)",
"UNUSED" => "_get_obj_zval_ptr_unused(execute_data)",
- "CV" => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op1.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op1.var)",
"TMPVAR" => "???",
);
"VAR" => "_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2)",
"CONST" => "EX_CONSTANT(opline->op2)",
"UNUSED" => "_get_obj_zval_ptr_unused(execute_data)",
- "CV" => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op2.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op2.var)",
"TMPVAR" => "???",
);
"VAR" => "_get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1)",
"CONST" => "NULL",
"UNUSED" => "_get_obj_zval_ptr_unused(execute_data)",
- "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var)",
"TMPVAR" => "???",
);
"VAR" => "_get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2)",
"CONST" => "NULL",
"UNUSED" => "_get_obj_zval_ptr_unused(execute_data)",
- "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var)",
"TMPVAR" => "???",
);
"VAR" => "_get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1)",
"CONST" => "NULL",
"UNUSED" => "_get_obj_zval_ptr_unused(execute_data)",
- "CV" => "_get_zval_ptr_cv_undef_\\1(execute_data, opline->op1.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_undef_\\1(execute_data, opline->op1.var)",
"TMPVAR" => "???",
);
"VAR" => "_get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2)",
"CONST" => "NULL",
"UNUSED" => "_get_obj_zval_ptr_unused(execute_data)",
- "CV" => "_get_zval_ptr_cv_undef_\\1(execute_data, opline->op2.var TSRMLS_CC)",
+ "CV" => "_get_zval_ptr_cv_undef_\\1(execute_data, opline->op2.var)",
"TMPVAR" => "???",
);
out($f,"#define ZEND_VM_ENTER() return 1\n");
out($f,"#define ZEND_VM_LEAVE() return 2\n");
out($f,"#define ZEND_VM_DISPATCH(opcode, opline) return zend_vm_get_opcode_handler(opcode, opline)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);\n\n");
- out($f,"#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data TSRMLS_CC\n");
+ out($f,"#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data
+");
break;
case ZEND_VM_KIND_SWITCH:
out($f,"\n");
out($f,"#define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_CONTINUE()\n");
out($f,"#define ZEND_VM_LEAVE() ZEND_VM_CONTINUE()\n");
out($f,"#define ZEND_VM_DISPATCH(opcode, opline) dispatch_handler = zend_vm_get_opcode_handler(opcode, opline); goto zend_vm_dispatch;\n\n");
- out($f,"#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data TSRMLS_CC\n");
+ out($f,"#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data
+");
break;
case ZEND_VM_KIND_GOTO:
out($f,"\n");
out($f,"#define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_CONTINUE()\n");
out($f,"#define ZEND_VM_LEAVE() ZEND_VM_CONTINUE()\n");
out($f,"#define ZEND_VM_DISPATCH(opcode, opline) goto *(void**)(zend_vm_get_opcode_handler(opcode, opline));\n\n");
- out($f,"#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data TSRMLS_CC\n");
+ out($f,"#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data
+");
break;
}
break;
// Emit code that dispatches to opcode handler
switch ($kind) {
case ZEND_VM_KIND_CALL:
- out($f, $m[1]."if (UNEXPECTED((ret = OPLINE->handler(execute_data TSRMLS_CC)) != 0))".$m[3]."\n");
+ out($f, $m[1]."if (UNEXPECTED((ret = OPLINE->handler(execute_data)) != 0))".$m[3]."\n");
break;
case ZEND_VM_KIND_SWITCH:
out($f, $m[1]."dispatch_handler = OPLINE->handler;\nzend_vm_dispatch:\n".$m[1]."switch ((int)dispatch_handler)".$m[3]."\n");
if ($kind == ZEND_VM_KIND_GOTO) {
// Labels are defined in the executor itself, so we call it
// with execute_data NULL and it sets zend_opcode_handlers array
- out($f,$prolog."TSRMLS_FETCH();\n");
- out($f,$prolog.$executor_name."_ex(NULL TSRMLS_CC);\n");
+ out($f,$prolog."");
+ out($f,$prolog.$executor_name."_ex(NULL);\n");
} else {
if ($old) {
// Reserving space for user-defined opcodes
out($f,"#define ZEND_VM_ENTER() return 1\n");
out($f,"#define ZEND_VM_LEAVE() return 2\n");
out($f,"#define ZEND_VM_DISPATCH(opcode, opline) return zend_vm_get_opcode_handler(opcode, opline)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);\n\n");
- out($f,"#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data TSRMLS_CC\n\n");
+ out($f,"#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data
+\n");
}
foreach ($export as $dsk) {
list($kind, $func, $name) = $dsk;
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
- TSRMLS_DC)
+ )
{
php_bz2_filter_data *data;
php_stream_bucket *bucket;
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
- TSRMLS_DC)
+ )
{
php_bz2_filter_data *data;
php_stream_bucket *bucket;
#undef EXIF_DEBUG
#ifdef EXIF_DEBUG
-#define EXIFERR_DC , const char *_file, size_t _line TSRMLS_DC
-#define EXIFERR_CC , __FILE__, __LINE__ TSRMLS_CC
+#define EXIFERR_DC , const char *_file, size_t _line
+#define EXIFERR_CC , __FILE__, __LINE__
#else
-#define EXIFERR_DC TSRMLS_DC
-#define EXIFERR_CC TSRMLS_CC
+#define EXIFERR_DC
+#define EXIFERR_CC
#endif
#undef EXIF_JPEG2000
ByteCount,
zend_multibyte_fetch_encoding(ImageInfo->encode_unicode),
zend_multibyte_fetch_encoding(decode)
- TSRMLS_CC) == (size_t)-1) {
+ ) == (size_t)-1) {
len = exif_process_string_raw(pszInfoPtr, szValuePtr, ByteCount);
}
return len;
ByteCount,
zend_multibyte_fetch_encoding(ImageInfo->encode_jis),
zend_multibyte_fetch_encoding(ImageInfo->motorola_intel ? ImageInfo->decode_jis_be : ImageInfo->decode_jis_le)
- TSRMLS_CC) == (size_t)-1) {
+ ) == (size_t)-1) {
len = exif_process_string_raw(pszInfoPtr, szValuePtr, ByteCount);
}
return len;
ByteCount,
zend_multibyte_fetch_encoding(ImageInfo->encode_unicode),
zend_multibyte_fetch_encoding(ImageInfo->motorola_intel ? ImageInfo->decode_unicode_be : ImageInfo->decode_unicode_le)
- TSRMLS_CC) == (size_t)-1) {
+ ) == (size_t)-1) {
xp_field->size = exif_process_string_raw(&xp_field->value, szValuePtr, ByteCount);
}
return xp_field->size;
#endif
-#define PHP_INPUT_FILTER_PARAM_DECL zval *value, zend_long flags, zval *option_array, char *charset TSRMLS_DC
+#define PHP_INPUT_FILTER_PARAM_DECL zval *value, zend_long flags, zval *option_array, char *charset
void php_filter_int(PHP_INPUT_FILTER_PARAM_DECL);
void php_filter_boolean(PHP_INPUT_FILTER_PARAM_DECL);
void php_filter_float(PHP_INPUT_FILTER_PARAM_DECL);
#define DO_BINARY_UI_OP_EX(op, uop, check_b_zero) \
gmp_zval_binary_ui_op( \
result, op1, op2, op, (gmp_binary_ui_op_t) uop, \
- check_b_zero TSRMLS_CC \
+ check_b_zero \
); \
return SUCCESS;
if (PG(sql_safe_mode)) {
_php_ibase_module_error("CREATE DATABASE is not allowed in SQL safe mode"
- TSRMLS_CC);
+ );
} else if (((l = INI_INT("ibase.max_links")) != -1) && (IBG(num_links) >= l)) {
_php_ibase_module_error("CREATE DATABASE is not allowed: maximum link count "
item == isc_info_error || i >= sizeof(bl_info)) {
_php_ibase_module_error("Could not determine BLOB size (internal error)"
- TSRMLS_CC);
+ );
goto _php_ibase_fetch_error;
}
ZEND_FETCH_RESOURCE(*trans, ibase_trans *, link_id, -1, LE_TRANS, le_trans);
if ((*trans)->link_cnt > 1) {
_php_ibase_module_error("Link id is ambiguous: transaction spans multiple connections."
- TSRMLS_CC);
+ );
return;
}
*ib_link = (*trans)->db_link[0];
static void __attribute__((constructor)) init()
{
- php_embed_init(0, NULL PTSRMLS_CC);
+ php_embed_init(0, NULL P);
}
static void __attribute__((destructor)) fini()
zend_ulong mysql_flags,
zend_bool silent,
zend_bool is_change_user
- TSRMLS_DC)
+ )
{
enum_func_status ret = FAIL;
zend_bool first_call = TRUE;
scrambled_data, scrambled_data_len,
&switch_to_auth_protocol, &switch_to_auth_protocol_len,
&switch_to_auth_protocol_data, &switch_to_auth_protocol_data_len
- TSRMLS_CC);
+ );
} else {
ret = mysqlnd_auth_change_user(conn, user, strlen(user), passwd, passwd_len, db, db_len, silent,
first_call,
const MYSQLND_PACKET_GREET * const greet_packet,
const MYSQLND_OPTIONS * const options,
zend_ulong mysql_flags
- TSRMLS_DC)
+ )
{
enum_func_status ret = FAIL;
DBG_ENTER("mysqlnd_connect_run_authentication");
MYSQLND_METHOD(mysqlnd_conn_data, set_client_option)(MYSQLND_CONN_DATA * const conn,
enum mysqlnd_option option,
const char * const value
- TSRMLS_DC)
+ )
{
size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, set_client_option);
enum_func_status ret = PASS;
enum mysqlnd_option option,
const char * const key,
const char * const value
- TSRMLS_DC)
+ )
{
size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, set_client_option_2d);
enum_func_status ret = PASS;
/* {{{ mysqlnd_conn_data::get_connection_stats */
static void
MYSQLND_METHOD(mysqlnd_conn_data, get_connection_stats)(const MYSQLND_CONN_DATA * const conn,
- zval * return_value TSRMLS_DC ZEND_FILE_LINE_DC)
+ zval * return_value ZEND_FILE_LINE_DC)
{
DBG_ENTER("mysqlnd_conn_data::get_connection_stats");
- mysqlnd_fill_stats_hash(conn->stats, mysqlnd_stats_values_names, return_value TSRMLS_CC ZEND_FILE_LINE_CC);
+ mysqlnd_fill_stats_hash(conn->stats, mysqlnd_stats_values_names, return_value ZEND_FILE_LINE_CC);
DBG_VOID_RETURN;
}
/* }}} */
PHPAPI void _mysqlnd_debug(const char *mode);
/* Query */
-#define mysqlnd_fetch_into(result, flags, ret_val, ext) (result)->m.fetch_into((result), (flags), (ret_val), (ext) TSRMLS_CC ZEND_FILE_LINE_CC)
+#define mysqlnd_fetch_into(result, flags, ret_val, ext) (result)->m.fetch_into((result), (flags), (ret_val), (ext) ZEND_FILE_LINE_CC)
#define mysqlnd_fetch_row_c(result) (result)->m.fetch_row_c((result))
-#define mysqlnd_fetch_all(result, flags, return_value) (result)->m.fetch_all((result), (flags), (return_value) TSRMLS_CC ZEND_FILE_LINE_CC)
+#define mysqlnd_fetch_all(result, flags, return_value) (result)->m.fetch_all((result), (flags), (return_value) ZEND_FILE_LINE_CC)
#define mysqlnd_result_fetch_field_data(res,offset,ret) (res)->m.fetch_field_data((res), (offset), (ret))
-#define mysqlnd_get_connection_stats(conn, values) ((conn)->data)->m->get_statistics((conn)->data, (values) TSRMLS_CC ZEND_FILE_LINE_CC)
-#define mysqlnd_get_client_stats(values) _mysqlnd_get_client_stats((values) TSRMLS_CC ZEND_FILE_LINE_CC)
+#define mysqlnd_get_connection_stats(conn, values) ((conn)->data)->m->get_statistics((conn)->data, (values) ZEND_FILE_LINE_CC)
+#define mysqlnd_get_client_stats(values) _mysqlnd_get_client_stats((values) ZEND_FILE_LINE_CC)
#define mysqlnd_close(conn,is_forced) (conn)->m->close((conn), (is_forced))
#define mysqlnd_query(conn, query_str, query_len) ((conn)->data)->m->query((conn)->data, (query_str), (query_len))
/* Performance statistics */
-PHPAPI void _mysqlnd_get_client_stats(zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC);
+PHPAPI void _mysqlnd_get_client_stats(zval *return_value ZEND_FILE_LINE_DC);
/* double check the class name to avoid naming conflicts when using these: */
#define MYSQLND_METHOD(class, method) php_##class##_##method##_pub
size_t * switch_to_auth_protocol_len,
zend_uchar ** switch_to_auth_protocol_data,
size_t * switch_to_auth_protocol_data_len
- TSRMLS_DC)
+ )
{
enum_func_status ret = FAIL;
const MYSQLND_CHARSET * old_cs = conn->charset;
size_t * switch_to_auth_protocol_len,
zend_uchar ** switch_to_auth_protocol_data,
size_t * switch_to_auth_protocol_data_len
- TSRMLS_DC);
+ );
enum_func_status
mysqlnd_auth_change_user(MYSQLND_CONN_DATA * const conn,
size_t * switch_to_auth_protocol_len,
zend_uchar ** switch_to_auth_protocol_data,
size_t * switch_to_auth_protocol_data_len
- TSRMLS_DC);
+ );
#endif /* MYSQLND_PRIV_H */
static void
MYSQLND_METHOD(mysqlnd_res, fetch_into)(MYSQLND_RES * result, const unsigned int flags,
zval *return_value,
- enum_mysqlnd_extension extension TSRMLS_DC ZEND_FILE_LINE_DC)
+ enum_mysqlnd_extension extension ZEND_FILE_LINE_DC)
{
zend_bool fetched_anything;
/* {{{ mysqlnd_res::fetch_all */
static void
-MYSQLND_METHOD(mysqlnd_res, fetch_all)(MYSQLND_RES * result, const unsigned int flags, zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC)
+MYSQLND_METHOD(mysqlnd_res, fetch_all)(MYSQLND_RES * result, const unsigned int flags, zval *return_value ZEND_FILE_LINE_DC)
{
zval row;
zend_ulong i = 0;
/* {{{ mysqlnd_fill_stats_hash */
PHPAPI void
-mysqlnd_fill_stats_hash(const MYSQLND_STATS * const stats, const MYSQLND_STRING * names, zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC)
+mysqlnd_fill_stats_hash(const MYSQLND_STATS * const stats, const MYSQLND_STRING * names, zval *return_value ZEND_FILE_LINE_DC)
{
unsigned int i;
/* {{{ _mysqlnd_get_client_stats */
PHPAPI void
-_mysqlnd_get_client_stats(zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC)
+_mysqlnd_get_client_stats(zval *return_value ZEND_FILE_LINE_DC)
{
MYSQLND_STATS stats, *stats_ptr = mysqlnd_global_stats;
DBG_ENTER("_mysqlnd_get_client_stats");
memset(&stats, 0, sizeof(stats));
stats_ptr = &stats;
}
- mysqlnd_fill_stats_hash(stats_ptr, mysqlnd_stats_values_names, return_value TSRMLS_CC ZEND_FILE_LINE_CC);
+ mysqlnd_fill_stats_hash(stats_ptr, mysqlnd_stats_values_names, return_value ZEND_FILE_LINE_CC);
DBG_VOID_RETURN;
}
/* }}} */
#endif /* MYSQLND_CORE_STATISTICS_DISABLED */
-PHPAPI void mysqlnd_fill_stats_hash(const MYSQLND_STATS * const stats, const MYSQLND_STRING * names, zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC);
+PHPAPI void mysqlnd_fill_stats_hash(const MYSQLND_STATS * const stats, const MYSQLND_STRING * names, zval *return_value ZEND_FILE_LINE_DC);
PHPAPI void mysqlnd_stats_init(MYSQLND_STATS ** stats, size_t statistic_count);
PHPAPI void mysqlnd_stats_end(MYSQLND_STATS * stats);
void * param,
const unsigned int flags,
zend_bool * fetched_anything
- TSRMLS_DC);
+ );
typedef struct st_mysqlnd_stats MYSQLND_STATS;
typedef const char * (*func_mysqlnd_conn_data__get_error_str)(const MYSQLND_CONN_DATA * const conn);
typedef const char * (*func_mysqlnd_conn_data__get_sqlstate)(const MYSQLND_CONN_DATA * const conn);
typedef uint64_t (*func_mysqlnd_conn_data__get_thread_id)(const MYSQLND_CONN_DATA * const conn);
-typedef void (*func_mysqlnd_conn_data__get_statistics)(const MYSQLND_CONN_DATA * const conn, zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC);
+typedef void (*func_mysqlnd_conn_data__get_statistics)(const MYSQLND_CONN_DATA * const conn, zval *return_value ZEND_FILE_LINE_DC);
typedef zend_ulong (*func_mysqlnd_conn_data__get_server_version)(const MYSQLND_CONN_DATA * const conn);
typedef const char * (*func_mysqlnd_conn_data__get_server_information)(const MYSQLND_CONN_DATA * const conn);
typedef MYSQLND_RES * (*func_mysqlnd_res__use_result)(MYSQLND_RES * const result, zend_bool ps_protocol);
typedef MYSQLND_RES * (*func_mysqlnd_res__store_result)(MYSQLND_RES * result, MYSQLND_CONN_DATA * const conn, const unsigned int flags);
-typedef void (*func_mysqlnd_res__fetch_into)(MYSQLND_RES *result, const unsigned int flags, zval *return_value, enum_mysqlnd_extension ext TSRMLS_DC ZEND_FILE_LINE_DC);
+typedef void (*func_mysqlnd_res__fetch_into)(MYSQLND_RES *result, const unsigned int flags, zval *return_value, enum_mysqlnd_extension ext ZEND_FILE_LINE_DC);
typedef MYSQLND_ROW_C (*func_mysqlnd_res__fetch_row_c)(MYSQLND_RES *result);
-typedef void (*func_mysqlnd_res__fetch_all)(MYSQLND_RES *result, const unsigned int flags, zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC);
+typedef void (*func_mysqlnd_res__fetch_all)(MYSQLND_RES *result, const unsigned int flags, zval *return_value ZEND_FILE_LINE_DC);
typedef void (*func_mysqlnd_res__fetch_field_data)(MYSQLND_RES *result, unsigned int offset, zval *return_value);
typedef uint64_t (*func_mysqlnd_res__num_rows)(const MYSQLND_RES * const result);
typedef unsigned int (*func_mysqlnd_res__num_fields)(const MYSQLND_RES * const result);
const size_t passwd_len, zend_uchar * auth_plugin_data, size_t auth_plugin_data_len,
const MYSQLND_OPTIONS * const options,
const MYSQLND_NET_OPTIONS * const net_options, zend_ulong mysql_flags
- TSRMLS_DC);
+ );
struct st_mysqlnd_authentication_plugin
{
zval values;
snprintf(buf, sizeof(buf), "%s statistics", plugin_header->plugin_name);
- mysqlnd_fill_stats_hash(plugin_header->plugin_stats.values, plugin_header->plugin_stats.names, &values TSRMLS_CC ZEND_FILE_LINE_CC);
+ mysqlnd_fill_stats_hash(plugin_header->plugin_stats.values, plugin_header->plugin_stats.names, &values ZEND_FILE_LINE_CC);
php_info_print_table_start();
php_info_print_table_header(2, buf, "");
int flen = FUNCTION_CACHE->funcs[Z_LVAL(ZEND_OP1_LITERAL(fcall))].name_len;
if(flen == sizeof("defined")-1 && zend_binary_strcasecmp(fname, flen, "defined", sizeof("defined")-1) == 0) {
zval c;
- if(zend_optimizer_get_persistent_constant(Z_STR_P(arg), &c, 0 TSRMLS_CC ELS_CC) != 0) {
+ if(zend_optimizer_get_persistent_constant(Z_STR_P(arg), &c, 0 ELS_CC) != 0) {
literal_dtor(arg);
MAKE_NOP(sv);
MAKE_NOP(fcall);
}
} else if(flen == sizeof("constant")-1 && zend_binary_strcasecmp(fname, flen, "constant", sizeof("constant")-1) == 0) {
zval c;
- if(zend_optimizer_get_persistent_constant(Z_STR_P(arg), &c, 1 TSRMLS_CC ELS_CC) != 0) {
+ if(zend_optimizer_get_persistent_constant(Z_STR_P(arg), &c, 1 ELS_CC) != 0) {
literal_dtor(arg);
MAKE_NOP(sv);
MAKE_NOP(fcall);
int php_openssl_setup_crypto(php_stream *stream,
php_openssl_netstream_data_t *sslsock,
php_stream_xport_crypto_param *cparam
- TSRMLS_DC) /* {{{ */
+ ) /* {{{ */
{
const SSL_METHOD *method;
long ssl_ctx_options;
static int php_openssl_enable_crypto(php_stream *stream,
php_openssl_netstream_data_t *sslsock,
php_stream_xport_crypto_param *cparam
- TSRMLS_DC)
+ )
{
int n;
int retry = 1;
xparam->inputs.timeout,
xparam->want_errortext ? &xparam->outputs.error_text : NULL,
&xparam->outputs.error_code
- TSRMLS_CC);
+ );
if (clisock >= 0) {
php_openssl_netstream_data_t *clisockdata;
pdo_raise_impl_error(dbh, NULL, "HY000",
"PDO::ATTR_STATEMENT_CLASS requires format array(classname, array(ctor_args)); "
"the classname must be a string specifying an existing class"
- TSRMLS_CC);
+ );
PDO_HANDLE_DBH_ERR();
RETURN_FALSE;
}
pdo_raise_impl_error(dbh, NULL, "HY000",
"PDO::ATTR_STATEMENT_CLASS requires format array(classname, ctor_args); "
"ctor_args must be an array"
- TSRMLS_CC);
+ );
PDO_HANDLE_DBH_ERR();
RETURN_FALSE;
}
if (!pdo_stmt_instantiate(dbh, return_value, dbstmt_ce, &ctor_args)) {
pdo_raise_impl_error(dbh, NULL, "HY000",
"failed to instantiate user-supplied statement class"
- TSRMLS_CC);
+ );
PDO_HANDLE_DBH_ERR();
RETURN_FALSE;
}
if (dbh->is_persistent) {
pdo_raise_impl_error(dbh, NULL, "HY000",
"PDO::ATTR_STATEMENT_CLASS cannot be used with persistent PDO instances"
- TSRMLS_CC);
+ );
PDO_HANDLE_DBH_ERR();
return FAILURE;
}
pdo_raise_impl_error(dbh, NULL, "HY000",
"PDO::ATTR_STATEMENT_CLASS requires format array(classname, array(ctor_args)); "
"the classname must be a string specifying an existing class"
- TSRMLS_CC);
+ );
PDO_HANDLE_DBH_ERR();
return FAILURE;
}
pdo_raise_impl_error(dbh, NULL, "HY000",
"PDO::ATTR_STATEMENT_CLASS requires format array(classname, array(ctor_args)); "
"ctor_args must be an array"
- TSRMLS_CC);
+ );
PDO_HANDLE_DBH_ERR();
return FAILURE;
}
* at this time. */
if (stmt->methods->param_hook) {
if (!stmt->methods->param_hook(stmt, param, PDO_PARAM_EVT_NORMALIZE
- TSRMLS_CC)) {
+ )) {
if (param->name) {
zend_string_release(param->name);
param->name = NULL;
/* tell the driver we just created a parameter */
if (stmt->methods->param_hook) {
if (!stmt->methods->param_hook(stmt, pparam, PDO_PARAM_EVT_ALLOC
- TSRMLS_CC)) {
+ )) {
/* undo storage allocation; the hash will free the parameter
* name if required */
if (pparam->name) {
/* In every utility function you add that needs to use variables
in php_pdo_odbc_globals, call TSRMLS_FETCH(); after declaring other
- variables used by that function, or better yet, pass in TSRMLS_CC
+ variables used by that function, or better yet, pass in
after the last function argument and declare your utility function
- with TSRMLS_DC after the last declared argument. Always refer to
+ with after the last declared argument. Always refer to
the globals in your function as PDO_ODBC_G(variable). You are
encouraged to rename these macros something shorter, see
examples in any other php module directory.
/* In every utility function you add that needs to use variables
in php_pdo_sqlite_globals, call TSRMLS_FETCH(); after declaring other
- variables used by that function, or better yet, pass in TSRMLS_CC
+ variables used by that function, or better yet, pass in
after the last function argument and declare your utility function
- with TSRMLS_DC after the last declared argument. Always refer to
+ with after the last declared argument. Always refer to
the globals in your function as PDO_SQLITE_G(variable). You are
encouraged to rename these macros something shorter, see
examples in any other php module directory.
/* To check php_session_valid_key()/php_session_reset_id() */
#define PHP_SESSION_STRICT 1
-#define PS_OPEN_ARGS void **mod_data, const char *save_path, const char *session_name TSRMLS_DC
-#define PS_CLOSE_ARGS void **mod_data TSRMLS_DC
-#define PS_READ_ARGS void **mod_data, zend_string *key, zend_string **val TSRMLS_DC
-#define PS_WRITE_ARGS void **mod_data, zend_string *key, zend_string *val TSRMLS_DC
-#define PS_DESTROY_ARGS void **mod_data, zend_string *key TSRMLS_DC
-#define PS_GC_ARGS void **mod_data, int maxlifetime, int *nrdels TSRMLS_DC
-#define PS_CREATE_SID_ARGS void **mod_data TSRMLS_DC
+#define PS_OPEN_ARGS void **mod_data, const char *save_path, const char *session_name
+#define PS_CLOSE_ARGS void **mod_data
+#define PS_READ_ARGS void **mod_data, zend_string *key, zend_string **val
+#define PS_WRITE_ARGS void **mod_data, zend_string *key, zend_string *val
+#define PS_DESTROY_ARGS void **mod_data, zend_string *key
+#define PS_GC_ARGS void **mod_data, int maxlifetime, int *nrdels
+#define PS_CREATE_SID_ARGS void **mod_data
/* default create id function */
PHPAPI zend_string *php_session_create_id(PS_CREATE_SID_ARGS);
#endif
#define PS_SERIALIZER_ENCODE_ARGS TSRMLS_D
-#define PS_SERIALIZER_DECODE_ARGS const char *val, int vallen TSRMLS_DC
+#define PS_SERIALIZER_DECODE_ARGS const char *val, int vallen
typedef struct ps_serializer_struct {
const char *name;
/* In every utility function you add that needs to use variables
in php_extname_globals, call TSRMLS_FETCH(); after declaring other
- variables used by that function, or better yet, pass in TSRMLS_CC
+ variables used by that function, or better yet, pass in
after the last function argument and declare your utility function
- with TSRMLS_DC after the last declared argument. Always refer to
+ with after the last declared argument. Always refer to
the globals in your function as EXTNAME_G(variable). You are
encouraged to rename these macros something shorter, see
examples in any other php module directory.
intern->u.dir.entry.d_name[0] = '\0';
if (!EG(exception)) {
/* open failed w/out notice (turned to exception due to EH_THROW) */
- zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0
- TSRMLS_CC, "Failed to open directory \"%s\"", path);
+ zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0,
+ "Failed to open directory \"%s\"", path);
}
} else {
do {
&shutdown_function_entry->arguments[0],
&retval,
shutdown_function_entry->arg_count - 1,
- shutdown_function_entry->arguments + 1
- TSRMLS_CC ) == SUCCESS)
+ shutdown_function_entry->arguments + 1) == SUCCESS)
{
zval_dtor(&retval);
}
&retval,
tick_fe->arg_count - 1,
tick_fe->arguments + 1
- TSRMLS_CC) == SUCCESS) {
+ ) == SUCCESS) {
zval_dtor(&retval);
} else {
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
- TSRMLS_DC)
+ )
{
php_stream_bucket *bucket;
size_t consumed = 0;
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
- TSRMLS_DC)
+ )
{
php_stream_bucket *bucket;
size_t consumed = 0;
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
- TSRMLS_DC)
+ )
{
php_stream_bucket *bucket;
size_t consumed = 0;
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
- TSRMLS_DC)
+ )
{
php_stream_bucket *bucket;
size_t consumed = 0;
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
- TSRMLS_DC)
+ )
{
php_stream_bucket *bucket = NULL;
size_t consumed = 0;
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
- TSRMLS_DC)
+ )
{
php_consumed_filter_data *data = (php_consumed_filter_data *)Z_PTR(thisfilter->abstract);
php_stream_bucket *bucket;
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
- TSRMLS_DC)
+ )
{
php_stream_bucket *bucket;
size_t consumed = 0;
if (FAILURE == php_stream_filter_register_factory(
standard_filters[i].ops->label,
standard_filters[i].factory
- TSRMLS_CC)) {
+ )) {
return FAILURE;
}
}
zpeername ? &peername : NULL,
NULL, NULL,
&tv, &errstr
- TSRMLS_CC) && clistream) {
+ ) && clistream) {
if (peername) {
ZVAL_STR(zpeername, peername);
if (0 != php_stream_xport_get_name(stream, want_peer,
&name,
NULL, NULL
- TSRMLS_CC)) {
+ )) {
RETURN_FALSE;
}
recvd = php_stream_xport_recvfrom(stream, read_buf->val, to_read, (int)flags, NULL, NULL,
zremote ? &remote_addr : NULL
- TSRMLS_CC);
+ );
if (recvd >= 0) {
if (zremote) {
#define YYMARKER q
#define STATE ctx->state
-#define STD_PARA url_adapt_state_ex_t *ctx, char *start, char *YYCURSOR TSRMLS_DC
-#define STD_ARGS ctx, start, xp TSRMLS_CC
+#define STD_PARA url_adapt_state_ex_t *ctx, char *start, char *YYCURSOR
+#define STD_ARGS ctx, start, xp
#if SCANNER_DEBUG
#define scdebug(x) printf x
#define YYMARKER q
#define STATE ctx->state
-#define STD_PARA url_adapt_state_ex_t *ctx, char *start, char *YYCURSOR TSRMLS_DC
-#define STD_ARGS ctx, start, xp TSRMLS_CC
+#define STD_PARA url_adapt_state_ex_t *ctx, char *start, char *YYCURSOR
+#define STD_ARGS ctx, start, xp
#if SCANNER_DEBUG
#define scdebug(x) printf x
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
- TSRMLS_DC)
+ )
{
int ret = PSFS_ERR_FATAL;
zval *obj = &thisfilter->abstract;
return result;
}
-#define UNSERIALIZE_PARAMETER zval *rval, const unsigned char **p, const unsigned char *max, php_unserialize_data_t *var_hash, HashTable *classes TSRMLS_DC
-#define UNSERIALIZE_PASSTHRU rval, p, max, var_hash, classes TSRMLS_CC
+#define UNSERIALIZE_PARAMETER zval *rval, const unsigned char **p, const unsigned char *max, php_unserialize_data_t *var_hash, HashTable *classes
+#define UNSERIALIZE_PASSTHRU rval, p, max, var_hash, classes
static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, zend_long elements, int objprops)
{
return result;
}
-#define UNSERIALIZE_PARAMETER zval *rval, const unsigned char **p, const unsigned char *max, php_unserialize_data_t *var_hash, HashTable *classes TSRMLS_DC
-#define UNSERIALIZE_PASSTHRU rval, p, max, var_hash, classes TSRMLS_CC
+#define UNSERIALIZE_PARAMETER zval *rval, const unsigned char **p, const unsigned char *max, php_unserialize_data_t *var_hash, HashTable *classes
+#define UNSERIALIZE_PASSTHRU rval, p, max, var_hash, classes
static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, zend_long elements, int objprops)
{
/* In every utility function you add that needs to use variables
in php_xsl_globals, call TSRM_FETCH(); after declaring other
- variables used by that function, or better yet, pass in TSRMLS_CC
+ variables used by that function, or better yet, pass in
after the last function argument and declare your utility function
- with TSRMLS_DC after the last declared argument. Always refer to
+ with after the last declared argument. Always refer to
the globals in your function as XSL_G(variable). You are
encouraged to rename these macros something shorter, see
examples in any other php module directory.
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
- TSRMLS_DC)
+ )
{
php_zlib_filter_data *data;
php_stream_bucket *bucket;
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
- TSRMLS_DC)
+ )
{
php_zlib_filter_data *data;
php_stream_bucket *bucket;
#define EXTCOUNT (sizeof(php_builtin_extensions)/sizeof(zend_module_entry *))
-PHPAPI int php_register_internal_extensions(TSRMLS_D)
+PHPAPI int php_register_internal_extensions(void)
{
- return php_register_extensions(php_builtin_extensions, EXTCOUNT TSRMLS_CC);
+ return php_register_extensions(php_builtin_extensions, EXTCOUNT);
}
/*
/* {{{ php_network_bind_socket_to_local_addr */
php_socket_t php_network_bind_socket_to_local_addr(const char *host, unsigned port,
int socktype, long sockopts, zend_string **error_string, int *error_code
- TSRMLS_DC)
+ )
{
int num_addrs, n, err = 0;
php_socket_t sock;
/* output address */
struct sockaddr **addr,
socklen_t *addrlen
- TSRMLS_DC)
+ )
{
if (addr) {
*addr = emalloc(sl);
zend_string **textaddr,
struct sockaddr **addr,
socklen_t *addrlen
- TSRMLS_DC)
+ )
{
php_sockaddr_storage sa;
socklen_t sl = sizeof(sa);
php_network_populate_name_from_sockaddr((struct sockaddr*)&sa, sl,
textaddr,
addr, addrlen
- TSRMLS_CC);
+ );
return 0;
}
return -1;
zend_string **textaddr,
struct sockaddr **addr,
socklen_t *addrlen
- TSRMLS_DC)
+ )
{
php_sockaddr_storage sa;
socklen_t sl = sizeof(sa);
php_network_populate_name_from_sockaddr((struct sockaddr*)&sa, sl,
textaddr,
addr, addrlen
- TSRMLS_CC);
+ );
return 0;
}
return -1;
struct timeval *timeout,
zend_string **error_string,
int *error_code
- TSRMLS_DC)
+ )
{
php_socket_t clisock = -1;
int error = 0, n;
php_network_populate_name_from_sockaddr((struct sockaddr*)&sa, sl,
textaddr,
addr, addrlen
- TSRMLS_CC);
+ );
} else {
error = php_socket_errno();
}
php_socket_t php_network_connect_socket_to_host(const char *host, unsigned short port,
int socktype, int asynchronous, struct timeval *timeout, zend_string **error_string,
int *error_code, char *bindto, unsigned short bindport, long sockopts
- TSRMLS_DC)
+ )
{
int num_addrs, n, fatal = 0;
php_socket_t sock;
PHPAPI php_socket_t php_network_connect_socket_to_host(const char *host, unsigned short port,
int socktype, int asynchronous, struct timeval *timeout, zend_string **error_string,
int *error_code, char *bindto, unsigned short bindport, long sockopts
- TSRMLS_DC);
+ );
PHPAPI int php_network_connect_socket(php_socket_t sockfd,
const struct sockaddr *addr,
PHPAPI php_socket_t php_network_bind_socket_to_local_addr(const char *host, unsigned port,
int socktype, long sockopts, zend_string **error_string, int *error_code
- TSRMLS_DC);
+ );
PHPAPI php_socket_t php_network_accept_incoming(php_socket_t srvsock,
zend_string **textaddr,
struct timeval *timeout,
zend_string **error_string,
int *error_code
- TSRMLS_DC);
+ );
PHPAPI int php_network_get_sock_name(php_socket_t sock,
zend_string **textaddr,
struct sockaddr **addr,
socklen_t *addrlen
- TSRMLS_DC);
+ );
PHPAPI int php_network_get_peer_name(php_socket_t sock,
zend_string **textaddr,
struct sockaddr **addr,
socklen_t *addrlen
- TSRMLS_DC);
+ );
PHPAPI void php_any_addr(int family, php_sockaddr_storage *addr, unsigned short port);
PHPAPI int php_sockaddr_size(php_sockaddr_storage *addr);
/* output address */
struct sockaddr **addr,
socklen_t *addrlen
- TSRMLS_DC);
+ );
PHPAPI int php_network_parse_network_address_with_port(const char *addr,
zend_long addrlen, struct sockaddr *sa, socklen_t *sl);
PHPAPI size_t _php_stream_printf(php_stream *stream, const char *fmt, ...) PHP_ATTRIBUTE_FORMAT(printf, 2, 3);
#endif
-/* php_stream_printf macro & function require TSRMLS_CC */
+/* php_stream_printf macro & function require */
#define php_stream_printf _php_stream_printf
PHPAPI int _php_stream_eof(php_stream *stream);
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
- TSRMLS_DC);
+ );
void (*dtor)(php_stream_filter *thisfilter);
PHPAPI int php_stream_xport_bind(php_stream *stream,
const char *name, size_t namelen,
zend_string **error_text
- TSRMLS_DC);
+ );
/* Connect to a remote address */
PHPAPI int php_stream_xport_connect(php_stream *stream,
struct timeval *timeout,
zend_string **error_text,
int *error_code
- TSRMLS_DC);
+ );
/* Prepare to listen */
PHPAPI int php_stream_xport_listen(php_stream *stream,
int backlog,
zend_string **error_text
- TSRMLS_DC);
+ );
/* Get the next client and their address as a string, or the underlying address
* structure. You must efree either of these if you request them */
void **addr, socklen_t *addrlen,
struct timeval *timeout,
zend_string **error_text
- TSRMLS_DC);
+ );
/* Get the name of either the socket or it's peer */
PHPAPI int php_stream_xport_get_name(php_stream *stream, int want_peer,
zend_string **textaddr,
void **addr, socklen_t *addrlen
- TSRMLS_DC);
+ );
enum php_stream_xport_send_recv_flags {
STREAM_OOB = 1,
justread = stream->ops->read(stream, (char*)stream->readbuf + stream->writepos,
stream->readbuflen - stream->writepos
- TSRMLS_CC);
+ );
if (justread != (size_t)-1) {
stream->writepos += justread;
PHPAPI int php_stream_xport_bind(php_stream *stream,
const char *name, size_t namelen,
zend_string **error_text
- TSRMLS_DC)
+ )
{
php_stream_xport_param param;
int ret;
struct timeval *timeout,
zend_string **error_text,
int *error_code
- TSRMLS_DC)
+ )
{
php_stream_xport_param param;
int ret;
void **addr, socklen_t *addrlen,
struct timeval *timeout,
zend_string **error_text
- TSRMLS_DC)
+ )
{
php_stream_xport_param param;
int ret;
PHPAPI int php_stream_xport_get_name(php_stream *stream, int want_peer,
zend_string **textaddr,
void **addr, socklen_t *addrlen
- TSRMLS_DC)
+ )
{
php_stream_xport_param param;
int ret;
* peeking, optionally retrieving OOB data */
PHPAPI int php_stream_xport_recvfrom(php_stream *stream, char *buf, size_t buflen,
int flags, void **addr, socklen_t *addrlen, zend_string **textaddr
- TSRMLS_DC)
+ )
{
php_stream_xport_param param;
int ret = 0;
&zfuncname,
&zretval,
4, args,
- 0, NULL TSRMLS_CC);
+ 0, NULL );
if (call_result == SUCCESS && Z_TYPE(zretval) != IS_UNDEF && zval_is_true(&zretval)) {
/* the stream is now open! */
&zfuncname,
&zretval,
2, args,
- 0, NULL TSRMLS_CC);
+ 0, NULL );
if (call_result == SUCCESS && Z_TYPE(zretval) != IS_UNDEF && zval_is_true(&zretval)) {
/* the stream is now open! */
&zfuncname,
&zretval,
1, args,
- 0, NULL TSRMLS_CC);
+ 0, NULL );
if (call_result == SUCCESS && (Z_TYPE(zretval) == IS_FALSE || Z_TYPE(zretval) == IS_TRUE)) {
ret = (Z_TYPE(zretval) == IS_TRUE);
&zfuncname,
&zretval,
2, args,
- 0, NULL TSRMLS_CC);
+ 0, NULL );
if (call_result == SUCCESS && (Z_TYPE(zretval) == IS_FALSE || Z_TYPE(zretval) == IS_TRUE)) {
ret = (Z_TYPE(zretval) == IS_TRUE);
&zfuncname,
&zretval,
3, args,
- 0, NULL TSRMLS_CC);
+ 0, NULL );
if (call_result == SUCCESS && (Z_TYPE(zretval) == IS_FALSE || Z_TYPE(zretval) == IS_TRUE)) {
ret = (Z_TYPE(zretval) == IS_TRUE);
&zfuncname,
&zretval,
2, args,
- 0, NULL TSRMLS_CC);
+ 0, NULL );
if (call_result == SUCCESS && (Z_TYPE(zretval) == IS_FALSE || Z_TYPE(zretval) == IS_TRUE)) {
ret = (Z_TYPE(zretval) == IS_TRUE);
&zfuncname,
&zretval,
3, args,
- 0, NULL TSRMLS_CC);
+ 0, NULL );
if (call_result == SUCCESS && (Z_TYPE(zretval) == IS_FALSE || Z_TYPE(zretval) == IS_TRUE)) {
ret = Z_TYPE(zretval) == IS_TRUE;
&zfuncname,
&zretval,
2, args,
- 0, NULL TSRMLS_CC);
+ 0, NULL );
if (call_result == SUCCESS && Z_TYPE(zretval) == IS_ARRAY) {
/* We got the info we needed */
static inline int sock_sendto(php_netstream_data_t *sock, const char *buf, size_t buflen, int flags,
struct sockaddr *addr, socklen_t addrlen
- TSRMLS_DC)
+ )
{
int ret;
if (addr) {
static inline int sock_recvfrom(php_netstream_data_t *sock, char *buf, size_t buflen, int flags,
zend_string **textaddr,
struct sockaddr **addr, socklen_t *addrlen
- TSRMLS_DC)
+ )
{
php_sockaddr_storage sa;
socklen_t sl = sizeof(sa);
xparam->want_textaddr ? &xparam->outputs.textaddr : NULL,
xparam->want_addr ? &xparam->outputs.addr : NULL,
xparam->want_addr ? &xparam->outputs.addrlen : NULL
- TSRMLS_CC);
+ );
return PHP_STREAM_OPTION_RETURN_OK;
case STREAM_XPORT_OP_GET_PEER_NAME:
xparam->want_textaddr ? &xparam->outputs.textaddr : NULL,
xparam->want_addr ? &xparam->outputs.addr : NULL,
xparam->want_addr ? &xparam->outputs.addrlen : NULL
- TSRMLS_CC);
+ );
return PHP_STREAM_OPTION_RETURN_OK;
case STREAM_XPORT_OP_SEND:
xparam->want_textaddr ? &xparam->outputs.textaddr : NULL,
xparam->want_addr ? &xparam->outputs.addr : NULL,
xparam->want_addr ? &xparam->outputs.addrlen : NULL
- TSRMLS_CC);
+ );
return PHP_STREAM_OPTION_RETURN_OK;
sockopts,
xparam->want_errortext ? &xparam->outputs.error_text : NULL,
&err
- TSRMLS_CC);
+ );
if (host) {
efree(host);
bindto,
bindport,
sockopts
- TSRMLS_CC);
+ );
ret = sock->socket == -1 ? -1 : 0;
xparam->outputs.error_code = err;
xparam->inputs.timeout,
xparam->want_errortext ? &xparam->outputs.error_text : NULL,
&xparam->outputs.error_code
- TSRMLS_CC);
+ );
if (clisock >= 0) {
php_netstream_data_t *clisockdata;
#define PHPDBG_COMMAND(name) int phpdbg_do_##name(const phpdbg_param_t *param)
-#define PHPDBG_COMMAND_ARGS param TSRMLS_CC
+#define PHPDBG_COMMAND_ARGS param
#define PHPDBG_END_COMMAND {NULL, 0, NULL, 0, '\0', NULL, NULL, NULL, NULL, 0}
const char *key, size_t len, /* pointer and length of key */
phpdbg_command_t const **command, /* address of first matching command */
phpdbg_command_t const * commands /* command table to be scanned */
- TSRMLS_DC)
+ )
{
const phpdbg_command_t *c;
unsigned int num_matches = 0;
}
int phpdbg_lex (phpdbg_param_t* yylval) {
- TSRMLS_FETCH(); /* Slow, but this is not a major problem here. TODO: Use TSRMLS_DC */
restart:
LEX(text) = YYCURSOR;
}
int phpdbg_lex (phpdbg_param_t* yylval) {
- TSRMLS_FETCH(); /* Slow, but this is not a major problem here. TODO: Use TSRMLS_DC */
restart:
LEX(text) = YYCURSOR;
#else
info->si_addr
#endif
- TSRMLS_CC);
+ );
if (watch == NULL) {
return FAILURE;
#if PHP_API_VERSION >= 20020918
if (php_module_startup(sapi_module, &php_thttpd_module, 1) == FAILURE) {
#else
- /* No TSRMLS_CC here to zend_startup_module() as 5.6 and older does not have that parameter */
+ /* No here to zend_startup_module() as 5.6 and older does not have that parameter */
if (php_module_startup(sapi_module) == FAILURE
|| zend_startup_module(&php_thttpd_module) == FAILURE) {
#endif
projects / php / commitdiff