Refactored ext/pdo_firebird (didn't do test)

diff --git a/ext/pdo_firebird/firebird_driver.c b/ext/pdo_firebird/firebird_driver.c
index e45f7981d91e5c1d5be08d1b61f49197dc0de83f..20a41bbb9b2addf7c29848e90ca973b158e1a9c4 100644 (file)
--- a/ext/pdo_firebird/firebird_driver.c
+++ b/ext/pdo_firebird/firebird_driver.c
@@ -447,8 +447,9 @@ static int firebird_alloc_prepare_stmt(pdo_dbh_t *dbh, const char *sql, long sql
                                } else {
                                        *ppname++ = 0;
                                        if (named_params) {
-                                               zend_hash_update(named_params, pname, (unsigned int)(ppname-pname),
-                                                       (void*)&pindex, sizeof(long)+1,NULL);
+                                               zval tmp;
+                                               ZVAL_LONG(&tmp, pindex);
+                                               zend_hash_str_update(named_params, pname, (unsigned int)(ppname - pname - 1), &tmp);
                                        }
                                }
                        }
@@ -479,9 +480,9 @@ static int firebird_handle_set_attribute(pdo_dbh_t *dbh, long attr, zval *val TS
                        convert_to_boolean(val);
        
                        /* ignore if the new value equals the old one */                        
-                       if (dbh->auto_commit ^ Z_BVAL_P(val)) {
+                       if (dbh->auto_commit ^ (Z_TYPE_P(val) == IS_TRUE? 1 : 0)) {
                                if (dbh->in_txn) {
-                                       if (Z_BVAL_P(val)) {
+                                       if (Z_TYPE_P(val) == IS_TRUE) {
                                                /* turning on auto_commit with an open transaction is illegal, because
                                                   we won't know what to do with it */
                                                H->last_app_error = "Cannot enable auto-commit while a transaction is already open";
@@ -494,13 +495,13 @@ static int firebird_handle_set_attribute(pdo_dbh_t *dbh, long attr, zval *val TS
                                                dbh->in_txn = 0;
                                        }
                                }
-                               dbh->auto_commit = Z_BVAL_P(val);
+                               dbh->auto_commit = Z_TYPE_P(val) == IS_TRUE? 1 : 0;
                        }
                        return 1;
 
                case PDO_ATTR_FETCH_TABLE_NAMES:
                        convert_to_boolean(val);
-                       H->fetch_table_names = Z_BVAL_P(val);
+                       H->fetch_table_names = Z_TYPE_P(val) == IS_TRUE? 1 : 0;
                        return 1;
 
                case PDO_FB_ATTR_DATE_FORMAT:
@@ -574,7 +575,7 @@ static int firebird_handle_get_attribute(pdo_dbh_t *dbh, long attr, zval *val TS
 #endif
                        if (info_func) {
                                info_func(tmp);
-                               ZVAL_STRING(val,tmp,1);
+                               ZVAL_STRING(val, tmp);
                        } 
 #else
                        ZVAL_NULL(val);
@@ -587,7 +588,7 @@ static int firebird_handle_get_attribute(pdo_dbh_t *dbh, long attr, zval *val TS
                        *tmp = 0;
                        
                        if (!isc_version(&H->db, firebird_info_cb, (void*)tmp)) {
-                               ZVAL_STRING(val,tmp,1);
+                               ZVAL_STRING(val, tmp);
                                return 1;
                        }
                        

diff --git a/ext/pdo_firebird/firebird_statement.c b/ext/pdo_firebird/firebird_statement.c
index 5eb2e977e71e3a6848811d45b7edc50af953e424..586960cbf74d3968d569d056611319b6569b762d 100644 (file)
--- a/ext/pdo_firebird/firebird_statement.c
+++ b/ext/pdo_firebird/firebird_statement.c
@@ -422,9 +422,8 @@ static int firebird_bind_blob(pdo_stmt_t *stmt, ISC_QUAD *blob_id, zval *param T
                return 0;
        }
 
-       SEPARATE_ZVAL(&param);
-
-       convert_to_string_ex(&param);
+       SEPARATE_ZVAL(param);
+       convert_to_string_ex(param);
        
        for (rem_cnt = Z_STRLEN_P(param); rem_cnt > 0; rem_cnt -= chunk_size)  {
 
@@ -438,7 +437,7 @@ static int firebird_bind_blob(pdo_stmt_t *stmt, ISC_QUAD *blob_id, zval *param T
                put_cnt += chunk_size;
        }
        
-       zval_dtor(param);
+       zval_ptr_dtor(param);
 
        if (isc_close_blob(H->isc_status, &h)) {
                RECORD_ERROR(stmt);
@@ -464,11 +463,11 @@ static int firebird_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_dat
                return 0;
        }
        if (param->is_param && param->paramno == -1) {
-               long *index;
+               zval *index;
 
                /* try to determine the index by looking in the named_params hash */
-               if (SUCCESS == zend_hash_find(S->named_params, param->name, param->namelen+1, (void*)&index)) {
-                       param->paramno = *index;
+               if ((index = zend_hash_find(S->named_params, param->name)) != NULL) {
+                       param->paramno = Z_LVAL_P(index);
                } else {
                        /* ... or by looking in the input descriptor */
                        int i;
@@ -476,10 +475,10 @@ static int firebird_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_dat
                        for (i = 0; i < sqlda->sqld; ++i) {
                                XSQLVAR *var = &sqlda->sqlvar[i];
 
-                               if ((var->aliasname_length && !strncasecmp(param->name, var->aliasname, 
-                                               min(param->namelen, var->aliasname_length))) 
-                                               || (var->sqlname_length && !strncasecmp(param->name, var->sqlname,
-                                               min(param->namelen, var->sqlname_length)))) {
+                               if ((var->aliasname_length && !strncasecmp(param->name->val, var->aliasname, 
+                                               min(param->name->len, var->aliasname_length))) 
+                                               || (var->sqlname_length && !strncasecmp(param->name->val, var->sqlname,
+                                               min(param->name->len, var->sqlname_length)))) {
                                        param->paramno = i;
                                        break;
                                }
@@ -498,6 +497,7 @@ static int firebird_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_dat
                char *value;
                unsigned long value_len;
                int caller_frees;
+               zval *parameter;
                        
                case PDO_PARAM_EVT_ALLOC:
                        if (param->is_param) {
@@ -516,6 +516,11 @@ static int firebird_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_dat
                        }
 
                        *var->sqlind = 0;
+                       if (Z_ISREF(param->parameter)) {
+                               parameter = Z_REFVAL(param->parameter);
+                       } else {
+                               parameter = &param->parameter;
+                       }
 
                        switch (var->sqltype & ~1) {
                                case SQL_ARRAY:
@@ -524,24 +529,23 @@ static int firebird_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_dat
                                        return 0;
        
                                case SQL_BLOB:
-                                       return firebird_bind_blob(stmt, (ISC_QUAD*)var->sqldata,
-                                               param->parameter TSRMLS_CC);
+                                       return firebird_bind_blob(stmt, (ISC_QUAD*)var->sqldata, parameter TSRMLS_CC);
                        }
                                                        
                        /* check if a NULL should be inserted */
-                       switch (Z_TYPE_P(param->parameter)) {
+                       switch (Z_TYPE_P(parameter)) {
                                int force_null;
                                
                                case IS_LONG:
                                        /* keep the allow-NULL flag */
                                        var->sqltype = (sizeof(long) == 8 ? SQL_INT64 : SQL_LONG) | (var->sqltype & 1);
-                                       var->sqldata = (void*)&Z_LVAL_P(param->parameter);
+                                       var->sqldata = (void*)&Z_LVAL_P(parameter);
                                        var->sqllen = sizeof(long);
                                        break;
                                case IS_DOUBLE:
                                        /* keep the allow-NULL flag */
                                        var->sqltype = SQL_DOUBLE | (var->sqltype & 1);
-                                       var->sqldata = (void*)&Z_DVAL_P(param->parameter);
+                                       var->sqldata = (void*)&Z_DVAL_P(parameter);
                                        var->sqllen = sizeof(double);
                                        break;
                                case IS_STRING:
@@ -557,13 +561,13 @@ static int firebird_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_dat
                                                case SQL_TIMESTAMP:
                                                case SQL_TYPE_DATE:
                                                case SQL_TYPE_TIME:
-                                                       force_null = (Z_STRLEN_P(param->parameter) == 0);
+                                                       force_null = (Z_STRLEN_P(parameter) == 0);
                                        }
                                        if (!force_null) {
                                                /* keep the allow-NULL flag */
                                                var->sqltype = SQL_TEXT | (var->sqltype & 1);
-                                               var->sqldata = Z_STRVAL_P(param->parameter);
-                                               var->sqllen      = Z_STRLEN_P(param->parameter);
+                                               var->sqldata = Z_STRVAL_P(parameter);
+                                               var->sqllen      = Z_STRLEN_P(parameter);
                                                break;
                                        }
                                case IS_NULL:
@@ -592,30 +596,35 @@ static int firebird_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_dat
                        value = NULL;
                        value_len = 0;
                        caller_frees = 0;
+                       if (Z_ISREF(param->parameter)) {
+                               parameter = Z_REFVAL(param->parameter);
+                       } else {
+                               parameter = &param->parameter;
+                       }
                        
                        if (firebird_stmt_get_col(stmt, param->paramno, &value, &value_len, &caller_frees TSRMLS_CC)) {
                                switch (PDO_PARAM_TYPE(param->param_type)) {
                                        case PDO_PARAM_STR:
                                                if (value) {
-                                                       ZVAL_STRINGL(param->parameter, value, value_len, 1);
+                                                       ZVAL_STRINGL(parameter, value, value_len);
                                                        break;
                                                }
                                        case PDO_PARAM_INT:
                                                if (value) {
-                                                       ZVAL_LONG(param->parameter, *(long*)value);
+                                                       ZVAL_LONG(parameter, *(long*)value);
                                                        break;
                                                }
-                                        case PDO_PARAM_EVT_NORMALIZE:
-                                                 if (!param->is_param) {
-                                                      char *s = param->name;
-                                                      while (*s != '\0') {
-                                                           *s = toupper(*s);
-                                                            s++;
-                                                      }
-                                                 }
-                                                        break;
+                                       case PDO_PARAM_EVT_NORMALIZE:
+                                                        if (!param->is_param) {
+                                                                 char *s = param->name->val;
+                                                                 while (*s != '\0') {
+                                                                          *s = toupper(*s);
+                                                                               s++;
+                                                                 }
+                                                        }
+                                               break;
                                        default:
-                                               ZVAL_NULL(param->parameter);
+                                               ZVAL_NULL(parameter);
                                }
                                if (value && caller_frees) {
                                        efree(value);
@@ -660,7 +669,7 @@ static int firebird_stmt_get_attribute(pdo_stmt_t *stmt, long attr, zval *val TS
                        return 0;
                case PDO_ATTR_CURSOR_NAME:
                        if (*S->name) {
-                               ZVAL_STRING(val,S->name,1);
+                               ZVAL_STRING(val, S->name);
                        } else {
                                ZVAL_NULL(val);
                        }