From: Xinchen Hui Date: Wed, 16 Apr 2014 09:28:11 +0000 (+0800) Subject: Refactor PDO (incompleted) X-Git-Tag: POST_PHPNG_MERGE~412^2~85 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=a16a6eae2400ca27900507a44801645a4b6b3927;p=php Refactor PDO (incompleted) --- diff --git a/ext/pdo/pdo.c b/ext/pdo/pdo.c index 77c2e1823e..a2b5decc5e 100644 --- a/ext/pdo/pdo.c +++ b/ext/pdo/pdo.c @@ -76,11 +76,11 @@ PDO_API zend_class_entry *php_pdo_get_exception_base(int root TSRMLS_DC) #if can_handle_soft_dependency_on_SPL && defined(HAVE_SPL) && ((PHP_MAJOR_VERSION > 5) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 1)) if (!root) { if (!spl_ce_RuntimeException) { - zend_class_entry **pce; + zend_class_entry *pce; - if (zend_hash_find(CG(class_table), "runtimeexception", sizeof("RuntimeException"), (void **) &pce) == SUCCESS) { - spl_ce_RuntimeException = *pce; - return *pce; + if ((pce = zend_hash_str_find_ptr(CG(class_table), "runtimeexception", sizeof("RuntimeException") - 1))) { + spl_ce_RuntimeException = pce; + return pce; } } else { return spl_ce_RuntimeException; @@ -101,7 +101,7 @@ zend_class_entry *pdo_dbh_ce, *pdo_dbstmt_ce, *pdo_row_ce; PHP_FUNCTION(pdo_drivers) { HashPosition pos; - pdo_driver_t **pdriver; + pdo_driver_t *pdriver; if (zend_parse_parameters_none() == FAILURE) { return; @@ -110,8 +110,8 @@ PHP_FUNCTION(pdo_drivers) array_init(return_value); zend_hash_internal_pointer_reset_ex(&pdo_driver_hash, &pos); - while (SUCCESS == zend_hash_get_current_data_ex(&pdo_driver_hash, (void**)&pdriver, &pos)) { - add_next_index_stringl(return_value, (char*)(*pdriver)->driver_name, (*pdriver)->driver_name_len); + while ((pdriver = zend_hash_get_current_data_ptr_ex(&pdo_driver_hash, &pos)) != NULL) { + add_next_index_stringl(return_value, (char*)pdriver->driver_name, pdriver->driver_name_len); zend_hash_move_forward_ex(&pdo_driver_hash, &pos); } } @@ -185,31 +185,26 @@ PDO_API int php_pdo_register_driver(pdo_driver_t *driver) driver->driver_name, driver->api_version, PDO_DRIVER_API); return FAILURE; } - if (!zend_hash_exists(&module_registry, "pdo", sizeof("pdo"))) { + if (!zend_hash_str_exists(&module_registry, "pdo", sizeof("pdo") - 1)) { zend_error(E_ERROR, "You MUST load PDO before loading any PDO drivers"); return FAILURE; /* NOTREACHED */ } - return zend_hash_add(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len, - (void**)&driver, sizeof(pdo_driver_t *), NULL); + return zend_hash_str_add_mem(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len, (void**)&driver, sizeof(pdo_driver_t *)) != NULL; } PDO_API void php_pdo_unregister_driver(pdo_driver_t *driver) { - if (!zend_hash_exists(&module_registry, "pdo", sizeof("pdo"))) { + if (!zend_hash_str_exists(&module_registry, "pdo", sizeof("pdo") - 1)) { return; } - zend_hash_del(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len); + zend_hash_str_del(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len); } pdo_driver_t *pdo_find_driver(const char *name, int namelen) { - pdo_driver_t **driver = NULL; - - zend_hash_find(&pdo_driver_hash, (char*)name, namelen, (void**)&driver); - - return driver ? *driver : NULL; + return zend_hash_str_find_ptr(&pdo_driver_hash, (char*)name, namelen); } PDO_API int php_pdo_parse_data_source(const char *data_source, @@ -397,20 +392,20 @@ PHP_MINFO_FUNCTION(pdo) { HashPosition pos; char *drivers = NULL, *ldrivers = estrdup(""); - pdo_driver_t **pdriver; + pdo_driver_t *pdriver; php_info_print_table_start(); php_info_print_table_header(2, "PDO support", "enabled"); zend_hash_internal_pointer_reset_ex(&pdo_driver_hash, &pos); - while (SUCCESS == zend_hash_get_current_data_ex(&pdo_driver_hash, (void**)&pdriver, &pos)) { - spprintf(&drivers, 0, "%s, %s", ldrivers, (*pdriver)->driver_name); + while ((pdriver = zend_hash_get_current_data_ptr_ex(&pdo_driver_hash, &pos))) { + spprintf(&drivers, 0, "%s, %s", ldrivers, pdriver->driver_name); zend_hash_move_forward_ex(&pdo_driver_hash, &pos); efree(ldrivers); ldrivers = drivers; } - php_info_print_table_row(2, "PDO drivers", drivers ? drivers+2 : ""); + php_info_print_table_row(2, "PDO drivers", drivers ? drivers + 2 : ""); if (drivers) { efree(drivers); diff --git a/ext/pdo/pdo_dbh.c b/ext/pdo/pdo_dbh.c index 1eb0e8af3c..d3d067e57d 100644 --- a/ext/pdo/pdo_dbh.c +++ b/ext/pdo/pdo_dbh.c @@ -74,25 +74,21 @@ void pdo_raise_impl_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *sqlstate if (dbh && dbh->error_mode != PDO_ERRMODE_EXCEPTION) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", message); } else { - zval *ex, *info; + zval ex, info; zend_class_entry *def_ex = php_pdo_get_exception_base(1 TSRMLS_CC), *pdo_ex = php_pdo_get_exception(); - MAKE_STD_ZVAL(ex); - object_init_ex(ex, pdo_ex); + object_init_ex(&ex, pdo_ex); - zend_update_property_string(def_ex, ex, "message", sizeof("message")-1, message TSRMLS_CC); - zend_update_property_string(def_ex, ex, "code", sizeof("code")-1, *pdo_err TSRMLS_CC); + zend_update_property_string(def_ex, &ex, "message", sizeof("message")-1, message TSRMLS_CC); + zend_update_property_string(def_ex, &ex, "code", sizeof("code")-1, *pdo_err TSRMLS_CC); - MAKE_STD_ZVAL(info); - array_init(info); + array_init(&info); - add_next_index_string(info, *pdo_err); - add_next_index_long(info, 0); + add_next_index_string(&info, *pdo_err); + add_next_index_long(&info, 0); + zend_update_property(pdo_ex, &ex, "errorInfo", sizeof("errorInfo")-1, &info TSRMLS_CC); - zend_update_property(pdo_ex, ex, "errorInfo", sizeof("errorInfo")-1, info TSRMLS_CC); - zval_ptr_dtor(&info); - - zend_throw_exception_object(ex TSRMLS_CC); + zend_throw_exception_object(&ex TSRMLS_CC); } if (message) { @@ -108,7 +104,7 @@ PDO_API void pdo_handle_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt TSRMLS_DC) /* {{{ char *supp = NULL; long native_code = 0; char *message = NULL; - zval *info = NULL; + zval info; if (dbh == NULL || dbh->error_mode == PDO_ERRMODE_SILENT) { return; @@ -124,21 +120,21 @@ PDO_API void pdo_handle_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt TSRMLS_DC) /* {{{ msg = "<>"; } + ZVAL_UNDEF(&info); if (dbh->methods->fetch_err) { - MAKE_STD_ZVAL(info); - array_init(info); + array_init(&info); - add_next_index_string(info, *pdo_err); + add_next_index_string(&info, *pdo_err); - if (dbh->methods->fetch_err(dbh, stmt, info TSRMLS_CC)) { - zval **item; + if (dbh->methods->fetch_err(dbh, stmt, &info TSRMLS_CC)) { + zval *item; - if (SUCCESS == zend_hash_index_find(Z_ARRVAL_P(info), 1, (void**)&item)) { - native_code = Z_LVAL_PP(item); + if ((item = zend_hash_index_find(Z_ARRVAL(info), 1)) != NULL) { + native_code = Z_LVAL_P(item); } - if (SUCCESS == zend_hash_index_find(Z_ARRVAL_P(info), 2, (void**)&item)) { - supp = estrndup(Z_STRVAL_PP(item), Z_STRLEN_PP(item)); + if ((item = zend_hash_index_find(Z_ARRVAL(info), 2)) != NULL) { + supp = estrndup(Z_STRVAL_P(item), Z_STRLEN_P(item)); } } } @@ -152,23 +148,22 @@ PDO_API void pdo_handle_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt TSRMLS_DC) /* {{{ if (dbh->error_mode == PDO_ERRMODE_WARNING) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", message); } else if (EG(exception) == NULL) { - zval *ex; + zval ex; zend_class_entry *def_ex = php_pdo_get_exception_base(1 TSRMLS_CC), *pdo_ex = php_pdo_get_exception(); - MAKE_STD_ZVAL(ex); - object_init_ex(ex, pdo_ex); + object_init_ex(&ex, pdo_ex); - zend_update_property_string(def_ex, ex, "message", sizeof("message")-1, message TSRMLS_CC); - zend_update_property_string(def_ex, ex, "code", sizeof("code")-1, *pdo_err TSRMLS_CC); + zend_update_property_string(def_ex, &ex, "message", sizeof("message") - 1, message TSRMLS_CC); + zend_update_property_string(def_ex, &ex, "code", sizeof("code") - 1, *pdo_err TSRMLS_CC); - if (info) { - zend_update_property(pdo_ex, ex, "errorInfo", sizeof("errorInfo")-1, info TSRMLS_CC); + if (!ZVAL_IS_UNDEF(&info)) { + zend_update_property(pdo_ex, &ex, "errorInfo", sizeof("errorInfo") - 1, &info TSRMLS_CC); } - zend_throw_exception_object(ex TSRMLS_CC); + zend_throw_exception_object(&ex TSRMLS_CC); } - if (info) { + if (!ZVAL_IS_UNDEF(&info)) { zval_ptr_dtor(&info); } @@ -270,27 +265,28 @@ static PHP_METHOD(PDO, dbh_constructor) return; } - dbh = (pdo_dbh_t *) zend_object_store_get_object(object TSRMLS_CC); + dbh = Z_PDO_DBH_P(object); /* is this supposed to be a persistent connection ? */ if (options) { - zval **v; + zval *v; int plen = 0; char *hashkey = NULL; - zend_rsrc_list_entry *le; + zend_resource *le; pdo_dbh_t *pdbh = NULL; - if (SUCCESS == zend_hash_index_find(Z_ARRVAL_P(options), PDO_ATTR_PERSISTENT, (void**)&v)) { - if (Z_TYPE_PP(v) == IS_STRING && !is_numeric_string(Z_STRVAL_PP(v), Z_STRLEN_PP(v), NULL, NULL, 0) && Z_STRLEN_PP(v) > 0) { + if ((v = zend_hash_index_find(Z_ARRVAL_P(options), PDO_ATTR_PERSISTENT)) != NULL) { + if (Z_TYPE_P(v) == IS_STRING && + !is_numeric_string(Z_STRVAL_P(v), Z_STRLEN_P(v), NULL, NULL, 0) && Z_STRLEN_P(v) > 0) { /* user specified key */ plen = spprintf(&hashkey, 0, "PDO:DBH:DSN=%s:%s:%s:%s", data_source, username ? username : "", password ? password : "", - Z_STRVAL_PP(v)); + Z_STRVAL_P(v)); is_persistent = 1; } else { convert_to_long_ex(v); - is_persistent = Z_LVAL_PP(v) ? 1 : 0; + is_persistent = Z_LVAL_P(v) ? 1 : 0; plen = spprintf(&hashkey, 0, "PDO:DBH:DSN=%s:%s:%s", data_source, username ? username : "", password ? password : ""); @@ -299,8 +295,8 @@ static PHP_METHOD(PDO, dbh_constructor) if (is_persistent) { /* let's see if we have one cached.... */ - if (SUCCESS == zend_hash_find(&EG(persistent_list), hashkey, plen+1, (void*)&le)) { - if (Z_TYPE_P(le) == php_pdo_list_entry()) { + if ((le = zend_hash_str_find_ptr(&EG(persistent_list), hashkey, plen)) != NULL) { + if (le->type == php_pdo_list_entry()) { pdbh = (pdo_dbh_t*)le->ptr; /* is the connection still alive ? */ @@ -327,7 +323,7 @@ static PHP_METHOD(PDO, dbh_constructor) php_error_docref(NULL TSRMLS_CC, E_ERROR, "out of memory while allocating PDO handle"); } memcpy((char *)pdbh->persistent_id, hashkey, plen+1); - pdbh->persistent_id_len = plen+1; + pdbh->persistent_id_len = plen; pdbh->refcount = 1; pdbh->std.properties = NULL; } @@ -338,21 +334,19 @@ static PHP_METHOD(PDO, dbh_constructor) if (pdbh->std.properties) { zend_hash_destroy(dbh->std.properties); efree(dbh->std.properties); - if (dbh->std.properties_table) { - efree(dbh->std.properties_table); - } } else { pdbh->std.ce = dbh->std.ce; pdbh->def_stmt_ce = dbh->def_stmt_ce; - pdbh->def_stmt_ctor_args = dbh->def_stmt_ctor_args; + ZVAL_COPY_VALUE(&pdbh->def_stmt_ctor_args, &dbh->def_stmt_ctor_args); pdbh->std.properties = dbh->std.properties; - pdbh->std.properties_table = dbh->std.properties_table; + //??? + //pdbh->std.properties_table = dbh->std.properties_table; } /* kill the non-persistent thingamy */ efree(dbh); /* switch over to the persistent one */ dbh = pdbh; - zend_object_store_set_object(object, dbh TSRMLS_CC); + zend_object_store_set_object(object, &dbh->std TSRMLS_CC); dbh->refcount++; } @@ -384,7 +378,7 @@ static PHP_METHOD(PDO, dbh_constructor) /* all set */ if (is_persistent) { - zend_rsrc_list_entry le; + zend_resource le; /* register in the persistent list etc. */ /* we should also need to replace the object store entry, @@ -393,9 +387,8 @@ static PHP_METHOD(PDO, dbh_constructor) le.type = php_pdo_list_entry(); le.ptr = dbh; - if (FAILURE == zend_hash_update(&EG(persistent_list), - (char*)dbh->persistent_id, dbh->persistent_id_len, (void*)&le, - sizeof(le), NULL)) { + if (zend_hash_str_update_mem(&EG(persistent_list), + (char*)dbh->persistent_id, dbh->persistent_id_len, &le, sizeof(le))) { php_error_docref(NULL TSRMLS_CC, E_ERROR, "Failed to register persistent entry"); } } @@ -403,15 +396,15 @@ static PHP_METHOD(PDO, dbh_constructor) dbh->driver = driver; options: if (options) { - zval **attr_value; - char *str_key; + zval *attr_value; + zend_string *str_key; ulong long_key; zend_hash_internal_pointer_reset(Z_ARRVAL_P(options)); - while (SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(options), (void**)&attr_value) + while ((attr_value = zend_hash_get_current_data(Z_ARRVAL_P(options))) != NULL && HASH_KEY_IS_LONG == zend_hash_get_current_key(Z_ARRVAL_P(options), &str_key, &long_key, 0)) { - pdo_dbh_attribute_set(dbh, long_key, *attr_value TSRMLS_CC); + pdo_dbh_attribute_set(dbh, long_key, attr_value TSRMLS_CC); zend_hash_move_forward(Z_ARRVAL_P(options)); } } @@ -427,7 +420,7 @@ options: static zval *pdo_stmt_instantiate(pdo_dbh_t *dbh, zval *object, zend_class_entry *dbstmt_ce, zval *ctor_args TSRMLS_DC) /* {{{ */ { - if (ctor_args) { + if (!ZVAL_IS_UNDEF(ctor_args)) { if (Z_TYPE_P(ctor_args) != IS_ARRAY) { pdo_raise_impl_error(dbh, NULL, "HY000", "constructor arguments must be passed as an array" TSRMLS_CC); return NULL; @@ -438,47 +431,45 @@ static zval *pdo_stmt_instantiate(pdo_dbh_t *dbh, zval *object, zend_class_entry } } - Z_TYPE_P(object) = IS_OBJECT; object_init_ex(object, dbstmt_ce); - Z_SET_REFCOUNT_P(object, 1); - Z_SET_ISREF_P(object); + // ??? Z_SET_REFCOUNT_P(object, 1); + //Z_SET_ISREF_P(object); return object; } /* }}} */ static void pdo_stmt_construct(pdo_stmt_t *stmt, zval *object, zend_class_entry *dbstmt_ce, zval *ctor_args TSRMLS_DC) /* {{{ */ { - zval *query_string; + zval query_string; zval z_key; - MAKE_STD_ZVAL(query_string); - ZVAL_STRINGL(query_string, stmt->query_string, stmt->query_stringlen, 1); - ZVAL_STRINGL(&z_key, "queryString", sizeof("queryString")-1, 0); - std_object_handlers.write_property(object, &z_key, query_string, 0 TSRMLS_CC); + ZVAL_STRINGL(&query_string, stmt->query_string, stmt->query_stringlen); + ZVAL_STRINGL(&z_key, "queryString", sizeof("queryString") - 1); + std_object_handlers.write_property(object, &z_key, &query_string, NULL TSRMLS_CC); zval_ptr_dtor(&query_string); if (dbstmt_ce->constructor) { zend_fcall_info fci; zend_fcall_info_cache fcc; - zval *retval = NULL; + zval retval; fci.size = sizeof(zend_fcall_info); fci.function_table = &dbstmt_ce->function_table; - fci.function_name = NULL; - fci.object_ptr = object; + ZVAL_UNDEF(&fci.function_name); + fci.object = Z_OBJ_P(object); fci.symbol_table = NULL; - fci.retval_ptr_ptr = &retval; - if (ctor_args) { + fci.retval = &retval; + if (!ZVAL_IS_UNDEF(ctor_args)) { HashTable *ht = Z_ARRVAL_P(ctor_args); uint idx; Bucket *p; fci.param_count = 0; - fci.params = safe_emalloc(sizeof(zval*), ht->nNumOfElements, 0); + fci.params = safe_emalloc(sizeof(zval), ht->nNumOfElements, 0); for (idx = 0; idx < ht->nNumUsed; idx++) { p = ht->arData + idx; - if (!p->xData) continue; - fci.params[fci.param_count++] = (zval**)&p->xData; + if (ZVAL_IS_UNDEF(&p->val)) continue; + ZVAL_COPY_VALUE(&fci.params[fci.param_count++], &p->val); } } else { fci.param_count = 0; @@ -490,13 +481,13 @@ static void pdo_stmt_construct(pdo_stmt_t *stmt, zval *object, zend_class_entry fcc.function_handler = dbstmt_ce->constructor; fcc.calling_scope = EG(scope); fcc.called_scope = Z_OBJCE_P(object); - fcc.object_ptr = object; + fcc.object = Z_OBJ_P(object); if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) { zval_dtor(object); ZVAL_NULL(object); object = NULL; /* marks failure */ - } else if (retval) { + } else if (!ZVAL_IS_UNDEF(&retval)) { zval_ptr_dtor(&retval); } @@ -511,12 +502,12 @@ static void pdo_stmt_construct(pdo_stmt_t *stmt, zval *object, zend_class_entry Prepares a statement for execution and returns a statement object */ static PHP_METHOD(PDO, prepare) { - pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC); + pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); pdo_stmt_t *stmt; char *statement; int statement_len; - zval *options = NULL, **opt, **item, *ctor_args; - zend_class_entry *dbstmt_ce, **pce; + zval *options = NULL, *opt, *item, ctor_args; + zend_class_entry *dbstmt_ce, *pce; if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", &statement, &statement_len, &options)) { @@ -526,10 +517,10 @@ static PHP_METHOD(PDO, prepare) PDO_DBH_CLEAR_ERR(); PDO_CONSTRUCT_CHECK; - if (ZEND_NUM_ARGS() > 1 && SUCCESS == zend_hash_index_find(Z_ARRVAL_P(options), PDO_ATTR_STATEMENT_CLASS, (void**)&opt)) { - if (Z_TYPE_PP(opt) != IS_ARRAY || zend_hash_index_find(Z_ARRVAL_PP(opt), 0, (void**)&item) == FAILURE - || Z_TYPE_PP(item) != IS_STRING - || zend_lookup_class(Z_STRVAL_PP(item), Z_STRLEN_PP(item), &pce TSRMLS_CC) == FAILURE + if (ZEND_NUM_ARGS() > 1 && (opt = zend_hash_index_find(Z_ARRVAL_P(options), PDO_ATTR_STATEMENT_CLASS)) != NULL) { + if (Z_TYPE_P(opt) != IS_ARRAY || (item = zend_hash_index_find(Z_ARRVAL_P(opt), 0)) == NULL + || Z_TYPE_P(item) != IS_STRING + || (pce = zend_lookup_class(Z_STR_P(item) TSRMLS_CC)) == NULL ) { pdo_raise_impl_error(dbh, NULL, "HY000", "PDO::ATTR_STATEMENT_CLASS requires format array(classname, array(ctor_args)); " @@ -538,7 +529,7 @@ static PHP_METHOD(PDO, prepare) PDO_HANDLE_DBH_ERR(); RETURN_FALSE; } - dbstmt_ce = *pce; + dbstmt_ce = pce; if (!instanceof_function(dbstmt_ce, pdo_dbstmt_ce TSRMLS_CC)) { pdo_raise_impl_error(dbh, NULL, "HY000", "user-supplied statement class must be derived from PDOStatement" TSRMLS_CC); @@ -551,8 +542,8 @@ static PHP_METHOD(PDO, prepare) PDO_HANDLE_DBH_ERR(); RETURN_FALSE; } - if (zend_hash_index_find(Z_ARRVAL_PP(opt), 1, (void**)&item) == SUCCESS) { - if (Z_TYPE_PP(item) != IS_ARRAY) { + if ((item = zend_hash_index_find(Z_ARRVAL_P(opt), 1)) != NULL) { + if (Z_TYPE_P(item) != IS_ARRAY) { pdo_raise_impl_error(dbh, NULL, "HY000", "PDO::ATTR_STATEMENT_CLASS requires format array(classname, ctor_args); " "ctor_args must be an array" @@ -560,23 +551,23 @@ static PHP_METHOD(PDO, prepare) PDO_HANDLE_DBH_ERR(); RETURN_FALSE; } - ctor_args = *item; + ZVAL_COPY_VALUE(&ctor_args, item); } else { - ctor_args = NULL; + ZVAL_UNDEF(&ctor_args); } } else { dbstmt_ce = dbh->def_stmt_ce; - ctor_args = dbh->def_stmt_ctor_args; + ZVAL_COPY_VALUE(&ctor_args, &dbh->def_stmt_ctor_args); } - if (!pdo_stmt_instantiate(dbh, return_value, dbstmt_ce, ctor_args TSRMLS_CC)) { + if (!pdo_stmt_instantiate(dbh, return_value, dbstmt_ce, &ctor_args TSRMLS_CC)) { pdo_raise_impl_error(dbh, NULL, "HY000", "failed to instantiate user-supplied statement class" TSRMLS_CC); PDO_HANDLE_DBH_ERR(); RETURN_FALSE; } - stmt = (pdo_stmt_t*)zend_object_store_get_object(return_value TSRMLS_CC); + stmt = Z_PDO_STMT_P(return_value); /* unconditionally keep this for later reference */ stmt->query_string = estrndup(statement, statement_len); @@ -584,14 +575,14 @@ static PHP_METHOD(PDO, prepare) stmt->default_fetch_type = dbh->default_fetch_type; stmt->dbh = dbh; /* give it a reference to me */ - zend_objects_store_add_ref(getThis() TSRMLS_CC); + Z_ADDREF_P(getThis() TSRMLS_CC); php_pdo_dbh_addref(dbh TSRMLS_CC); - stmt->database_object_handle = *getThis(); + ZVAL_COPY_VALUE(&stmt->database_object_handle, getThis()); /* we haven't created a lazy object yet */ ZVAL_NULL(&stmt->lazy_object_ref); if (dbh->methods->preparer(dbh, statement, statement_len, stmt, options TSRMLS_CC)) { - pdo_stmt_construct(stmt, return_value, dbstmt_ce, ctor_args TSRMLS_CC); + pdo_stmt_construct(stmt, return_value, dbstmt_ce, &ctor_args TSRMLS_CC); return; } @@ -608,7 +599,7 @@ static PHP_METHOD(PDO, prepare) Initiates a transaction */ static PHP_METHOD(PDO, beginTransaction) { - pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC); + pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); if (zend_parse_parameters_none() == FAILURE) { return; @@ -641,7 +632,7 @@ static PHP_METHOD(PDO, beginTransaction) Commit a transaction */ static PHP_METHOD(PDO, commit) { - pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC); + pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); if (zend_parse_parameters_none() == FAILURE) { return; @@ -667,7 +658,7 @@ static PHP_METHOD(PDO, commit) roll back a transaction */ static PHP_METHOD(PDO, rollBack) { - pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC); + pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); if (zend_parse_parameters_none() == FAILURE) { return; @@ -693,7 +684,7 @@ static PHP_METHOD(PDO, rollBack) determine if inside a transaction */ static PHP_METHOD(PDO, inTransaction) { - pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC); + pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); if (zend_parse_parameters_none() == FAILURE) { return; @@ -759,9 +750,9 @@ static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_D case PDO_ATTR_DEFAULT_FETCH_MODE: if (Z_TYPE_P(value) == IS_ARRAY) { - zval **tmp; - if (zend_hash_index_find(Z_ARRVAL_P(value), 0, (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG) { - if (Z_LVAL_PP(tmp) == PDO_FETCH_INTO || Z_LVAL_PP(tmp) == PDO_FETCH_CLASS) { + zval *tmp; + if ((tmp = zend_hash_index_find(Z_ARRVAL_P(value), 0)) != NULL && Z_TYPE_P(tmp) == IS_LONG) { + if (Z_LVAL_P(tmp) == PDO_FETCH_INTO || Z_LVAL_P(tmp) == PDO_FETCH_CLASS) { pdo_raise_impl_error(dbh, NULL, "HY000", "FETCH_INTO and FETCH_CLASS are not yet supported as default fetch modes" TSRMLS_CC); return FAILURE; } @@ -785,8 +776,8 @@ static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_D case PDO_ATTR_STATEMENT_CLASS: { /* array(string classname, array(mixed ctor_args)) */ - zend_class_entry **pce; - zval **item; + zend_class_entry *pce; + zval *item; if (dbh->is_persistent) { pdo_raise_impl_error(dbh, NULL, "HY000", @@ -796,9 +787,9 @@ static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_D return FAILURE; } if (Z_TYPE_P(value) != IS_ARRAY - || zend_hash_index_find(Z_ARRVAL_P(value), 0, (void**)&item) == FAILURE - || Z_TYPE_PP(item) != IS_STRING - || zend_lookup_class(Z_STRVAL_PP(item), Z_STRLEN_PP(item), &pce TSRMLS_CC) == FAILURE + || (item = zend_hash_index_find(Z_ARRVAL_P(value), 0)) == NULL + || Z_TYPE_P(item) != IS_STRING + || (pce = zend_lookup_class(Z_STR_P(item) TSRMLS_CC)) == NULL ) { pdo_raise_impl_error(dbh, NULL, "HY000", "PDO::ATTR_STATEMENT_CLASS requires format array(classname, array(ctor_args)); " @@ -807,25 +798,25 @@ static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_D PDO_HANDLE_DBH_ERR(); return FAILURE; } - if (!instanceof_function(*pce, pdo_dbstmt_ce TSRMLS_CC)) { + if (!instanceof_function(pce, pdo_dbstmt_ce TSRMLS_CC)) { pdo_raise_impl_error(dbh, NULL, "HY000", "user-supplied statement class must be derived from PDOStatement" TSRMLS_CC); PDO_HANDLE_DBH_ERR(); return FAILURE; } - if ((*pce)->constructor && !((*pce)->constructor->common.fn_flags & (ZEND_ACC_PRIVATE|ZEND_ACC_PROTECTED))) { + if (pce->constructor && !(pce->constructor->common.fn_flags & (ZEND_ACC_PRIVATE|ZEND_ACC_PROTECTED))) { pdo_raise_impl_error(dbh, NULL, "HY000", "user-supplied statement class cannot have a public constructor" TSRMLS_CC); PDO_HANDLE_DBH_ERR(); return FAILURE; } - dbh->def_stmt_ce = *pce; - if (dbh->def_stmt_ctor_args) { + dbh->def_stmt_ce = pce; + if (!ZVAL_IS_UNDEF(&dbh->def_stmt_ctor_args)) { zval_ptr_dtor(&dbh->def_stmt_ctor_args); - dbh->def_stmt_ctor_args = NULL; + ZVAL_UNDEF(&dbh->def_stmt_ctor_args); } - if (zend_hash_index_find(Z_ARRVAL_P(value), 1, (void**)&item) == SUCCESS) { - if (Z_TYPE_PP(item) != IS_ARRAY) { + if ((item = zend_hash_index_find(Z_ARRVAL_P(value), 1)) != NULL) { + if (Z_TYPE_P(item) != IS_ARRAY) { pdo_raise_impl_error(dbh, NULL, "HY000", "PDO::ATTR_STATEMENT_CLASS requires format array(classname, array(ctor_args)); " "ctor_args must be an array" @@ -833,8 +824,7 @@ static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_D PDO_HANDLE_DBH_ERR(); return FAILURE; } - Z_ADDREF_PP(item); - dbh->def_stmt_ctor_args = *item; + ZVAL_COPY(&dbh->def_stmt_ctor_args, item); } return SUCCESS; } @@ -868,7 +858,7 @@ fail: Set an attribute */ static PHP_METHOD(PDO, setAttribute) { - pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC); + pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); long attr; zval *value; @@ -890,7 +880,7 @@ static PHP_METHOD(PDO, setAttribute) Get an attribute */ static PHP_METHOD(PDO, getAttribute) { - pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC); + pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); long attr; if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &attr)) { @@ -915,19 +905,20 @@ static PHP_METHOD(PDO, getAttribute) RETURN_LONG(dbh->error_mode); case PDO_ATTR_DRIVER_NAME: - RETURN_STRINGL((char*)dbh->driver->driver_name, dbh->driver->driver_name_len, 1); + RETURN_STRINGL((char*)dbh->driver->driver_name, dbh->driver->driver_name_len); case PDO_ATTR_STATEMENT_CLASS: array_init(return_value); - add_next_index_string(return_value, dbh->def_stmt_ce->name); - if (dbh->def_stmt_ctor_args) { - Z_ADDREF_P(dbh->def_stmt_ctor_args); - add_next_index_zval(return_value, dbh->def_stmt_ctor_args); + add_next_index_str(return_value, STR_COPY(dbh->def_stmt_ce->name)); + if (!ZVAL_IS_UNDEF(&dbh->def_stmt_ctor_args)) { + Z_ADDREF(dbh->def_stmt_ctor_args); + add_next_index_zval(return_value, &dbh->def_stmt_ctor_args); } return; case PDO_ATTR_DEFAULT_FETCH_MODE: RETURN_LONG(dbh->default_fetch_type); - + default: + break; } if (!dbh->methods->get_attribute) { @@ -954,7 +945,7 @@ static PHP_METHOD(PDO, getAttribute) Execute a query that does not return a row set, returning the number of affected rows */ static PHP_METHOD(PDO, exec) { - pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC); + pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); char *statement; int statement_len; long ret; @@ -979,12 +970,11 @@ static PHP_METHOD(PDO, exec) } /* }}} */ - /* {{{ proto string PDO::lastInsertId([string seqname]) Returns the id of the last row that we affected on this connection. Some databases require a sequence or table name to be passed in. Not always meaningful. */ static PHP_METHOD(PDO, lastInsertId) { - pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC); + pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); char *name = NULL; int namelen; @@ -998,12 +988,16 @@ static PHP_METHOD(PDO, lastInsertId) pdo_raise_impl_error(dbh, NULL, "IM001", "driver does not support lastInsertId()" TSRMLS_CC); RETURN_FALSE; } else { - Z_STRVAL_P(return_value) = dbh->methods->last_id(dbh, name, (unsigned int *)&Z_STRLEN_P(return_value) TSRMLS_CC); - if (!Z_STRVAL_P(return_value)) { + int id_len; + char *id; + id = dbh->methods->last_id(dbh, name, (unsigned int *)&id_len TSRMLS_CC); + if (!id) { PDO_HANDLE_DBH_ERR(); RETURN_FALSE; } else { - Z_TYPE_P(return_value) = IS_STRING; + //??? use zend_string ? + RETVAL_STRINGL(id, id_len); + efree(id); } } } @@ -1013,7 +1007,7 @@ static PHP_METHOD(PDO, lastInsertId) Fetch the error code associated with the last operation on the database handle */ static PHP_METHOD(PDO, errorCode) { - pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC); + pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); if (zend_parse_parameters_none() == FAILURE) { return; @@ -1021,7 +1015,7 @@ static PHP_METHOD(PDO, errorCode) PDO_CONSTRUCT_CHECK; if (dbh->query_stmt) { - RETURN_STRING(dbh->query_stmt->error_code, 1); + RETURN_STRING(dbh->query_stmt->error_code); } if (dbh->error_code[0] == '\0') { @@ -1032,7 +1026,7 @@ static PHP_METHOD(PDO, errorCode) * Making sure that we fallback to the default implementation * if the dbh->error_code is not null. */ - RETURN_STRING(dbh->error_code, 1); + RETURN_STRING(dbh->error_code); } /* }}} */ @@ -1044,7 +1038,7 @@ static PHP_METHOD(PDO, errorInfo) int error_count_diff = 0; int error_expected_count = 3; - pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC); + pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); if (zend_parse_parameters_none() == FAILURE) { return; @@ -1086,7 +1080,7 @@ static PHP_METHOD(PDO, errorInfo) Prepare and execute $sql; returns the statement object for iteration */ static PHP_METHOD(PDO, query) { - pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC); + pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); pdo_stmt_t *stmt; char *statement; int statement_len; @@ -1105,11 +1099,11 @@ static PHP_METHOD(PDO, query) PDO_DBH_CLEAR_ERR(); PDO_CONSTRUCT_CHECK; - if (!pdo_stmt_instantiate(dbh, return_value, dbh->def_stmt_ce, dbh->def_stmt_ctor_args TSRMLS_CC)) { + if (!pdo_stmt_instantiate(dbh, return_value, dbh->def_stmt_ce, &dbh->def_stmt_ctor_args TSRMLS_CC)) { pdo_raise_impl_error(dbh, NULL, "HY000", "failed to instantiate user supplied statement class" TSRMLS_CC); return; } - stmt = (pdo_stmt_t*)zend_object_store_get_object(return_value TSRMLS_CC); + stmt = Z_PDO_STMT_P(return_value); /* unconditionally keep this for later reference */ stmt->query_string = estrndup(statement, statement_len); @@ -1120,7 +1114,7 @@ static PHP_METHOD(PDO, query) stmt->active_query_stringlen = statement_len; stmt->dbh = dbh; /* give it a reference to me */ - zend_objects_store_add_ref(getThis() TSRMLS_CC); + Z_ADDREF_P(getThis()); php_pdo_dbh_addref(dbh TSRMLS_CC); stmt->database_object_handle = *getThis(); /* we haven't created a lazy object yet */ @@ -1141,14 +1135,14 @@ static PHP_METHOD(PDO, query) stmt->executed = 1; } if (ret) { - pdo_stmt_construct(stmt, return_value, dbh->def_stmt_ce, dbh->def_stmt_ctor_args TSRMLS_CC); + pdo_stmt_construct(stmt, return_value, dbh->def_stmt_ce, &dbh->def_stmt_ctor_args TSRMLS_CC); return; } } } /* something broke */ dbh->query_stmt = stmt; - dbh->query_stmt_zval = *return_value; + ZVAL_COPY_VALUE(&dbh->query_stmt_zval, return_value); PDO_HANDLE_STMT_ERR(); } else { PDO_HANDLE_DBH_ERR(); @@ -1163,7 +1157,7 @@ static PHP_METHOD(PDO, query) quotes string for use in a query. The optional paramtype acts as a hint for drivers that have alternate quoting styles. The default value is PDO_PARAM_STR */ static PHP_METHOD(PDO, quote) { - pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC); + pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); char *str; int str_len; long paramtype = PDO_PARAM_STR; @@ -1182,7 +1176,8 @@ static PHP_METHOD(PDO, quote) } if (dbh->methods->quoter(dbh, str, str_len, &qstr, &qlen, paramtype TSRMLS_CC)) { - RETURN_STRINGL(qstr, qlen, 0); + //??? memleak + RETURN_STRINGL(qstr, qlen); } PDO_HANDLE_DBH_ERR(); RETURN_FALSE; @@ -1210,7 +1205,7 @@ static PHP_METHOD(PDO, __sleep) static PHP_METHOD(PDO, getAvailableDrivers) { HashPosition pos; - pdo_driver_t **pdriver; + pdo_driver_t *pdriver; if (zend_parse_parameters_none() == FAILURE) { return; @@ -1219,8 +1214,8 @@ static PHP_METHOD(PDO, getAvailableDrivers) array_init(return_value); zend_hash_internal_pointer_reset_ex(&pdo_driver_hash, &pos); - while (SUCCESS == zend_hash_get_current_data_ex(&pdo_driver_hash, (void**)&pdriver, &pos)) { - add_next_index_stringl(return_value, (char*)(*pdriver)->driver_name, (*pdriver)->driver_name_len); + while ((pdriver = zend_hash_get_current_data_ptr_ex(&pdo_driver_hash, &pos)) != NULL) { + add_next_index_stringl(return_value, (char*)pdriver->driver_name, pdriver->driver_name_len); zend_hash_move_forward_ex(&pdo_driver_hash, &pos); } } @@ -1311,7 +1306,7 @@ int pdo_hash_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC) while (funcs->fname) { ifunc->type = ZEND_INTERNAL_FUNCTION; ifunc->handler = funcs->handler; - ifunc->function_name = (char*)funcs->fname; + ifunc->function_name = STR_INIT(funcs->fname, strlen(funcs->fname), 0); ifunc->scope = dbh->std.ce; ifunc->prototype = NULL; if (funcs->flags) { @@ -1343,7 +1338,7 @@ int pdo_hash_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC) namelen = strlen(funcs->fname); lc_name = emalloc(namelen+1); zend_str_tolower_copy(lc_name, funcs->fname, namelen); - zend_hash_add(dbh->cls_methods[kind], lc_name, namelen+1, &func, sizeof(func), NULL); + zend_hash_str_add_mem(dbh->cls_methods[kind], lc_name, namelen, &func, sizeof(func)); efree(lc_name); funcs++; } @@ -1351,25 +1346,16 @@ int pdo_hash_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC) return 1; } -static union _zend_function *dbh_method_get( -#if PHP_API_VERSION >= 20041225 - zval **object_pp, -#else - zval *object, -#endif - char *method_name, int method_len, const zend_literal *key TSRMLS_DC) +static union _zend_function *dbh_method_get(zend_object **object, zend_string *method_name, const zend_literal *key TSRMLS_DC) { zend_function *fbc = NULL; - char *lc_method_name; -#if PHP_API_VERSION >= 20041225 - zval *object = *object_pp; -#endif - pdo_dbh_t *dbh = zend_object_store_get_object(object TSRMLS_CC); + pdo_dbh_t *dbh = php_pdo_dbh_fetch_object(*object); + zend_string *lc_method_name; - lc_method_name = emalloc(method_len + 1); - zend_str_tolower_copy(lc_method_name, method_name, method_len); + lc_method_name = STR_INIT(method_name->val, method_name->len, 0); + zend_str_tolower_copy(lc_method_name->val, method_name->val, method_name->len); - if ((fbc = std_object_handlers.get_method(object_pp, method_name, method_len, key TSRMLS_CC)) == NULL) { + if ((fbc = std_object_handlers.get_method(object, method_name, key TSRMLS_CC)) == NULL) { /* not a pre-defined method, nor a user-defined method; check * the driver specific methods */ if (!dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_DBH]) { @@ -1380,16 +1366,11 @@ static union _zend_function *dbh_method_get( } } - if (zend_hash_find(dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_DBH], - lc_method_name, method_len+1, (void**)&fbc) == FAILURE) { - if (!fbc) { - fbc = NULL; - } - } + fbc = zend_hash_find_ptr(dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_DBH], lc_method_name); } out: - efree(lc_method_name); + STR_RELEASE(lc_method_name); return fbc; } @@ -1399,6 +1380,7 @@ static int dbh_compare(zval *object1, zval *object2 TSRMLS_DC) } static zend_object_handlers pdo_dbh_object_handlers; +static void pdo_dbh_free_storage(zend_object *std TSRMLS_DC); void pdo_dbh_init(TSRMLS_D) { @@ -1409,6 +1391,9 @@ void pdo_dbh_init(TSRMLS_D) pdo_dbh_ce->create_object = pdo_dbh_new; memcpy(&pdo_dbh_object_handlers, &std_object_handlers, sizeof(zend_object_handlers)); + pdo_dbh_object_handlers.offset = XtOffsetOf(pdo_dbh_t, std); + pdo_dbh_object_handlers.dtor_obj = zend_objects_destroy_object; + pdo_dbh_object_handlers.free_obj = pdo_dbh_free_storage; pdo_dbh_object_handlers.get_method = dbh_method_get; pdo_dbh_object_handlers.compare_objects = dbh_compare; @@ -1539,7 +1524,7 @@ static void dbh_free(pdo_dbh_t *dbh TSRMLS_DC) pefree((char *)dbh->persistent_id, dbh->is_persistent); } - if (dbh->def_stmt_ctor_args) { + if (!ZVAL_IS_UNDEF(&dbh->def_stmt_ctor_args)) { zval_ptr_dtor(&dbh->def_stmt_ctor_args); } @@ -1563,8 +1548,9 @@ PDO_API void php_pdo_dbh_delref(pdo_dbh_t *dbh TSRMLS_DC) dbh_free(dbh TSRMLS_CC); } -static void pdo_dbh_free_storage(pdo_dbh_t *dbh TSRMLS_DC) +static void pdo_dbh_free_storage(zend_object *std TSRMLS_DC) { + pdo_dbh_t *dbh = php_pdo_dbh_fetch_object(std); if (dbh->in_txn && dbh->methods && dbh->methods->rollback) { dbh->methods->rollback(dbh TSRMLS_CC); dbh->in_txn = 0; @@ -1573,39 +1559,34 @@ static void pdo_dbh_free_storage(pdo_dbh_t *dbh TSRMLS_DC) if (dbh->is_persistent && dbh->methods && dbh->methods->persistent_shutdown) { dbh->methods->persistent_shutdown(dbh TSRMLS_CC); } - zend_object_std_dtor(&dbh->std TSRMLS_CC); - dbh->std.properties = NULL; - dbh->std.properties_table = NULL; - dbh_free(dbh TSRMLS_CC); + zend_object_std_dtor(std TSRMLS_CC); } -zend_object_value pdo_dbh_new(zend_class_entry *ce TSRMLS_DC) +zend_object *pdo_dbh_new(zend_class_entry *ce TSRMLS_DC) { - zend_object_value retval; pdo_dbh_t *dbh; - dbh = emalloc(sizeof(*dbh)); - memset(dbh, 0, sizeof(*dbh)); + dbh = ecalloc(1, sizeof(pdo_dbh_t) + sizeof(zval) * (ce->default_properties_count - 1)); zend_object_std_init(&dbh->std, ce TSRMLS_CC); object_properties_init(&dbh->std, ce); rebuild_object_properties(&dbh->std); dbh->refcount = 1; dbh->def_stmt_ce = pdo_dbstmt_ce; - retval.handle = zend_objects_store_put(dbh, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t)pdo_dbh_free_storage, NULL TSRMLS_CC); - retval.handlers = &pdo_dbh_object_handlers; + zend_objects_store_put(&dbh->std TSRMLS_CC); + dbh->std.handlers = &pdo_dbh_object_handlers; - return retval; + return &dbh->std; } /* }}} */ ZEND_RSRC_DTOR_FUNC(php_pdo_pdbh_dtor) { - if (rsrc->ptr) { - pdo_dbh_t *dbh = (pdo_dbh_t*)rsrc->ptr; + if (res->ptr) { + pdo_dbh_t *dbh = (pdo_dbh_t*)res->ptr; dbh_free(dbh TSRMLS_CC); - rsrc->ptr = NULL; + res->ptr = NULL; } } diff --git a/ext/pdo/php_pdo_driver.h b/ext/pdo/php_pdo_driver.h index 56a69cac30..5abb15a177 100644 --- a/ext/pdo/php_pdo_driver.h +++ b/ext/pdo/php_pdo_driver.h @@ -194,21 +194,21 @@ enum pdo_null_handling { /* {{{ utils for reading attributes set as driver_options */ static inline long pdo_attr_lval(zval *options, enum pdo_attribute_type option_name, long defval TSRMLS_DC) { - zval **v; + zval *v; - if (options && SUCCESS == zend_hash_index_find(Z_ARRVAL_P(options), option_name, (void**)&v)) { + if (options && (v = zend_hash_index_find(Z_ARRVAL_P(options), option_name))) { convert_to_long_ex(v); - return Z_LVAL_PP(v); + return Z_LVAL_P(v); } return defval; } static inline char *pdo_attr_strval(zval *options, enum pdo_attribute_type option_name, char *defval TSRMLS_DC) { - zval **v; + zval *v; - if (options && SUCCESS == zend_hash_index_find(Z_ARRVAL_P(options), option_name, (void**)&v)) { + if (options && (v = zend_hash_index_find(Z_ARRVAL_P(options), option_name))) { convert_to_string_ex(v); - return estrndup(Z_STRVAL_PP(v), Z_STRLEN_PP(v)); + return estrndup(Z_STRVAL_P(v), Z_STRLEN_P(v)); } return defval ? estrdup(defval) : NULL; } @@ -426,13 +426,6 @@ enum pdo_placeholder_support { /* represents a connection to a database */ struct _pdo_dbh_t { - /* these items must appear in this order at the beginning of the - struct so that this can be cast as a zend_object. we need this - to allow the extending class to escape all the custom handlers - that PDO declares. - */ - zend_object std; - /* driver specific methods */ struct pdo_dbh_methods *methods; /* driver specific data */ @@ -496,7 +489,7 @@ struct _pdo_dbh_t { zend_class_entry *def_stmt_ce; - zval *def_stmt_ctor_args; + zval def_stmt_ctor_args; /* when calling PDO::query(), we need to keep the error * context from the statement around until we next clear it. @@ -507,8 +500,21 @@ struct _pdo_dbh_t { /* defaults for fetches */ enum pdo_fetch_type default_fetch_type; + + /* these items must appear in this order at the beginning of the + struct so that this can be cast as a zend_object. we need this + to allow the extending class to escape all the custom handlers + that PDO declares. + */ + zend_object std; }; +static inline pdo_dbh_t *php_pdo_dbh_fetch_object(zend_object *obj) { + return (pdo_dbh_t *)((char*)(obj) - XtOffsetOf(pdo_dbh_t, std)); +} + +#define Z_PDO_DBH_P(zv) php_pdo_dbh_fetch_object(Z_OBJ_P((zv))) + /* describes a column */ struct pdo_column_data { char *name; @@ -541,13 +547,6 @@ struct pdo_bound_param_data { /* represents a prepared statement */ struct _pdo_stmt_t { - /* these items must appear in this order at the beginning of the - struct so that this can be cast as a zend_object. we need this - to allow the extending class to escape all the custom handlers - that PDO declares. - */ - zend_object std; - /* driver specifics */ struct pdo_stmt_methods *methods; void *driver_data; @@ -626,8 +625,21 @@ struct _pdo_stmt_t { /* used by the query parser for driver specific * parameter naming (see pgsql driver for example) */ const char *named_rewrite_template; + + /* these items must appear in this order at the beginning of the + struct so that this can be cast as a zend_object. we need this + to allow the extending class to escape all the custom handlers + that PDO declares. + */ + zend_object std; }; +static inline pdo_stmt_t *php_pdo_stmt_fetch_object(zend_object *obj) { + return (pdo_stmt_t *)((char*)(obj) - XtOffsetOf(pdo_stmt_t, std)); +} + +#define Z_PDO_STMT_P(zv) php_pdo_stmt_fetch_object(Z_OBJ_P((zv))) + /* call this in MINIT to register your PDO driver */ PDO_API int php_pdo_register_driver(pdo_driver_t *driver); /* call this in MSHUTDOWN to unregister your PDO driver */ diff --git a/ext/pdo/php_pdo_error.h b/ext/pdo/php_pdo_error.h index 74fe0ad0fe..60bb89a8f8 100644 --- a/ext/pdo/php_pdo_error.h +++ b/ext/pdo/php_pdo_error.h @@ -29,7 +29,7 @@ PDO_API void pdo_handle_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt TSRMLS_DC); strlcpy(dbh->error_code, PDO_ERR_NONE, sizeof(PDO_ERR_NONE)); \ if (dbh->query_stmt) { \ dbh->query_stmt = NULL; \ - zend_objects_store_del_ref(&dbh->query_stmt_zval TSRMLS_CC); \ + zval_ptr_dtor(&dbh->query_stmt_zval); \ } \ } while (0) #define PDO_STMT_CLEAR_ERR() strcpy(stmt->error_code, PDO_ERR_NONE) diff --git a/ext/pdo/php_pdo_int.h b/ext/pdo/php_pdo_int.h index e1868644a3..d25f5c3ba4 100644 --- a/ext/pdo/php_pdo_int.h +++ b/ext/pdo/php_pdo_int.h @@ -33,12 +33,12 @@ int php_pdo_list_entry(void); void pdo_dbh_init(TSRMLS_D); void pdo_stmt_init(TSRMLS_D); -extern zend_object_value pdo_dbh_new(zend_class_entry *ce TSRMLS_DC); +extern zend_object *pdo_dbh_new(zend_class_entry *ce TSRMLS_DC); extern const zend_function_entry pdo_dbh_functions[]; extern zend_class_entry *pdo_dbh_ce; extern ZEND_RSRC_DTOR_FUNC(php_pdo_pdbh_dtor); -extern zend_object_value pdo_dbstmt_new(zend_class_entry *ce TSRMLS_DC); +extern zend_object *pdo_dbstmt_new(zend_class_entry *ce TSRMLS_DC); extern const zend_function_entry pdo_dbstmt_functions[]; extern zend_class_entry *pdo_dbstmt_ce; void pdo_dbstmt_free_storage(pdo_stmt_t *stmt TSRMLS_DC); @@ -47,7 +47,7 @@ extern zend_object_handlers pdo_dbstmt_object_handlers; int pdo_stmt_describe_columns(pdo_stmt_t *stmt TSRMLS_DC); int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, int skip_first_arg); -extern zend_object_value pdo_row_new(zend_class_entry *ce TSRMLS_DC); +extern zend_object *pdo_row_new(zend_class_entry *ce TSRMLS_DC); extern const zend_function_entry pdo_row_functions[]; extern zend_class_entry *pdo_row_ce; void pdo_row_free_storage(pdo_stmt_t *stmt TSRMLS_DC);