diff options
Diffstat (limited to 'ext/pdo/pdo_stmt.c')
| -rw-r--r-- | ext/pdo/pdo_stmt.c | 467 |
1 files changed, 233 insertions, 234 deletions
diff --git a/ext/pdo/pdo_stmt.c b/ext/pdo/pdo_stmt.c index 1491c80cfd..e4daca7b87 100644 --- a/ext/pdo/pdo_stmt.c +++ b/ext/pdo/pdo_stmt.c @@ -115,11 +115,11 @@ ZEND_END_ARG_INFO() static PHP_FUNCTION(dbstmt_constructor) /* {{{ */ { - php_error_docref(NULL TSRMLS_CC, E_ERROR, "You should not create a PDOStatement manually"); + php_error_docref(NULL, E_ERROR, "You should not create a PDOStatement manually"); } /* }}} */ -static inline int rewrite_name_to_position(pdo_stmt_t *stmt, struct pdo_bound_param_data *param TSRMLS_DC) /* {{{ */ +static inline int rewrite_name_to_position(pdo_stmt_t *stmt, struct pdo_bound_param_data *param) /* {{{ */ { if (stmt->bound_param_map) { /* rewriting :name to ? style. @@ -141,7 +141,7 @@ static inline int rewrite_name_to_position(pdo_stmt_t *stmt, struct pdo_bound_pa param->name = zend_string_init(name, strlen(name), 0); return 1; } - pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "parameter was not defined" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "parameter was not defined"); return 0; } @@ -151,13 +151,13 @@ static inline int rewrite_name_to_position(pdo_stmt_t *stmt, struct pdo_bound_pa continue; } if (param->paramno >= 0) { - pdo_raise_impl_error(stmt->dbh, stmt, "IM001", "PDO refuses to handle repeating the same :named parameter for multiple positions with this driver, as it might be unsafe to do so. Consider using a separate name for each parameter instead" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "IM001", "PDO refuses to handle repeating the same :named parameter for multiple positions with this driver, as it might be unsafe to do so. Consider using a separate name for each parameter instead"); return -1; } param->paramno = position; return 1; } ZEND_HASH_FOREACH_END(); - pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "parameter was not defined" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "parameter was not defined"); return 0; } return 1; @@ -165,7 +165,7 @@ static inline int rewrite_name_to_position(pdo_stmt_t *stmt, struct pdo_bound_pa /* }}} */ /* trigger callback hook for parameters */ -static int dispatch_param_event(pdo_stmt_t *stmt, enum pdo_param_event event_type TSRMLS_DC) /* {{{ */ +static int dispatch_param_event(pdo_stmt_t *stmt, enum pdo_param_event event_type) /* {{{ */ { int ret = 1, is_param = 1; struct pdo_bound_param_data *param; @@ -180,7 +180,7 @@ static int dispatch_param_event(pdo_stmt_t *stmt, enum pdo_param_event event_typ iterate: if (ht) { ZEND_HASH_FOREACH_PTR(ht, param) { - if (!stmt->methods->param_hook(stmt, param, event_type TSRMLS_CC)) { + if (!stmt->methods->param_hook(stmt, param, event_type)) { ret = 0; break; } @@ -196,14 +196,14 @@ iterate: } /* }}} */ -int pdo_stmt_describe_columns(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */ +int pdo_stmt_describe_columns(pdo_stmt_t *stmt) /* {{{ */ { int col; stmt->columns = ecalloc(stmt->column_count, sizeof(struct pdo_column_data)); for (col = 0; col < stmt->column_count; col++) { - if (!stmt->methods->describer(stmt, col TSRMLS_CC)) { + if (!stmt->methods->describer(stmt, col)) { return 0; } @@ -254,12 +254,12 @@ int pdo_stmt_describe_columns(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */ } /* }}} */ -static void get_lazy_object(pdo_stmt_t *stmt, zval *return_value TSRMLS_DC) /* {{{ */ +static void get_lazy_object(pdo_stmt_t *stmt, zval *return_value) /* {{{ */ { if (Z_ISUNDEF(stmt->lazy_object_ref)) { pdo_row_t *row = ecalloc(1, sizeof(pdo_row_t)); row->stmt = stmt; - zend_object_std_init(&row->std, pdo_row_ce TSRMLS_CC); + zend_object_std_init(&row->std, pdo_row_ce); ZVAL_OBJ(&stmt->lazy_object_ref, &row->std); row->std.handlers = &pdo_row_object_handlers; stmt->std.gc.refcount++; @@ -274,8 +274,7 @@ static void param_dtor(zval *el) /* {{{ */ /* tell the driver that it is going away */ if (param->stmt->methods->param_hook) { - TSRMLS_FETCH(); - param->stmt->methods->param_hook(param->stmt, param, PDO_PARAM_EVT_FREE TSRMLS_CC); + param->stmt->methods->param_hook(param->stmt, param, PDO_PARAM_EVT_FREE); } if (param->name) { @@ -293,7 +292,7 @@ static void param_dtor(zval *el) /* {{{ */ } /* }}} */ -static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_stmt_t *stmt, int is_param TSRMLS_DC) /* {{{ */ +static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_stmt_t *stmt, int is_param) /* {{{ */ { HashTable *hash; zval *parameter; @@ -356,7 +355,7 @@ static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_s if (param->paramno == -1) { char *tmp; spprintf(&tmp, 0, "Did not find column name '%s' in the defined columns; it will not be bound", param->name->val); - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", tmp TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", tmp); efree(tmp); } } @@ -372,7 +371,7 @@ static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_s } } - if (is_param && !rewrite_name_to_position(stmt, param TSRMLS_CC)) { + if (is_param && !rewrite_name_to_position(stmt, param)) { if (param->name) { zend_string_release(param->name); param->name = NULL; @@ -386,7 +385,7 @@ static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_s * 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; @@ -412,7 +411,7 @@ static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_s /* 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) { @@ -437,7 +436,7 @@ static PHP_METHOD(PDOStatement, execute) int ret = 1; PHP_STMT_GET_OBJ; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a!", &input_params)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "|a!", &input_params)) { RETURN_FALSE; } @@ -466,7 +465,7 @@ static PHP_METHOD(PDOStatement, execute) /* we're okay to be zero based here */ /* num_index is unsignend if (num_index < 0) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY093", NULL TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY093", NULL); RETURN_FALSE; } */ @@ -476,7 +475,7 @@ static PHP_METHOD(PDOStatement, execute) param.param_type = PDO_PARAM_STR; ZVAL_COPY(¶m.parameter, tmp); - if (!really_register_bound_param(¶m, stmt, 1 TSRMLS_CC)) { + if (!really_register_bound_param(¶m, stmt, 1)) { if (!Z_ISUNDEF(param.parameter)) { zval_ptr_dtor(¶m.parameter); } @@ -492,7 +491,7 @@ static PHP_METHOD(PDOStatement, execute) */ ret = pdo_parse_params(stmt, stmt->query_string, stmt->query_stringlen, - &stmt->active_query_string, &stmt->active_query_stringlen TSRMLS_CC); + &stmt->active_query_string, &stmt->active_query_stringlen); if (ret == 0) { /* no changes were made */ @@ -504,11 +503,11 @@ static PHP_METHOD(PDOStatement, execute) PDO_HANDLE_STMT_ERR(); RETURN_FALSE; } - } else if (!dispatch_param_event(stmt, PDO_PARAM_EVT_EXEC_PRE TSRMLS_CC)) { + } else if (!dispatch_param_event(stmt, PDO_PARAM_EVT_EXEC_PRE)) { PDO_HANDLE_STMT_ERR(); RETURN_FALSE; } - if (stmt->methods->executer(stmt TSRMLS_CC)) { + if (stmt->methods->executer(stmt)) { if (stmt->active_query_string && stmt->active_query_string != stmt->query_string) { efree(stmt->active_query_string); } @@ -519,13 +518,13 @@ static PHP_METHOD(PDOStatement, execute) if (stmt->dbh->alloc_own_columns && !stmt->columns) { /* for "big boy" drivers, we need to allocate memory to fetch * the results into, so lets do that now */ - ret = pdo_stmt_describe_columns(stmt TSRMLS_CC); + ret = pdo_stmt_describe_columns(stmt); } stmt->executed = 1; } - if (ret && !dispatch_param_event(stmt, PDO_PARAM_EVT_EXEC_POST TSRMLS_CC)) { + if (ret && !dispatch_param_event(stmt, PDO_PARAM_EVT_EXEC_POST)) { RETURN_FALSE; } @@ -540,7 +539,7 @@ static PHP_METHOD(PDOStatement, execute) } /* }}} */ -static inline void fetch_value(pdo_stmt_t *stmt, zval *dest, int colno, int *type_override TSRMLS_DC) /* {{{ */ +static inline void fetch_value(pdo_stmt_t *stmt, zval *dest, int colno, int *type_override) /* {{{ */ { struct pdo_column_data *col; char *value = NULL; @@ -555,7 +554,7 @@ static inline void fetch_value(pdo_stmt_t *stmt, zval *dest, int colno, int *typ value = NULL; value_len = 0; - stmt->methods->get_col(stmt, colno, &value, &value_len, &caller_frees TSRMLS_CC); + stmt->methods->get_col(stmt, colno, &value, &value_len, &caller_frees); switch (type) { case PDO_PARAM_ZVAL: @@ -674,26 +673,26 @@ static inline void fetch_value(pdo_stmt_t *stmt, zval *dest, int colno, int *typ } /* }}} */ -static int do_fetch_common(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori, zend_long offset, int do_bind TSRMLS_DC) /* {{{ */ +static int do_fetch_common(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori, zend_long offset, int do_bind) /* {{{ */ { if (!stmt->executed) { return 0; } - if (!dispatch_param_event(stmt, PDO_PARAM_EVT_FETCH_PRE TSRMLS_CC)) { + if (!dispatch_param_event(stmt, PDO_PARAM_EVT_FETCH_PRE)) { return 0; } - if (!stmt->methods->fetcher(stmt, ori, offset TSRMLS_CC)) { + if (!stmt->methods->fetcher(stmt, ori, offset)) { return 0; } /* some drivers might need to describe the columns now */ - if (!stmt->columns && !pdo_stmt_describe_columns(stmt TSRMLS_CC)) { + if (!stmt->columns && !pdo_stmt_describe_columns(stmt)) { return 0; } - if (!dispatch_param_event(stmt, PDO_PARAM_EVT_FETCH_POST TSRMLS_CC)) { + if (!dispatch_param_event(stmt, PDO_PARAM_EVT_FETCH_POST)) { return 0; } @@ -712,7 +711,7 @@ static int do_fetch_common(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori, zen zval_dtor(Z_REFVAL(param->parameter)); /* set new value */ - fetch_value(stmt, Z_REFVAL(param->parameter), param->paramno, (int *)¶m->param_type TSRMLS_CC); + fetch_value(stmt, Z_REFVAL(param->parameter), param->paramno, (int *)¶m->param_type); /* TODO: some smart thing that avoids duplicating the value in the * general loop below. For now, if you're binding output columns, @@ -726,7 +725,7 @@ static int do_fetch_common(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori, zen } /* }}} */ -static int do_fetch_class_prepare(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */ +static int do_fetch_class_prepare(pdo_stmt_t *stmt) /* {{{ */ { zend_class_entry *ce = stmt->fetch.cls.ce; zend_fcall_info *fci = &stmt->fetch.cls.fci; @@ -748,7 +747,7 @@ static int do_fetch_class_prepare(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */ fci->params = NULL; fci->no_separation = 1; - zend_fcall_info_args_ex(fci, ce->constructor, &stmt->fetch.cls.ctor_args TSRMLS_CC); + zend_fcall_info_args_ex(fci, ce->constructor, &stmt->fetch.cls.ctor_args); fcc->initialized = 1; fcc->function_handler = ce->constructor; @@ -756,7 +755,7 @@ static int do_fetch_class_prepare(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */ fcc->called_scope = ce; return 1; } else if (!Z_ISUNDEF(stmt->fetch.cls.ctor_args)) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "user-supplied class does not have a constructor, use NULL for the ctor_params parameter, or simply omit it" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "user-supplied class does not have a constructor, use NULL for the ctor_params parameter, or simply omit it"); return 0; } else { return 1; /* no ctor no args is also ok */ @@ -764,16 +763,16 @@ static int do_fetch_class_prepare(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */ } /* }}} */ -static int make_callable_ex(pdo_stmt_t *stmt, zval *callable, zend_fcall_info * fci, zend_fcall_info_cache * fcc, int num_args TSRMLS_DC) /* {{{ */ +static int make_callable_ex(pdo_stmt_t *stmt, zval *callable, zend_fcall_info * fci, zend_fcall_info_cache * fcc, int num_args) /* {{{ */ { char *is_callable_error = NULL; - if (zend_fcall_info_init(callable, 0, fci, fcc, NULL, &is_callable_error TSRMLS_CC) == FAILURE) { + if (zend_fcall_info_init(callable, 0, fci, fcc, NULL, &is_callable_error) == FAILURE) { if (is_callable_error) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", is_callable_error TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", is_callable_error); efree(is_callable_error); } else { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "user-supplied function must be a valid callback" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "user-supplied function must be a valid callback"); } return 0; } @@ -789,12 +788,12 @@ static int make_callable_ex(pdo_stmt_t *stmt, zval *callable, zend_fcall_info * } /* }}} */ -static int do_fetch_func_prepare(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */ +static int do_fetch_func_prepare(pdo_stmt_t *stmt) /* {{{ */ { zend_fcall_info *fci = &stmt->fetch.cls.fci; zend_fcall_info_cache *fcc = &stmt->fetch.cls.fcc; - if (!make_callable_ex(stmt, &stmt->fetch.func.function, fci, fcc, stmt->column_count TSRMLS_CC)) { + if (!make_callable_ex(stmt, &stmt->fetch.func.function, fci, fcc, stmt->column_count)) { return 0; } else { stmt->fetch.func.values = safe_emalloc(sizeof(zval), stmt->column_count, 0); @@ -803,7 +802,7 @@ static int do_fetch_func_prepare(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */ } /* }}} */ -static int do_fetch_opt_finish(pdo_stmt_t *stmt, int free_ctor_agrs TSRMLS_DC) /* {{{ */ +static int do_fetch_opt_finish(pdo_stmt_t *stmt, int free_ctor_agrs) /* {{{ */ { /* fci.size is used to check if it is valid */ if (stmt->fetch.cls.fci.size && stmt->fetch.cls.fci.params) { @@ -832,7 +831,7 @@ static int do_fetch_opt_finish(pdo_stmt_t *stmt, int free_ctor_agrs TSRMLS_DC) / /* perform a fetch. If do_bind is true, update any bound columns. * If return_value is not null, store values into it according to HOW. */ -static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_fetch_type how, enum pdo_fetch_orientation ori, zend_long offset, zval *return_all TSRMLS_DC) /* {{{ */ +static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_fetch_type how, enum pdo_fetch_orientation ori, zend_long offset, zval *return_all) /* {{{ */ { int flags, idx, old_arg_count = 0; zend_class_entry *ce = NULL, *old_ce = NULL; @@ -845,7 +844,7 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ flags = how & PDO_FETCH_FLAGS; how = how & ~PDO_FETCH_FLAGS; - if (!do_fetch_common(stmt, ori, offset, do_bind TSRMLS_CC)) { + if (!do_fetch_common(stmt, ori, offset, do_bind)) { return 0; } @@ -864,7 +863,7 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ int i = 0; if (how == PDO_FETCH_LAZY) { - get_lazy_object(stmt, return_value TSRMLS_CC); + get_lazy_object(stmt, return_value); return 1; } @@ -886,7 +885,7 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ case PDO_FETCH_KEY_PAIR: if (stmt->column_count != 2) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_KEY_PAIR fetch mode requires the result set to contain extactly 2 columns." TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_KEY_PAIR fetch mode requires the result set to contain extactly 2 columns."); return 0; } if (!return_all) { @@ -897,11 +896,11 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ case PDO_FETCH_COLUMN: if (colno >= 0 && colno < stmt->column_count) { if (flags == PDO_FETCH_GROUP && stmt->fetch.column == -1) { - fetch_value(stmt, return_value, 1, NULL TSRMLS_CC); + fetch_value(stmt, return_value, 1, NULL); } else if (flags == PDO_FETCH_GROUP && colno) { - fetch_value(stmt, return_value, 0, NULL TSRMLS_CC); + fetch_value(stmt, return_value, 0, NULL); } else { - fetch_value(stmt, return_value, colno, NULL TSRMLS_CC); + fetch_value(stmt, return_value, colno, NULL); } if (!return_all) { return 1; @@ -909,7 +908,7 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ break; } } else { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "Invalid column index" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "Invalid column index"); } return 0; @@ -925,30 +924,30 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ old_ce = stmt->fetch.cls.ce; ZVAL_COPY_VALUE(&old_ctor_args, &stmt->fetch.cls.ctor_args); old_arg_count = stmt->fetch.cls.fci.param_count; - do_fetch_opt_finish(stmt, 0 TSRMLS_CC); + do_fetch_opt_finish(stmt, 0); - fetch_value(stmt, &val, i++, NULL TSRMLS_CC); + fetch_value(stmt, &val, i++, NULL); if (Z_TYPE(val) != IS_NULL) { convert_to_string(&val); - if ((cep = zend_lookup_class(Z_STR(val) TSRMLS_CC)) == NULL) { + if ((cep = zend_lookup_class(Z_STR(val))) == NULL) { stmt->fetch.cls.ce = ZEND_STANDARD_CLASS_DEF_PTR; } else { stmt->fetch.cls.ce = cep; } } - do_fetch_class_prepare(stmt TSRMLS_CC); + do_fetch_class_prepare(stmt); zval_dtor(&val); } ce = stmt->fetch.cls.ce; if (!ce) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "No fetch class specified" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "No fetch class specified"); return 0; } if ((flags & PDO_FETCH_SERIALIZE) == 0) { object_init_ex(return_value, ce); if (!stmt->fetch.cls.fci.size) { - if (!do_fetch_class_prepare(stmt TSRMLS_CC)) + if (!do_fetch_class_prepare(stmt)) { return 0; } @@ -956,8 +955,8 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ if (ce->constructor && (flags & PDO_FETCH_PROPS_LATE)) { stmt->fetch.cls.fci.object = Z_OBJ_P(return_value); stmt->fetch.cls.fcc.object = Z_OBJ_P(return_value); - if (zend_call_function(&stmt->fetch.cls.fci, &stmt->fetch.cls.fcc TSRMLS_CC) == FAILURE) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "could not call class constructor" TSRMLS_CC); + if (zend_call_function(&stmt->fetch.cls.fci, &stmt->fetch.cls.fcc) == FAILURE) { + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "could not call class constructor"); return 0; } else { if (!Z_ISUNDEF(stmt->fetch.cls.retval)) { @@ -971,7 +970,7 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ case PDO_FETCH_INTO: if (Z_ISUNDEF(stmt->fetch.into)) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "No fetch-into object specified." TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "No fetch-into object specified."); return 0; break; } @@ -985,11 +984,11 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ case PDO_FETCH_FUNC: if (Z_ISUNDEF(stmt->fetch.func.function)) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "No fetch function specified" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "No fetch function specified"); return 0; } if (!stmt->fetch.func.fci.size) { - if (!do_fetch_func_prepare(stmt TSRMLS_CC)) + if (!do_fetch_func_prepare(stmt)) { return 0; } @@ -1006,9 +1005,9 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ //??? //ZVAL_NULL(&grp_val); if (flags == PDO_FETCH_GROUP && how == PDO_FETCH_COLUMN && stmt->fetch.column > 0) { - fetch_value(stmt, &grp_val, colno, NULL TSRMLS_CC); + fetch_value(stmt, &grp_val, colno, NULL); } else { - fetch_value(stmt, &grp_val, i, NULL TSRMLS_CC); + fetch_value(stmt, &grp_val, i, NULL); } convert_to_string(&grp_val); if (how == PDO_FETCH_COLUMN) { @@ -1020,7 +1019,7 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ for (idx = 0; i < stmt->column_count; i++, idx++) { zval val; - fetch_value(stmt, &val, i, NULL TSRMLS_CC); + fetch_value(stmt, &val, i, NULL); switch (how) { case PDO_FETCH_ASSOC: @@ -1030,7 +1029,7 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ case PDO_FETCH_KEY_PAIR: { zval tmp; - fetch_value(stmt, &tmp, ++i, NULL TSRMLS_CC); + fetch_value(stmt, &tmp, ++i, NULL); if (Z_TYPE(val) == IS_LONG) { zend_hash_index_update((return_all ? Z_ARRVAL_P(return_all) : Z_ARRVAL_P(return_value)), Z_LVAL(val), &tmp); @@ -1095,7 +1094,7 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ case PDO_FETCH_INTO: zend_update_property(NULL, return_value, stmt->columns[i].name, stmt->columns[i].namelen, - &val TSRMLS_CC); + &val); zval_ptr_dtor(&val); break; @@ -1103,15 +1102,15 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ if ((flags & PDO_FETCH_SERIALIZE) == 0 || idx) { zend_update_property(ce, return_value, stmt->columns[i].name, stmt->columns[i].namelen, - &val TSRMLS_CC); + &val); zval_ptr_dtor(&val); } else { #ifdef MBO_0 php_unserialize_data_t var_hash; PHP_VAR_UNSERIALIZE_INIT(var_hash); - if (php_var_unserialize(return_value, (const unsigned char**)&Z_STRVAL(val), Z_STRVAL(val)+Z_STRLEN(val), NULL TSRMLS_CC) == FAILURE) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "cannot unserialize data" TSRMLS_CC); + if (php_var_unserialize(return_value, (const unsigned char**)&Z_STRVAL(val), Z_STRVAL(val)+Z_STRLEN(val), NULL) == FAILURE) { + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "cannot unserialize data"); PHP_VAR_UNSERIALIZE_DESTROY(var_hash); return 0; } @@ -1119,11 +1118,11 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ #endif if (!ce->unserialize) { zval_ptr_dtor(&val); - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "cannot unserialize class" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "cannot unserialize class"); return 0; - } else if (ce->unserialize(return_value, ce, (unsigned char *)(Z_TYPE(val) == IS_STRING ? Z_STRVAL(val) : ""), Z_TYPE(val) == IS_STRING ? Z_STRLEN(val) : 0, NULL TSRMLS_CC) == FAILURE) { + } else if (ce->unserialize(return_value, ce, (unsigned char *)(Z_TYPE(val) == IS_STRING ? Z_STRVAL(val) : ""), Z_TYPE(val) == IS_STRING ? Z_STRLEN(val) : 0, NULL) == FAILURE) { zval_ptr_dtor(&val); - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "cannot unserialize class" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "cannot unserialize class"); zval_dtor(return_value); ZVAL_NULL(return_value); return 0; @@ -1140,7 +1139,7 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ default: zval_ptr_dtor(&val); - pdo_raise_impl_error(stmt->dbh, stmt, "22003", "mode is out of range" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "22003", "mode is out of range"); return 0; break; } @@ -1151,8 +1150,8 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ if (ce->constructor && !(flags & (PDO_FETCH_PROPS_LATE | PDO_FETCH_SERIALIZE))) { stmt->fetch.cls.fci.object = Z_OBJ_P(return_value); stmt->fetch.cls.fcc.object = Z_OBJ_P(return_value); - if (zend_call_function(&stmt->fetch.cls.fci, &stmt->fetch.cls.fcc TSRMLS_CC) == FAILURE) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "could not call class constructor" TSRMLS_CC); + if (zend_call_function(&stmt->fetch.cls.fci, &stmt->fetch.cls.fcc) == FAILURE) { + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "could not call class constructor"); return 0; } else { if (!Z_ISUNDEF(stmt->fetch.cls.retval)) { @@ -1161,7 +1160,7 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ } } if (flags & PDO_FETCH_CLASSTYPE) { - do_fetch_opt_finish(stmt, 0 TSRMLS_CC); + do_fetch_opt_finish(stmt, 0); stmt->fetch.cls.ce = old_ce; ZVAL_COPY_VALUE(&stmt->fetch.cls.ctor_args, &old_ctor_args); stmt->fetch.cls.fci.param_count = old_arg_count; @@ -1171,8 +1170,8 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ case PDO_FETCH_FUNC: stmt->fetch.func.fci.param_count = idx; stmt->fetch.func.fci.retval = &retval; - if (zend_call_function(&stmt->fetch.func.fci, &stmt->fetch.func.fcc TSRMLS_CC) == FAILURE) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "could not call user-supplied function" TSRMLS_CC); + if (zend_call_function(&stmt->fetch.func.fci, &stmt->fetch.func.fcc) == FAILURE) { + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "could not call user-supplied function"); return 0; } else { if (return_all) { @@ -1213,14 +1212,14 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ } /* }}} */ -static int pdo_stmt_verify_mode(pdo_stmt_t *stmt, zend_long mode, int fetch_all TSRMLS_DC) /* {{{ */ +static int pdo_stmt_verify_mode(pdo_stmt_t *stmt, zend_long mode, int fetch_all) /* {{{ */ { int flags = mode & PDO_FETCH_FLAGS; mode = mode & ~PDO_FETCH_FLAGS; if (mode < 0 || mode > PDO_FETCH__MAX) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "invalid fetch mode" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "invalid fetch mode"); return 0; } @@ -1232,29 +1231,29 @@ static int pdo_stmt_verify_mode(pdo_stmt_t *stmt, zend_long mode, int fetch_all switch(mode) { case PDO_FETCH_FUNC: if (!fetch_all) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_FUNC is only allowed in PDOStatement::fetchAll()" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_FUNC is only allowed in PDOStatement::fetchAll()"); return 0; } return 1; case PDO_FETCH_LAZY: if (fetch_all) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_LAZY can't be used with PDOStatement::fetchAll()" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_LAZY can't be used with PDOStatement::fetchAll()"); return 0; } /* fall through */ default: if ((flags & PDO_FETCH_SERIALIZE) == PDO_FETCH_SERIALIZE) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_SERIALIZE can only be used together with PDO::FETCH_CLASS" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_SERIALIZE can only be used together with PDO::FETCH_CLASS"); return 0; } if ((flags & PDO_FETCH_CLASSTYPE) == PDO_FETCH_CLASSTYPE) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_CLASSTYPE can only be used together with PDO::FETCH_CLASS" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_CLASSTYPE can only be used together with PDO::FETCH_CLASS"); return 0; } if (mode >= PDO_FETCH__MAX) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "invalid fetch mode" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "invalid fetch mode"); return 0; } /* no break; */ @@ -1274,18 +1273,18 @@ static PHP_METHOD(PDOStatement, fetch) zend_long off = 0; PHP_STMT_GET_OBJ; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lll", &how, + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "|lll", &how, &ori, &off)) { RETURN_FALSE; } PDO_STMT_CLEAR_ERR(); - if (!pdo_stmt_verify_mode(stmt, how, 0 TSRMLS_CC)) { + if (!pdo_stmt_verify_mode(stmt, how, 0)) { RETURN_FALSE; } - if (!do_fetch(stmt, TRUE, return_value, how, ori, off, 0 TSRMLS_CC)) { + if (!do_fetch(stmt, TRUE, return_value, how, ori, off, 0)) { PDO_HANDLE_STMT_ERR(); RETURN_FALSE; } @@ -1306,13 +1305,13 @@ static PHP_METHOD(PDOStatement, fetchObject) PHP_STMT_GET_OBJ; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|S!a", &class_name, &ctor_args)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "|S!a", &class_name, &ctor_args)) { RETURN_FALSE; } PDO_STMT_CLEAR_ERR(); - if (!pdo_stmt_verify_mode(stmt, how, 0 TSRMLS_CC)) { + if (!pdo_stmt_verify_mode(stmt, how, 0)) { RETURN_FALSE; } @@ -1320,7 +1319,7 @@ static PHP_METHOD(PDOStatement, fetchObject) ZVAL_COPY_VALUE(&old_ctor_args, &stmt->fetch.cls.ctor_args); old_arg_count = stmt->fetch.cls.fci.param_count; - do_fetch_opt_finish(stmt, 0 TSRMLS_CC); + do_fetch_opt_finish(stmt, 0); if (ctor_args) { if (Z_TYPE_P(ctor_args) == IS_ARRAY && zend_hash_num_elements(Z_ARRVAL_P(ctor_args))) { @@ -1330,23 +1329,23 @@ static PHP_METHOD(PDOStatement, fetchObject) } } if (class_name && !error) { - stmt->fetch.cls.ce = zend_fetch_class(class_name, ZEND_FETCH_CLASS_AUTO TSRMLS_CC); + stmt->fetch.cls.ce = zend_fetch_class(class_name, ZEND_FETCH_CLASS_AUTO); if (!stmt->fetch.cls.ce) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "Could not find user-supplied class" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "Could not find user-supplied class"); error = 1; } } else if (!error) { stmt->fetch.cls.ce = zend_standard_class_def; } - if (!error && !do_fetch(stmt, TRUE, return_value, how, ori, off, 0 TSRMLS_CC)) { + if (!error && !do_fetch(stmt, TRUE, return_value, how, ori, off, 0)) { error = 1; } if (error) { PDO_HANDLE_STMT_ERR(); } - do_fetch_opt_finish(stmt, 1 TSRMLS_CC); + do_fetch_opt_finish(stmt, 1); stmt->fetch.cls.ce = old_ce; ZVAL_COPY_VALUE(&stmt->fetch.cls.ctor_args, &old_ctor_args); @@ -1364,18 +1363,18 @@ static PHP_METHOD(PDOStatement, fetchColumn) zend_long col_n = 0; PHP_STMT_GET_OBJ; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &col_n)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &col_n)) { RETURN_FALSE; } PDO_STMT_CLEAR_ERR(); - if (!do_fetch_common(stmt, PDO_FETCH_ORI_NEXT, 0, TRUE TSRMLS_CC)) { + if (!do_fetch_common(stmt, PDO_FETCH_ORI_NEXT, 0, TRUE)) { PDO_HANDLE_STMT_ERR(); RETURN_FALSE; } - fetch_value(stmt, return_value, col_n, NULL TSRMLS_CC); + fetch_value(stmt, return_value, col_n, NULL); } /* }}} */ @@ -1391,11 +1390,11 @@ static PHP_METHOD(PDOStatement, fetchAll) int error = 0, flags, old_arg_count; PHP_STMT_GET_OBJ; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lzz", &how, &arg2, &ctor_args)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "|lzz", &how, &arg2, &ctor_args)) { RETURN_FALSE; } - if (!pdo_stmt_verify_mode(stmt, how, 1 TSRMLS_CC)) { + if (!pdo_stmt_verify_mode(stmt, how, 1)) { RETURN_FALSE; } @@ -1403,7 +1402,7 @@ static PHP_METHOD(PDOStatement, fetchAll) ZVAL_COPY_VALUE(&old_ctor_args, &stmt->fetch.cls.ctor_args); old_arg_count = stmt->fetch.cls.fci.param_count; - do_fetch_opt_finish(stmt, 0 TSRMLS_CC); + do_fetch_opt_finish(stmt, 0); switch(how & ~PDO_FETCH_FLAGS) { case PDO_FETCH_CLASS: @@ -1414,7 +1413,7 @@ static PHP_METHOD(PDOStatement, fetchAll) break; case 3: if (Z_TYPE_P(ctor_args) != IS_NULL && Z_TYPE_P(ctor_args) != IS_ARRAY) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "ctor_args must be either NULL or an array" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "ctor_args must be either NULL or an array"); error = 1; break; } @@ -1429,20 +1428,20 @@ static PHP_METHOD(PDOStatement, fetchAll) ZVAL_UNDEF(&stmt->fetch.cls.ctor_args); } if (Z_TYPE_P(arg2) != IS_STRING) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "Invalid class name (should be a string)" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "Invalid class name (should be a string)"); error = 1; break; } else { - stmt->fetch.cls.ce = zend_fetch_class(Z_STR_P(arg2), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); + stmt->fetch.cls.ce = zend_fetch_class(Z_STR_P(arg2), ZEND_FETCH_CLASS_AUTO); if (!stmt->fetch.cls.ce) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "could not find user-specified class" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "could not find user-specified class"); error = 1; break; } } } if (!error) { - do_fetch_class_prepare(stmt TSRMLS_CC); + do_fetch_class_prepare(stmt); } break; @@ -1450,13 +1449,13 @@ static PHP_METHOD(PDOStatement, fetchAll) switch (ZEND_NUM_ARGS()) { case 0: case 1: - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "no fetch function specified" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "no fetch function specified"); error = 1; break; case 3: case 2: ZVAL_COPY_VALUE(&stmt->fetch.func.function, arg2); - if (do_fetch_func_prepare(stmt TSRMLS_CC) == 0) { + if (do_fetch_func_prepare(stmt) == 0) { error = 1; } break; @@ -1474,14 +1473,14 @@ static PHP_METHOD(PDOStatement, fetchAll) stmt->fetch.column = Z_LVAL_P(arg2); break; case 3: - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "Third parameter not allowed for PDO::FETCH_COLUMN" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "Third parameter not allowed for PDO::FETCH_COLUMN"); error = 1; } break; default: if (ZEND_NUM_ARGS() > 1) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "Extraneous additional parameters" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "Extraneous additional parameters"); error = 1; } } @@ -1503,7 +1502,7 @@ static PHP_METHOD(PDOStatement, fetchAll) } else { return_all = 0; } - if (!do_fetch(stmt, 1, &data, how | flags, PDO_FETCH_ORI_NEXT, 0, return_all TSRMLS_CC)) { + if (!do_fetch(stmt, 1, &data, how | flags, PDO_FETCH_ORI_NEXT, 0, return_all)) { error = 2; } } @@ -1511,18 +1510,18 @@ static PHP_METHOD(PDOStatement, fetchAll) if ((how & PDO_FETCH_GROUP)) { do { //??? MAKE_STD_ZVAL(data); - } while (do_fetch(stmt, 1, &data, how | flags, PDO_FETCH_ORI_NEXT, 0, return_all TSRMLS_CC)); + } while (do_fetch(stmt, 1, &data, how | flags, PDO_FETCH_ORI_NEXT, 0, return_all)); } else if (how == PDO_FETCH_KEY_PAIR || (how == PDO_FETCH_USE_DEFAULT && stmt->default_fetch_type == PDO_FETCH_KEY_PAIR)) { - while (do_fetch(stmt, 1, &data, how | flags, PDO_FETCH_ORI_NEXT, 0, return_all TSRMLS_CC)); + while (do_fetch(stmt, 1, &data, how | flags, PDO_FETCH_ORI_NEXT, 0, return_all)); } else { array_init(return_value); do { add_next_index_zval(return_value, &data); - } while (do_fetch(stmt, 1, &data, how | flags, PDO_FETCH_ORI_NEXT, 0, 0 TSRMLS_CC)); + } while (do_fetch(stmt, 1, &data, how | flags, PDO_FETCH_ORI_NEXT, 0, 0)); } } - do_fetch_opt_finish(stmt, 0 TSRMLS_CC); + do_fetch_opt_finish(stmt, 0); stmt->fetch.cls.ce = old_ce; ZVAL_COPY_VALUE(&stmt->fetch.cls.ctor_args, &old_ctor_args); @@ -1550,10 +1549,10 @@ static int register_bound_param(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, param.paramno = -1; - if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, + if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "lz|llz!", ¶m.paramno, ¶meter, ¶m_type, ¶m.max_value_len, ¶m.driver_params)) { - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|llz!", ¶m.name, + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "Sz|llz!", ¶m.name, ¶meter, ¶m_type, ¶m.max_value_len, ¶m.driver_params)) { return 0; @@ -1565,12 +1564,12 @@ static int register_bound_param(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, if (param.paramno > 0) { --param.paramno; /* make it zero-based internally */ } else if (!param.name) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "Columns/Parameters are 1-based" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "Columns/Parameters are 1-based"); return 0; } ZVAL_COPY(¶m.parameter, parameter); - if (!really_register_bound_param(¶m, stmt, is_param TSRMLS_CC)) { + if (!really_register_bound_param(¶m, stmt, is_param)) { if (!Z_ISUNDEF(param.parameter)) { zval_ptr_dtor(&(param.parameter)); } @@ -1590,9 +1589,9 @@ static PHP_METHOD(PDOStatement, bindValue) param.paramno = -1; - if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, + if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "lz/|l", ¶m.paramno, ¶meter, ¶m_type)) { - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz/|l", ¶m.name, + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "Sz/|l", ¶m.name, ¶meter, ¶m_type)) { RETURN_FALSE; } @@ -1603,12 +1602,12 @@ static PHP_METHOD(PDOStatement, bindValue) if (param.paramno > 0) { --param.paramno; /* make it zero-based internally */ } else if (!param.name) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "Columns/Parameters are 1-based" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "Columns/Parameters are 1-based"); RETURN_FALSE; } ZVAL_COPY(¶m.parameter, parameter); - if (!really_register_bound_param(¶m, stmt, TRUE TSRMLS_CC)) { + if (!really_register_bound_param(¶m, stmt, TRUE)) { if (!Z_ISUNDEF(param.parameter)) { zval_ptr_dtor(&(param.parameter)); ZVAL_UNDEF(¶m.parameter); @@ -1683,7 +1682,7 @@ static PHP_METHOD(PDOStatement, errorInfo) add_next_index_string(return_value, stmt->error_code); if (stmt->dbh->methods->fetch_err) { - stmt->dbh->methods->fetch_err(stmt->dbh, stmt, return_value TSRMLS_CC); + stmt->dbh->methods->fetch_err(stmt->dbh, stmt, return_value); } error_count = zend_hash_num_elements(Z_ARRVAL_P(return_value)); @@ -1707,7 +1706,7 @@ static PHP_METHOD(PDOStatement, setAttribute) zval *value = NULL; PHP_STMT_GET_OBJ; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz!", &attr, &value)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "lz!", &attr, &value)) { RETURN_FALSE; } @@ -1716,13 +1715,13 @@ static PHP_METHOD(PDOStatement, setAttribute) } PDO_STMT_CLEAR_ERR(); - if (stmt->methods->set_attribute(stmt, attr, value TSRMLS_CC)) { + if (stmt->methods->set_attribute(stmt, attr, value)) { RETURN_TRUE; } fail: if (!stmt->methods->set_attribute) { - pdo_raise_impl_error(stmt->dbh, stmt, "IM001", "This driver doesn't support setting attributes" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "IM001", "This driver doesn't support setting attributes"); } else { PDO_HANDLE_STMT_ERR(); } @@ -1748,21 +1747,21 @@ static PHP_METHOD(PDOStatement, getAttribute) zend_long attr; PHP_STMT_GET_OBJ; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &attr)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "l", &attr)) { RETURN_FALSE; } if (!stmt->methods->get_attribute) { if (!generic_stmt_attr_get(stmt, return_value, attr)) { pdo_raise_impl_error(stmt->dbh, stmt, "IM001", - "This driver doesn't support getting attributes" TSRMLS_CC); + "This driver doesn't support getting attributes"); RETURN_FALSE; } return; } PDO_STMT_CLEAR_ERR(); - switch (stmt->methods->get_attribute(stmt, attr, return_value TSRMLS_CC)) { + switch (stmt->methods->get_attribute(stmt, attr, return_value)) { case -1: PDO_HANDLE_STMT_ERR(); RETURN_FALSE; @@ -1771,7 +1770,7 @@ static PHP_METHOD(PDOStatement, getAttribute) if (!generic_stmt_attr_get(stmt, return_value, attr)) { /* XXX: should do something better here */ pdo_raise_impl_error(stmt->dbh, stmt, "IM001", - "driver doesn't support getting that attribute" TSRMLS_CC); + "driver doesn't support getting that attribute"); RETURN_FALSE; } return; @@ -1802,21 +1801,21 @@ static PHP_METHOD(PDOStatement, getColumnMeta) struct pdo_column_data *col; PHP_STMT_GET_OBJ; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &colno)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "l", &colno)) { RETURN_FALSE; } if(colno < 0) { - pdo_raise_impl_error(stmt->dbh, stmt, "42P10", "column number must be non-negative" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "42P10", "column number must be non-negative"); RETURN_FALSE; } if (!stmt->methods->get_column_meta) { - pdo_raise_impl_error(stmt->dbh, stmt, "IM001", "driver doesn't support meta data" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "IM001", "driver doesn't support meta data"); RETURN_FALSE; } PDO_STMT_CLEAR_ERR(); - if (FAILURE == stmt->methods->get_column_meta(stmt, colno, return_value TSRMLS_CC)) { + if (FAILURE == stmt->methods->get_column_meta(stmt, colno, return_value)) { PDO_HANDLE_STMT_ERR(); RETURN_FALSE; } @@ -1844,7 +1843,7 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in zend_class_entry *cep; int retval; - do_fetch_opt_finish(stmt, 1 TSRMLS_CC); + do_fetch_opt_finish(stmt, 1); switch (stmt->default_fetch_type) { case PDO_FETCH_INTO: @@ -1869,13 +1868,13 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in if (SUCCESS == retval) { if (Z_TYPE(args[skip]) != IS_LONG) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "mode must be an integer" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "mode must be an integer"); retval = FAILURE; } else { mode = Z_LVAL(args[skip]); flags = mode & PDO_FETCH_FLAGS; - retval = pdo_stmt_verify_mode(stmt, mode, 0 TSRMLS_CC); + retval = pdo_stmt_verify_mode(stmt, mode, 0); } } @@ -1897,7 +1896,7 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in case PDO_FETCH_NAMED: case PDO_FETCH_KEY_PAIR: if (argc != 1) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "fetch mode doesn't allow any extra arguments" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "fetch mode doesn't allow any extra arguments"); } else { retval = SUCCESS; } @@ -1905,9 +1904,9 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in case PDO_FETCH_COLUMN: if (argc != 2) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "fetch mode requires the colno argument" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "fetch mode requires the colno argument"); } else if (Z_TYPE(args[skip+1]) != IS_LONG) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "colno must be an integer" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "colno must be an integer"); } else { stmt->fetch.column = Z_LVAL(args[skip+1]); retval = SUCCESS; @@ -1918,20 +1917,20 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in /* Gets its class name from 1st column */ if ((flags & PDO_FETCH_CLASSTYPE) == PDO_FETCH_CLASSTYPE) { if (argc != 1) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "fetch mode doesn't allow any extra arguments" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "fetch mode doesn't allow any extra arguments"); } else { stmt->fetch.cls.ce = NULL; retval = SUCCESS; } } else { if (argc < 2) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "fetch mode requires the classname argument" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "fetch mode requires the classname argument"); } else if (argc > 3) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "too many arguments" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "too many arguments"); } else if (Z_TYPE(args[skip+1]) != IS_STRING) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "classname must be a string" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "classname must be a string"); } else { - cep = zend_lookup_class(Z_STR(args[skip+1]) TSRMLS_CC); + cep = zend_lookup_class(Z_STR(args[skip+1])); if (cep) { retval = SUCCESS; stmt->fetch.cls.ce = cep; @@ -1943,12 +1942,12 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in ZVAL_UNDEF(&stmt->fetch.cls.ctor_args); #ifdef ilia_0 /* we'll only need this when we have persistent statements, if ever */ if (stmt->dbh->is_persistent) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "PHP might crash if you don't call $stmt->setFetchMode() to reset to defaults on this persistent statement. This will be fixed in a later release"); + php_error_docref(NULL, E_WARNING, "PHP might crash if you don't call $stmt->setFetchMode() to reset to defaults on this persistent statement. This will be fixed in a later release"); } #endif if (argc == 3) { if (Z_TYPE(args[skip+2]) != IS_NULL && Z_TYPE(args[skip+2]) != IS_ARRAY) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "ctor_args must be either NULL or an array" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "ctor_args must be either NULL or an array"); retval = FAILURE; } else if (Z_TYPE(args[skip+2]) == IS_ARRAY && zend_hash_num_elements(Z_ARRVAL(args[skip+2]))) { ZVAL_DUP(&stmt->fetch.cls.ctor_args, &args[skip+2]); @@ -1956,7 +1955,7 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in } if (SUCCESS == retval) { - do_fetch_class_prepare(stmt TSRMLS_CC); + do_fetch_class_prepare(stmt); } } @@ -1964,9 +1963,9 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in case PDO_FETCH_INTO: if (argc != 2) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "fetch mode requires the object parameter" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "fetch mode requires the object parameter"); } else if (Z_TYPE(args[skip+1]) != IS_OBJECT) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "object must be an object" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "object must be an object"); } else { retval = SUCCESS; } @@ -1974,7 +1973,7 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in if (SUCCESS == retval) { #ifdef ilia_0 /* we'll only need this when we have persistent statements, if ever */ if (stmt->dbh->is_persistent) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "PHP might crash if you don't call $stmt->setFetchMode() to reset to defaults on this persistent statement. This will be fixed in a later release"); + php_error_docref(NULL, E_WARNING, "PHP might crash if you don't call $stmt->setFetchMode() to reset to defaults on this persistent statement. This will be fixed in a later release"); } #endif ZVAL_COPY(&stmt->fetch.into, &args[skip+1]); @@ -1983,7 +1982,7 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in break; default: - pdo_raise_impl_error(stmt->dbh, stmt, "22003", "Invalid fetch mode specified" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "22003", "Invalid fetch mode specified"); } if (SUCCESS == retval) { @@ -2018,7 +2017,7 @@ static PHP_METHOD(PDOStatement, setFetchMode) /* {{{ proto bool PDOStatement::nextRowset() Advances to the next rowset in a multi-rowset statement handle. Returns true if it succeeded, false otherwise */ -static int pdo_stmt_do_next_rowset(pdo_stmt_t *stmt TSRMLS_DC) +static int pdo_stmt_do_next_rowset(pdo_stmt_t *stmt) { /* un-describe */ if (stmt->columns) { @@ -2033,13 +2032,13 @@ static int pdo_stmt_do_next_rowset(pdo_stmt_t *stmt TSRMLS_DC) stmt->column_count = 0; } - if (!stmt->methods->next_rowset(stmt TSRMLS_CC)) { + if (!stmt->methods->next_rowset(stmt)) { /* Set the executed flag to 0 to reallocate columns on next execute */ stmt->executed = 0; return 0; } - pdo_stmt_describe_columns(stmt TSRMLS_CC); + pdo_stmt_describe_columns(stmt); return 1; } @@ -2049,13 +2048,13 @@ static PHP_METHOD(PDOStatement, nextRowset) PHP_STMT_GET_OBJ; if (!stmt->methods->next_rowset) { - pdo_raise_impl_error(stmt->dbh, stmt, "IM001", "driver does not support multiple rowsets" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "IM001", "driver does not support multiple rowsets"); RETURN_FALSE; } PDO_STMT_CLEAR_ERR(); - if (!pdo_stmt_do_next_rowset(stmt TSRMLS_CC)) { + if (!pdo_stmt_do_next_rowset(stmt)) { PDO_HANDLE_STMT_ERR(); RETURN_FALSE; } @@ -2073,13 +2072,13 @@ static PHP_METHOD(PDOStatement, closeCursor) if (!stmt->methods->cursor_closer) { /* emulate it by fetching and discarding rows */ do { - while (stmt->methods->fetcher(stmt, PDO_FETCH_ORI_NEXT, 0 TSRMLS_CC)) + while (stmt->methods->fetcher(stmt, PDO_FETCH_ORI_NEXT, 0)) ; if (!stmt->methods->next_rowset) { break; } - if (!pdo_stmt_do_next_rowset(stmt TSRMLS_CC)) { + if (!pdo_stmt_do_next_rowset(stmt)) { break; } @@ -2090,7 +2089,7 @@ static PHP_METHOD(PDOStatement, closeCursor) PDO_STMT_CLEAR_ERR(); - if (!stmt->methods->cursor_closer(stmt TSRMLS_CC)) { + if (!stmt->methods->cursor_closer(stmt)) { PDO_HANDLE_STMT_ERR(); RETURN_FALSE; } @@ -2111,11 +2110,11 @@ static PHP_METHOD(PDOStatement, debugDumpParams) RETURN_FALSE; } - php_stream_printf(out TSRMLS_CC, "SQL: [%d] %.*s\n", + php_stream_printf(out, "SQL: [%d] %.*s\n", stmt->query_stringlen, stmt->query_stringlen, stmt->query_string); - php_stream_printf(out TSRMLS_CC, "Params: %d\n", + php_stream_printf(out, "Params: %d\n", stmt->bound_params ? zend_hash_num_elements(stmt->bound_params) : 0); if (stmt->bound_params) { @@ -2123,12 +2122,12 @@ static PHP_METHOD(PDOStatement, debugDumpParams) zend_string *key = NULL; ZEND_HASH_FOREACH_KEY_PTR(stmt->bound_params, num, key, param) { if (key) { - php_stream_printf(out TSRMLS_CC, "Key: Name: [%d] %.*s\n", key->len, key->len, key->val); + php_stream_printf(out, "Key: Name: [%d] %.*s\n", key->len, key->len, key->val); } else { - php_stream_printf(out TSRMLS_CC, "Key: Position #%pd:\n", num); + php_stream_printf(out, "Key: Position #%pd:\n", num); } - php_stream_printf(out TSRMLS_CC, "paramno=%pd\nname=[%d] \"%.*s\"\nis_param=%d\nparam_type=%d\n", + php_stream_printf(out, "paramno=%pd\nname=[%d] \"%.*s\"\nis_param=%d\nparam_type=%d\n", param->paramno, param->name? param->name->len : 0, param->name? param->name->len : 0, param->name ? param->name->val : "", param->is_param, @@ -2145,7 +2144,7 @@ static PHP_METHOD(PDOStatement, debugDumpParams) Prevents use of a PDOStatement instance that has been unserialized */ static PHP_METHOD(PDOStatement, __wakeup) { - zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "You cannot serialize or unserialize PDOStatement instances"); + zend_throw_exception_ex(php_pdo_get_exception(), 0, "You cannot serialize or unserialize PDOStatement instances"); } /* }}} */ @@ -2153,7 +2152,7 @@ static PHP_METHOD(PDOStatement, __wakeup) Prevents serialization of a PDOStatement instance */ static PHP_METHOD(PDOStatement, __sleep) { - zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "You cannot serialize or unserialize PDOStatement instances"); + zend_throw_exception_ex(php_pdo_get_exception(), 0, "You cannot serialize or unserialize PDOStatement instances"); } /* }}} */ @@ -2183,33 +2182,33 @@ const zend_function_entry pdo_dbstmt_functions[] = { }; /* {{{ overloaded handlers for PDOStatement class */ -static void dbstmt_prop_write(zval *object, zval *member, zval *value, void **cache_slot TSRMLS_DC) +static void dbstmt_prop_write(zval *object, zval *member, zval *value, void **cache_slot) { pdo_stmt_t *stmt = Z_PDO_STMT_P(object); convert_to_string(member); if (strcmp(Z_STRVAL_P(member), "queryString") == 0) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "property queryString is read only" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "property queryString is read only"); } else { - std_object_handlers.write_property(object, member, value, cache_slot TSRMLS_CC); + std_object_handlers.write_property(object, member, value, cache_slot); } } -static void dbstmt_prop_delete(zval *object, zval *member, void **cache_slot TSRMLS_DC) +static void dbstmt_prop_delete(zval *object, zval *member, void **cache_slot) { pdo_stmt_t *stmt = Z_PDO_STMT_P(object); convert_to_string(member); if (strcmp(Z_STRVAL_P(member), "queryString") == 0) { - pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "property queryString is read only" TSRMLS_CC); + pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "property queryString is read only"); } else { - std_object_handlers.unset_property(object, member, cache_slot TSRMLS_CC); + std_object_handlers.unset_property(object, member, cache_slot); } } -static union _zend_function *dbstmt_method_get(zend_object **object_pp, zend_string *method_name, const zval *key TSRMLS_DC) +static union _zend_function *dbstmt_method_get(zend_object **object_pp, zend_string *method_name, const zval *key) { zend_function *fbc = NULL; zend_string *lc_method_name; @@ -2228,7 +2227,7 @@ static union _zend_function *dbstmt_method_get(zend_object **object_pp, zend_str * the driver specific methods */ if (!stmt->dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_STMT]) { if (!pdo_hash_methods(Z_PDO_OBJECT_P(&stmt->database_object_handle), - PDO_DBH_DRIVER_METHOD_KIND_STMT TSRMLS_CC) + PDO_DBH_DRIVER_METHOD_KIND_STMT) || !stmt->dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_STMT]) { goto out; } @@ -2245,40 +2244,40 @@ out: return fbc; } -static int dbstmt_compare(zval *object1, zval *object2 TSRMLS_DC) +static int dbstmt_compare(zval *object1, zval *object2) { return -1; } -static zend_object *dbstmt_clone_obj(zval *zobject TSRMLS_DC) +static zend_object *dbstmt_clone_obj(zval *zobject) { pdo_stmt_t *stmt; pdo_stmt_t *old_stmt; stmt = ecalloc(1, sizeof(pdo_stmt_t) + sizeof(zval) * (Z_OBJCE_P(zobject)->default_properties_count - 1)); - zend_object_std_init(&stmt->std, Z_OBJCE_P(zobject) TSRMLS_CC); + zend_object_std_init(&stmt->std, Z_OBJCE_P(zobject)); object_properties_init(&stmt->std, Z_OBJCE_P(zobject)); old_stmt = Z_PDO_STMT_P(zobject); - zend_objects_clone_members(&stmt->std, &old_stmt->std TSRMLS_CC); + zend_objects_clone_members(&stmt->std, &old_stmt->std); return &stmt->std; } zend_object_handlers pdo_dbstmt_object_handlers; -static int pdo_row_serialize(zval *object, unsigned char **buffer, size_t *buf_len, zend_serialize_data *data TSRMLS_DC); +static int pdo_row_serialize(zval *object, unsigned char **buffer, size_t *buf_len, zend_serialize_data *data); -void pdo_stmt_init(TSRMLS_D) +void pdo_stmt_init(void) { zend_class_entry ce; INIT_CLASS_ENTRY(ce, "PDOStatement", pdo_dbstmt_functions); - pdo_dbstmt_ce = zend_register_internal_class(&ce TSRMLS_CC); + pdo_dbstmt_ce = zend_register_internal_class(&ce); pdo_dbstmt_ce->get_iterator = pdo_stmt_iter_get; pdo_dbstmt_ce->create_object = pdo_dbstmt_new; - zend_class_implements(pdo_dbstmt_ce TSRMLS_CC, 1, zend_ce_traversable); - zend_declare_property_null(pdo_dbstmt_ce, "queryString", sizeof("queryString")-1, ZEND_ACC_PUBLIC TSRMLS_CC); + zend_class_implements(pdo_dbstmt_ce, 1, zend_ce_traversable); + zend_declare_property_null(pdo_dbstmt_ce, "queryString", sizeof("queryString")-1, ZEND_ACC_PUBLIC); memcpy(&pdo_dbstmt_object_handlers, &std_object_handlers, sizeof(zend_object_handlers)); pdo_dbstmt_object_handlers.offset = XtOffsetOf(pdo_stmt_t, std); @@ -2291,13 +2290,13 @@ void pdo_stmt_init(TSRMLS_D) pdo_dbstmt_object_handlers.clone_obj = dbstmt_clone_obj; INIT_CLASS_ENTRY(ce, "PDORow", pdo_row_functions); - pdo_row_ce = zend_register_internal_class(&ce TSRMLS_CC); + pdo_row_ce = zend_register_internal_class(&ce); pdo_row_ce->ce_flags |= ZEND_ACC_FINAL; /* when removing this a lot of handlers need to be redone */ pdo_row_ce->create_object = pdo_row_new; pdo_row_ce->serialize = pdo_row_serialize; } -static void free_statement(pdo_stmt_t *stmt TSRMLS_DC) +static void free_statement(pdo_stmt_t *stmt) { if (stmt->bound_params) { zend_hash_destroy(stmt->bound_params); @@ -2316,7 +2315,7 @@ static void free_statement(pdo_stmt_t *stmt TSRMLS_DC) } if (stmt->methods && stmt->methods->dtor) { - stmt->methods->dtor(stmt TSRMLS_CC); + stmt->methods->dtor(stmt); } if (stmt->query_string) { efree(stmt->query_string); @@ -2340,26 +2339,26 @@ static void free_statement(pdo_stmt_t *stmt TSRMLS_DC) ZVAL_UNDEF(&stmt->fetch.into); } - do_fetch_opt_finish(stmt, 1 TSRMLS_CC); + do_fetch_opt_finish(stmt, 1); if (!Z_ISUNDEF(stmt->database_object_handle)) { zval_ptr_dtor(&stmt->database_object_handle); } - zend_object_std_dtor(&stmt->std TSRMLS_CC); + zend_object_std_dtor(&stmt->std); } -void pdo_dbstmt_free_storage(zend_object *std TSRMLS_DC) +void pdo_dbstmt_free_storage(zend_object *std) { pdo_stmt_t *stmt = php_pdo_stmt_fetch_object(std); - free_statement(stmt TSRMLS_CC); + free_statement(stmt); } -zend_object *pdo_dbstmt_new(zend_class_entry *ce TSRMLS_DC) +zend_object *pdo_dbstmt_new(zend_class_entry *ce) { pdo_stmt_t *stmt; stmt = ecalloc(1, sizeof(pdo_stmt_t) + sizeof(zval) * (ce->default_properties_count - 1)); - zend_object_std_init(&stmt->std, ce TSRMLS_CC); + zend_object_std_init(&stmt->std, ce); object_properties_init(&stmt->std, ce); stmt->std.handlers = &pdo_dbstmt_object_handlers; @@ -2376,7 +2375,7 @@ struct php_pdo_iterator { zval fetch_ahead; }; -static void pdo_stmt_iter_dtor(zend_object_iterator *iter TSRMLS_DC) +static void pdo_stmt_iter_dtor(zend_object_iterator *iter) { struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter; @@ -2387,14 +2386,14 @@ static void pdo_stmt_iter_dtor(zend_object_iterator *iter TSRMLS_DC) } } -static int pdo_stmt_iter_valid(zend_object_iterator *iter TSRMLS_DC) +static int pdo_stmt_iter_valid(zend_object_iterator *iter) { struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter; return Z_ISUNDEF(I->fetch_ahead) ? FAILURE : SUCCESS; } -static zval *pdo_stmt_iter_get_data(zend_object_iterator *iter TSRMLS_DC) +static zval *pdo_stmt_iter_get_data(zend_object_iterator *iter) { struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter; @@ -2406,7 +2405,7 @@ static zval *pdo_stmt_iter_get_data(zend_object_iterator *iter TSRMLS_DC) return &I->fetch_ahead; } -static void pdo_stmt_iter_get_key(zend_object_iterator *iter, zval *key TSRMLS_DC) +static void pdo_stmt_iter_get_key(zend_object_iterator *iter, zval *key) { struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter; @@ -2417,7 +2416,7 @@ static void pdo_stmt_iter_get_key(zend_object_iterator *iter, zval *key TSRMLS_D } } -static void pdo_stmt_iter_move_forwards(zend_object_iterator *iter TSRMLS_DC) +static void pdo_stmt_iter_move_forwards(zend_object_iterator *iter) { struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter; pdo_stmt_t *stmt = Z_PDO_STMT_P(&I->iter.data); /* for PDO_HANDLE_STMT_ERR() */ @@ -2427,7 +2426,7 @@ static void pdo_stmt_iter_move_forwards(zend_object_iterator *iter TSRMLS_DC) } if (!do_fetch(stmt, TRUE, &I->fetch_ahead, PDO_FETCH_USE_DEFAULT, - PDO_FETCH_ORI_NEXT, 0, 0 TSRMLS_CC)) { + PDO_FETCH_ORI_NEXT, 0, 0)) { PDO_HANDLE_STMT_ERR(); I->key = (ulong)-1; @@ -2448,7 +2447,7 @@ static zend_object_iterator_funcs pdo_stmt_iter_funcs = { NULL }; -zend_object_iterator *pdo_stmt_iter_get(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC) +zend_object_iterator *pdo_stmt_iter_get(zend_class_entry *ce, zval *object, int by_ref) { pdo_stmt_t *stmt = Z_PDO_STMT_P(object); struct php_pdo_iterator *I; @@ -2458,12 +2457,12 @@ zend_object_iterator *pdo_stmt_iter_get(zend_class_entry *ce, zval *object, int } I = ecalloc(1, sizeof(struct php_pdo_iterator)); - zend_iterator_init(&I->iter TSRMLS_CC); + zend_iterator_init(&I->iter); I->iter.funcs = &pdo_stmt_iter_funcs; ZVAL_COPY(&I->iter.data, object); if (!do_fetch(stmt, 1, &I->fetch_ahead, PDO_FETCH_USE_DEFAULT, - PDO_FETCH_ORI_NEXT, 0, 0 TSRMLS_CC)) { + PDO_FETCH_ORI_NEXT, 0, 0)) { PDO_HANDLE_STMT_ERR(); I->key = (ulong)-1; ZVAL_UNDEF(&I->fetch_ahead); @@ -2480,7 +2479,7 @@ const zend_function_entry pdo_row_functions[] = { {NULL, NULL, NULL} }; -static zval *row_prop_read(zval *object, zval *member, int type, void **cache_slot, zval *rv TSRMLS_DC) +static zval *row_prop_read(zval *object, zval *member, int type, void **cache_slot, zval *rv) { pdo_row_t *row = (pdo_row_t *)Z_OBJ_P(object); pdo_stmt_t *stmt = row->stmt; @@ -2492,12 +2491,12 @@ static zval *row_prop_read(zval *object, zval *member, int type, void **cache_sl if (stmt) { if (Z_TYPE_P(member) == IS_LONG) { if (Z_LVAL_P(member) >= 0 && Z_LVAL_P(member) < stmt->column_count) { - fetch_value(stmt, rv, Z_LVAL_P(member), NULL TSRMLS_CC); + fetch_value(stmt, rv, Z_LVAL_P(member), NULL); } } else if (Z_TYPE_P(member) == IS_STRING && is_numeric_string_ex(Z_STRVAL_P(member), Z_STRLEN_P(member), &lval, NULL, 0, NULL) == IS_LONG) { if (lval >= 0 && lval < stmt->column_count) { - fetch_value(stmt, rv, lval, NULL TSRMLS_CC); + fetch_value(stmt, rv, lval, NULL); } } else { convert_to_string(member); @@ -2505,7 +2504,7 @@ static zval *row_prop_read(zval *object, zval *member, int type, void **cache_sl * numbers */ for (colno = 0; colno < stmt->column_count; colno++) { if (strcmp(stmt->columns[colno].name, Z_STRVAL_P(member)) == 0) { - fetch_value(stmt, rv, colno, NULL TSRMLS_CC); + fetch_value(stmt, rv, colno, NULL); //??? //Z_SET_REFCOUNT_P(rv, 0); //Z_UNSET_ISREF_P(rv); @@ -2515,7 +2514,7 @@ static zval *row_prop_read(zval *object, zval *member, int type, void **cache_sl if (strcmp(Z_STRVAL_P(member), "queryString") == 0) { ZVAL_OBJ(&zobj, &stmt->std); //zval_ptr_dtor(rv); - return std_object_handlers.read_property(&zobj, member, type, cache_slot, rv TSRMLS_CC); + return std_object_handlers.read_property(&zobj, member, type, cache_slot, rv); } } } @@ -2527,22 +2526,22 @@ static zval *row_prop_read(zval *object, zval *member, int type, void **cache_sl return rv; } -static zval *row_dim_read(zval *object, zval *member, int type, zval *rv TSRMLS_DC) +static zval *row_dim_read(zval *object, zval *member, int type, zval *rv) { - return row_prop_read(object, member, type, NULL, rv TSRMLS_CC); + return row_prop_read(object, member, type, NULL, rv); } -static void row_prop_write(zval *object, zval *member, zval *value, void **cache_slot TSRMLS_DC) +static void row_prop_write(zval *object, zval *member, zval *value, void **cache_slot) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "This PDORow is not from a writable result set"); + php_error_docref(NULL, E_WARNING, "This PDORow is not from a writable result set"); } -static void row_dim_write(zval *object, zval *member, zval *value TSRMLS_DC) +static void row_dim_write(zval *object, zval *member, zval *value) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "This PDORow is not from a writable result set"); + php_error_docref(NULL, E_WARNING, "This PDORow is not from a writable result set"); } -static int row_prop_exists(zval *object, zval *member, int check_empty, void **cache_slot TSRMLS_DC) +static int row_prop_exists(zval *object, zval *member, int check_empty, void **cache_slot) { pdo_row_t *row = (pdo_row_t *)Z_OBJ_P(object); pdo_stmt_t *stmt = row->stmt; @@ -2572,22 +2571,22 @@ static int row_prop_exists(zval *object, zval *member, int check_empty, void **c return 0; } -static int row_dim_exists(zval *object, zval *member, int check_empty TSRMLS_DC) +static int row_dim_exists(zval *object, zval *member, int check_empty) { - return row_prop_exists(object, member, check_empty, NULL TSRMLS_CC); + return row_prop_exists(object, member, check_empty, NULL); } -static void row_prop_delete(zval *object, zval *offset, void **cache_slot TSRMLS_DC) +static void row_prop_delete(zval *object, zval *offset, void **cache_slot) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot delete properties from a PDORow"); + php_error_docref(NULL, E_WARNING, "Cannot delete properties from a PDORow"); } -static void row_dim_delete(zval *object, zval *offset TSRMLS_DC) +static void row_dim_delete(zval *object, zval *offset) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot delete properties from a PDORow"); + php_error_docref(NULL, E_WARNING, "Cannot delete properties from a PDORow"); } -static HashTable *row_get_properties(zval *object TSRMLS_DC) +static HashTable *row_get_properties(zval *object) { pdo_row_t *row = (pdo_row_t *)Z_OBJ_P(object); pdo_stmt_t *stmt = row->stmt; @@ -2602,7 +2601,7 @@ static HashTable *row_get_properties(zval *object TSRMLS_DC) } for (i = 0; i < stmt->column_count; i++) { zval val; - fetch_value(stmt, &val, i, NULL TSRMLS_CC); + fetch_value(stmt, &val, i, NULL); zend_hash_str_update(stmt->std.properties, stmt->columns[i].name, stmt->columns[i].namelen, &val); } @@ -2612,7 +2611,7 @@ static HashTable *row_get_properties(zval *object TSRMLS_DC) static union _zend_function *row_method_get( zend_object **object_pp, - zend_string *method_name, const zval *key TSRMLS_DC) + zend_string *method_name, const zval *key) { zend_function *fbc; zend_string *lc_method_name; @@ -2634,7 +2633,7 @@ static int row_call_method(zend_string *method, zend_object *object, INTERNAL_FU return FAILURE; } -static union _zend_function *row_get_ctor(zend_object *object TSRMLS_DC) +static union _zend_function *row_get_ctor(zend_object *object) { static zend_internal_function ctor = {0}; @@ -2647,12 +2646,12 @@ static union _zend_function *row_get_ctor(zend_object *object TSRMLS_DC) return (union _zend_function*)&ctor; } -static zend_string *row_get_classname(const zend_object *object TSRMLS_DC) +static zend_string *row_get_classname(const zend_object *object) { return zend_string_init("PDORow", sizeof("PDORow") - 1, 0); } -static int row_compare(zval *object1, zval *object2 TSRMLS_DC) +static int row_compare(zval *object1, zval *object2) { return -1; } @@ -2683,7 +2682,7 @@ zend_object_handlers pdo_row_object_handlers = { NULL }; -void pdo_row_free_storage(zend_object *std TSRMLS_DC) +void pdo_row_free_storage(zend_object *std) { pdo_row_t *row = (pdo_row_t *)std; if (row->stmt) { @@ -2692,18 +2691,18 @@ void pdo_row_free_storage(zend_object *std TSRMLS_DC) } } -zend_object *pdo_row_new(zend_class_entry *ce TSRMLS_DC) +zend_object *pdo_row_new(zend_class_entry *ce) { pdo_row_t *row = ecalloc(1, sizeof(pdo_row_t)); - zend_object_std_init(&row->std, ce TSRMLS_CC); + zend_object_std_init(&row->std, ce); row->std.handlers = &pdo_row_object_handlers; return &row->std; } -static int pdo_row_serialize(zval *object, unsigned char **buffer, size_t *buf_len, zend_serialize_data *data TSRMLS_DC) +static int pdo_row_serialize(zval *object, unsigned char **buffer, size_t *buf_len, zend_serialize_data *data) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "PDORow instances may not be serialized"); + php_error_docref(NULL, E_WARNING, "PDORow instances may not be serialized"); return FAILURE; } /* }}} */ |