ported from pdo - pgsql, odbc, mysql, firebirt, dblib

diff --git a/ext/pdo_dblib/dblib_driver.c b/ext/pdo_dblib/dblib_driver.c
index 67a3241a66a1a0d2ea1621b1b75ef5d4a51f386d..f329435e237a881d776ad5ea3fee2359570cc6f4 100644 (file)
--- a/ext/pdo_dblib/dblib_driver.c
+++ b/ext/pdo_dblib/dblib_driver.c
@@ -93,7 +93,7 @@ static int dblib_handle_closer(pdo_dbh_t *dbh TSRMLS_DC)
        return 0;
 }
 
-static int dblib_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
+static int dblib_handle_preparer(pdo_dbh_t *dbh, const char *sql, php_int_t sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
 {
        pdo_dblib_db_handle *H = (pdo_dblib_db_handle *)dbh->driver_data;
        pdo_dblib_stmt *S = ecalloc(1, sizeof(*S));
@@ -107,7 +107,7 @@ static int dblib_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len,
        return 1;
 }
 
-static long dblib_handle_doer(pdo_dbh_t *dbh, const char *sql, long sql_len TSRMLS_DC)
+static php_int_t dblib_handle_doer(pdo_dbh_t *dbh, const char *sql, php_int_t sql_len TSRMLS_DC)
 {
        pdo_dblib_db_handle *H = (pdo_dblib_db_handle *)dbh->driver_data;
        RETCODE ret, resret;

diff --git a/ext/pdo_dblib/dblib_stmt.c b/ext/pdo_dblib/dblib_stmt.c
index fd0999f7e41e1b237b0a7c582495882d1979719a..fa071c0e26aaa23908c10f8dbbe17f0c867af8d9 100644 (file)
--- a/ext/pdo_dblib/dblib_stmt.c
+++ b/ext/pdo_dblib/dblib_stmt.c
@@ -171,7 +171,7 @@ static int pdo_dblib_stmt_execute(pdo_stmt_t *stmt TSRMLS_DC)
 }
 
 static int pdo_dblib_stmt_fetch(pdo_stmt_t *stmt,
-       enum pdo_fetch_orientation ori, long offset TSRMLS_DC)
+       enum pdo_fetch_orientation ori, php_int_t offset TSRMLS_DC)
 {
        
        RETCODE ret;
@@ -213,7 +213,7 @@ static int pdo_dblib_stmt_describe(pdo_stmt_t *stmt, int colno TSRMLS_DC)
 }
 
 static int pdo_dblib_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr,
-        unsigned long *len, int *caller_frees TSRMLS_DC)
+        php_uint_t *len, int *caller_frees TSRMLS_DC)
 {
        
        pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
@@ -287,7 +287,7 @@ static int pdo_dblib_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_da
        return 1;
 }
 
-static int pdo_dblib_stmt_get_column_meta(pdo_stmt_t *stmt, long colno, zval *return_value TSRMLS_DC)
+static int pdo_dblib_stmt_get_column_meta(pdo_stmt_t *stmt, php_int_t colno, zval *return_value TSRMLS_DC)
 {
        pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
        pdo_dblib_db_handle *H = S->H;

diff --git a/ext/pdo_firebird/firebird_driver.c b/ext/pdo_firebird/firebird_driver.c
index 309f2067540619b565be07d44234e74677832fe2..fb3979863ba3ad78748272c60f1e58e824e41da9 100644 (file)
--- a/ext/pdo_firebird/firebird_driver.c
+++ b/ext/pdo_firebird/firebird_driver.c
@@ -33,11 +33,11 @@
 #include "php_pdo_firebird.h"
 #include "php_pdo_firebird_int.h"
 
-static int firebird_alloc_prepare_stmt(pdo_dbh_t*, const char*, long, XSQLDA*, isc_stmt_handle*,
+static int firebird_alloc_prepare_stmt(pdo_dbh_t*, const char*, php_int_t, XSQLDA*, isc_stmt_handle*,
        HashTable* TSRMLS_DC);
 
 /* map driver specific error message to PDO error */
-void _firebird_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, char const *file, long line TSRMLS_DC) /* {{{ */
+void _firebird_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, char const *file, php_int_t line TSRMLS_DC) /* {{{ */
 {
 #if 0
        pdo_firebird_db_handle *H = stmt ? ((pdo_firebird_stmt *)stmt->driver_data)->H 
@@ -132,7 +132,7 @@ static int firebird_handle_closer(pdo_dbh_t *dbh TSRMLS_DC) /* {{{ */
 /* }}} */
 
 /* called by PDO to prepare an SQL query */
-static int firebird_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len, /* {{{ */
+static int firebird_handle_preparer(pdo_dbh_t *dbh, const char *sql, php_int_t sql_len, /* {{{ */
        pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
 {
        pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
@@ -218,7 +218,7 @@ static int firebird_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_le
 /* }}} */
 
 /* called by PDO to execute a statement that doesn't produce a result set */
-static long firebird_handle_doer(pdo_dbh_t *dbh, const char *sql, long sql_len TSRMLS_DC) /* {{{ */
+static php_int_t firebird_handle_doer(pdo_dbh_t *dbh, const char *sql, php_int_t sql_len TSRMLS_DC) /* {{{ */
 {
        pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
        isc_stmt_handle stmt = NULL;
@@ -391,12 +391,12 @@ static int firebird_handle_rollback(pdo_dbh_t *dbh TSRMLS_DC) /* {{{ */
 /* }}} */
 
 /* used by prepare and exec to allocate a statement handle and prepare the SQL */
-static int firebird_alloc_prepare_stmt(pdo_dbh_t *dbh, const char *sql, long sql_len, /* {{{ */
+static int firebird_alloc_prepare_stmt(pdo_dbh_t *dbh, const char *sql, php_int_t sql_len, /* {{{ */
        XSQLDA *out_sqlda, isc_stmt_handle *s, HashTable *named_params TSRMLS_DC)
 {
        pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
        char *c, *new_sql, in_quote, in_param, pname[64], *ppname;
-       long l, pindex = -1;
+       php_int_t l, pindex = -1;
                
        /* Firebird allows SQL statements up to 64k, so bail if it doesn't fit */
        if (sql_len > 65536) {
@@ -470,7 +470,7 @@ static int firebird_alloc_prepare_stmt(pdo_dbh_t *dbh, const char *sql, long sql
 /* }}} */
        
 /* called by PDO to set a driver-specific dbh attribute */
-static int firebird_handle_set_attribute(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC) /* {{{ */
+static int firebird_handle_set_attribute(pdo_dbh_t *dbh, php_int_t attr, zval *val TSRMLS_DC) /* {{{ */
 {
        pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
 
@@ -545,7 +545,7 @@ static void firebird_info_cb(void *arg, char const *s) /* {{{ */
 /* }}} */
 
 /* called by PDO to get a driver-specific dbh attribute */
-static int firebird_handle_get_attribute(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC) /* {{{ */
+static int firebird_handle_get_attribute(pdo_dbh_t *dbh, php_int_t attr, zval *val TSRMLS_DC) /* {{{ */
 {
        pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
 
@@ -606,7 +606,7 @@ static int pdo_firebird_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval
        pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
        const ISC_STATUS *s = H->isc_status;
        char buf[400];
-       long i = 0, l, sqlcode = isc_sqlcode(s);
+       php_int_t i = 0, l, sqlcode = isc_sqlcode(s);
 
        if (sqlcode) {
                add_next_index_int(info, sqlcode);

diff --git a/ext/pdo_firebird/firebird_statement.c b/ext/pdo_firebird/firebird_statement.c
index 2fd60417b6108facff380fd3ccc57c1ed7173b44..bf6431c09e24569dd73ced704bef8541a8fd60fa 100644 (file)
--- a/ext/pdo_firebird/firebird_statement.c
+++ b/ext/pdo_firebird/firebird_statement.c
@@ -88,7 +88,7 @@ static int firebird_stmt_execute(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
 {
        pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
        pdo_firebird_db_handle *H = S->H;
-       unsigned long affected_rows = 0;
+       php_uint_t affected_rows = 0;
        static char info_count[] = {isc_info_sql_records};
        char result[64];
 
@@ -153,7 +153,7 @@ static int firebird_stmt_execute(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
 
 /* called by PDO to fetch the next row from a statement */
 static int firebird_stmt_fetch(pdo_stmt_t *stmt, /* {{{ */
-       enum pdo_fetch_orientation ori, long offset TSRMLS_DC)
+       enum pdo_fetch_orientation ori, php_int_t offset TSRMLS_DC)
 {
        pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
        pdo_firebird_db_handle *H = S->H;
@@ -219,7 +219,7 @@ static int firebird_stmt_describe(pdo_stmt_t *stmt, int colno TSRMLS_DC) /* {{{
 
 /* fetch a blob into a fetch buffer */
 static int firebird_fetch_blob(pdo_stmt_t *stmt, int colno, char **ptr, /* {{{ */
-       unsigned long *len, ISC_QUAD *blob_id TSRMLS_DC)
+       php_uint_t *len, ISC_QUAD *blob_id TSRMLS_DC)
 {
        pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
        pdo_firebird_db_handle *H = S->H;
@@ -263,7 +263,7 @@ static int firebird_fetch_blob(pdo_stmt_t *stmt, int colno, char **ptr, /* {{{ *
        /* we've found the blob's length, now fetch! */
        
        if (*len) {
-               unsigned long cur_len;
+               php_uint_t cur_len;
                unsigned short seg_len;
                ISC_STATUS stat;
 
@@ -296,7 +296,7 @@ fetch_blob_end:
 /* }}} */
 
 static int firebird_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr,  /* {{{ */
-       unsigned long *len, int *caller_frees TSRMLS_DC)
+       php_uint_t *len, int *caller_frees TSRMLS_DC)
 {
        pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
        XSQLVAR const *var = &S->out_sqlda.sqlvar[colno];
@@ -413,7 +413,7 @@ static int firebird_bind_blob(pdo_stmt_t *stmt, ISC_QUAD *blob_id, zval *param T
        pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
        pdo_firebird_db_handle *H = S->H;
        isc_blob_handle h = NULL;
-       unsigned long put_cnt = 0, rem_cnt;
+       php_uint_t put_cnt = 0, rem_cnt;
        unsigned short chunk_size;
        int result = 1;
        
@@ -495,7 +495,7 @@ static int firebird_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_dat
        
        switch (event_type) {
                char *value;
-               unsigned long value_len;
+               php_uint_t value_len;
                int caller_frees;
                zval *parameter;
                        
@@ -551,9 +551,9 @@ static int firebird_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_dat
                                
                                case IS_INT:
                                        /* keep the allow-NULL flag */
-                                       var->sqltype = (sizeof(long) == 8 ? SQL_INT64 : SQL_LONG) | (var->sqltype & 1);
+                                       var->sqltype = (sizeof(php_int_t) == 8 ? SQL_INT64 : SQL_LONG) | (var->sqltype & 1);
                                        var->sqldata = (void*)&Z_IVAL_P(parameter);
-                                       var->sqllen = sizeof(long);
+                                       var->sqllen = sizeof(php_int_t);
                                        break;
                                case IS_DOUBLE:
                                        /* keep the allow-NULL flag */
@@ -626,7 +626,7 @@ static int firebird_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_dat
                                                }
                                        case PDO_PARAM_INT:
                                                if (value) {
-                                                       ZVAL_INT(parameter, *(long*)value);
+                                                       ZVAL_INT(parameter, *(php_int_t*)value);
                                                        break;
                                                }
                                        case PDO_PARAM_EVT_NORMALIZE:
@@ -654,7 +654,7 @@ static int firebird_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_dat
 }
 /* }}} */
 
-static int firebird_stmt_set_attribute(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC) /* {{{ */
+static int firebird_stmt_set_attribute(pdo_stmt_t *stmt, php_int_t attr, zval *val TSRMLS_DC) /* {{{ */
 {
        pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
        
@@ -675,7 +675,7 @@ static int firebird_stmt_set_attribute(pdo_stmt_t *stmt, long attr, zval *val TS
 }
 /* }}} */
 
-static int firebird_stmt_get_attribute(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC) /* {{{ */
+static int firebird_stmt_get_attribute(pdo_stmt_t *stmt, php_int_t attr, zval *val TSRMLS_DC) /* {{{ */
 {
        pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
        

diff --git a/ext/pdo_firebird/pdo_firebird.c b/ext/pdo_firebird/pdo_firebird.c
index 675e6dc7a9e05ce8491508a7ee8d4bbeae233436..e81b7c553f2c6695a82ffd5634a2e080a9018362 100644 (file)
--- a/ext/pdo_firebird/pdo_firebird.c
+++ b/ext/pdo_firebird/pdo_firebird.c
@@ -62,9 +62,9 @@ ZEND_GET_MODULE(pdo_firebird)
 
 PHP_MINIT_FUNCTION(pdo_firebird) /* {{{ */
 {
-       REGISTER_PDO_CLASS_CONST_INT("FB_ATTR_DATE_FORMAT", (long) PDO_FB_ATTR_DATE_FORMAT);
-       REGISTER_PDO_CLASS_CONST_INT("FB_ATTR_TIME_FORMAT", (long) PDO_FB_ATTR_TIME_FORMAT);
-       REGISTER_PDO_CLASS_CONST_INT("FB_ATTR_TIMESTAMP_FORMAT", (long) PDO_FB_ATTR_TIMESTAMP_FORMAT);
+       REGISTER_PDO_CLASS_CONST_INT("FB_ATTR_DATE_FORMAT", (php_int_t) PDO_FB_ATTR_DATE_FORMAT);
+       REGISTER_PDO_CLASS_CONST_INT("FB_ATTR_TIME_FORMAT", (php_int_t) PDO_FB_ATTR_TIME_FORMAT);
+       REGISTER_PDO_CLASS_CONST_INT("FB_ATTR_TIMESTAMP_FORMAT", (php_int_t) PDO_FB_ATTR_TIMESTAMP_FORMAT);
 
        php_pdo_register_driver(&pdo_firebird_driver);
 

diff --git a/ext/pdo_firebird/php_pdo_firebird_int.h b/ext/pdo_firebird/php_pdo_firebird_int.h
index 15004b8d33352356ac10e7792bfc11fedbc39e5b..831fa5972662e1c6c8739036656e34f517d175cc 100644 (file)
--- a/ext/pdo_firebird/php_pdo_firebird_int.h
+++ b/ext/pdo_firebird/php_pdo_firebird_int.h
@@ -35,7 +35,7 @@
 
 #define SHORT_MAX (1 << (8*sizeof(short)-1))
 
-#if SIZEOF_LONG == 8
+#if SIZEOF_ZEND_INT == 8 && !defined(PHP_WIN32)
 # define LL_MASK "l"
 # define LL_LIT(lit) lit ## L
 #else
@@ -128,7 +128,7 @@ extern pdo_driver_t pdo_firebird_driver;
 
 extern struct pdo_stmt_methods firebird_stmt_methods;
 
-void _firebird_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, char const *file, long line TSRMLS_DC);
+void _firebird_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, char const *file, php_int_t line TSRMLS_DC);
 
 enum {
        PDO_FB_ATTR_DATE_FORMAT = PDO_ATTR_DRIVER_SPECIFIC,

diff --git a/ext/pdo_mysql/mysql_driver.c b/ext/pdo_mysql/mysql_driver.c
index 1ba46730ca883b330ca9167334c7a1b89462c6d5..8dd981f42efcad7a7c3052243585d20bd4ba553b 100644 (file)
--- a/ext/pdo_mysql/mysql_driver.c
+++ b/ext/pdo_mysql/mysql_driver.c
@@ -161,7 +161,7 @@ static int mysql_handle_closer(pdo_dbh_t *dbh TSRMLS_DC)
 /* }}} */
 
 /* {{{ mysql_handle_preparer */
-static int mysql_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
+static int mysql_handle_preparer(pdo_dbh_t *dbh, const char *sql, php_int_t sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
 {
        pdo_mysql_db_handle *H = (pdo_mysql_db_handle *)dbh->driver_data;
        pdo_mysql_stmt *S = ecalloc(1, sizeof(pdo_mysql_stmt));
@@ -235,7 +235,7 @@ static int mysql_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len,
 #else
                S->params = ecalloc(S->num_params, sizeof(MYSQL_BIND));
                S->in_null = ecalloc(S->num_params, sizeof(my_bool));
-               S->in_length = ecalloc(S->num_params, sizeof(unsigned long));
+               S->in_length = ecalloc(S->num_params, sizeof(php_uint_t));
 #endif
        }
        dbh->alloc_own_columns = 1;
@@ -253,7 +253,7 @@ end:
 /* }}} */
 
 /* {{{ mysql_handle_doer */
-static long mysql_handle_doer(pdo_dbh_t *dbh, const char *sql, long sql_len TSRMLS_DC)
+static php_int_t mysql_handle_doer(pdo_dbh_t *dbh, const char *sql, php_int_t sql_len TSRMLS_DC)
 {
        pdo_mysql_db_handle *H = (pdo_mysql_db_handle *)dbh->driver_data;
        PDO_DBG_ENTER("mysql_handle_doer");
@@ -368,7 +368,7 @@ static inline int mysql_handle_autocommit(pdo_dbh_t *dbh TSRMLS_DC)
 /* }}} */
 
 /* {{{ pdo_mysql_set_attribute */
-static int pdo_mysql_set_attribute(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC)
+static int pdo_mysql_set_attribute(pdo_dbh_t *dbh, php_int_t attr, zval *val TSRMLS_DC)
 {
        PDO_DBG_ENTER("pdo_mysql_set_attribute");
        PDO_DBG_INF_FMT("dbh=%p", dbh);
@@ -419,7 +419,7 @@ static int pdo_mysql_set_attribute(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_D
 /* }}} */
 
 /* {{{ pdo_mysql_get_attribute */
-static int pdo_mysql_get_attribute(pdo_dbh_t *dbh, long attr, zval *return_value TSRMLS_DC)
+static int pdo_mysql_get_attribute(pdo_dbh_t *dbh, php_int_t attr, zval *return_value TSRMLS_DC)
 {
        pdo_mysql_db_handle *H = (pdo_mysql_db_handle *)dbh->driver_data;
 
@@ -596,13 +596,13 @@ static int pdo_mysql_handle_factory(pdo_dbh_t *dbh, zval *driver_options TSRMLS_
 
        /* handle MySQL options */
        if (driver_options) {
-               long connect_timeout = pdo_attr_ival(driver_options, PDO_ATTR_TIMEOUT, 30 TSRMLS_CC);
-               long local_infile = pdo_attr_ival(driver_options, PDO_MYSQL_ATTR_LOCAL_INFILE, 0 TSRMLS_CC);
+               php_int_t connect_timeout = pdo_attr_ival(driver_options, PDO_ATTR_TIMEOUT, 30 TSRMLS_CC);
+               php_int_t local_infile = pdo_attr_ival(driver_options, PDO_MYSQL_ATTR_LOCAL_INFILE, 0 TSRMLS_CC);
                char *init_cmd = NULL;
 #ifndef PDO_USE_MYSQLND
                char *default_file = NULL, *default_group = NULL;
 #endif
-               long compress = 0;
+               php_int_t compress = 0;
                char *ssl_key = NULL, *ssl_cert = NULL, *ssl_ca = NULL, *ssl_capath = NULL, *ssl_cipher = NULL;
                H->buffered = pdo_attr_ival(driver_options, PDO_MYSQL_ATTR_USE_BUFFERED_QUERY, 1 TSRMLS_CC);
 
@@ -648,7 +648,7 @@ static int pdo_mysql_handle_factory(pdo_dbh_t *dbh, zval *driver_options TSRMLS_
                 * mysqlnd doesn't support reconnect, thus we don't have "|| defined(PDO_USE_MYSQLND)"
                */
                {
-                       long reconnect = 1;
+                       php_int_t reconnect = 1;
                        mysql_options(H->server, MYSQL_OPT_RECONNECT, (const char*)&reconnect);
                }
 #endif

diff --git a/ext/pdo_mysql/mysql_statement.c b/ext/pdo_mysql/mysql_statement.c
index 9e0a76366360ae60a254e3ed8c65dac3c4dda5b0..17a63454325378054cddabf0b7afb52a40e25d2e 100644 (file)
--- a/ext/pdo_mysql/mysql_statement.c
+++ b/ext/pdo_mysql/mysql_statement.c
@@ -116,10 +116,10 @@ static int pdo_mysql_stmt_dtor(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
 
 static void pdo_mysql_stmt_set_row_count(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
 {
-       long row_count;
+       php_int_t row_count;
        pdo_mysql_stmt *S = stmt->driver_data;
-       row_count = (long) mysql_stmt_affected_rows(S->stmt);
-       if (row_count != (long)-1) {
+       row_count = (php_int_t) mysql_stmt_affected_rows(S->stmt);
+       if (row_count != (php_int_t)-1) {
                stmt->row_count = row_count;
        }
 }
@@ -146,12 +146,12 @@ static int pdo_mysql_fill_stmt_from_result(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
                        PDO_DBG_RETURN(0);
                }
 
-               stmt->row_count = (long) mysql_num_rows(S->result);
+               stmt->row_count = (php_int_t) mysql_num_rows(S->result);
                stmt->column_count = (int) mysql_num_fields(S->result);
                S->fields = mysql_fetch_fields(S->result);
        } else {
                /* this was a DML or DDL query (INSERT, UPDATE, DELETE, ... */
-               stmt->row_count = (long) row_count;
+               stmt->row_count = (php_int_t) row_count;
        }
 
        PDO_DBG_RETURN(1);
@@ -200,7 +200,7 @@ static int pdo_mysql_stmt_execute_prepared_libmysql(pdo_stmt_t *stmt TSRMLS_DC)
                        stmt->column_count = (int)mysql_num_fields(S->result);
                        S->bound_result = ecalloc(stmt->column_count, sizeof(MYSQL_BIND));
                        S->out_null = ecalloc(stmt->column_count, sizeof(my_bool));
-                       S->out_length = ecalloc(stmt->column_count, sizeof(unsigned long));
+                       S->out_length = ecalloc(stmt->column_count, sizeof(php_uint_t));
 
                        /* summon memory to hold the row */
                        for (i = 0; i < stmt->column_count; i++) {
@@ -343,7 +343,7 @@ static int pdo_mysql_stmt_next_rowset(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
        pdo_mysql_stmt *S = (pdo_mysql_stmt*)stmt->driver_data;
        pdo_mysql_db_handle *H = S->H;
 #if PDO_USE_MYSQLND
-       long row_count;
+       php_int_t row_count;
 #endif
        PDO_DBG_ENTER("pdo_mysql_stmt_next_rowset");
        PDO_DBG_INF_FMT("stmt=%p", S->stmt);
@@ -393,8 +393,8 @@ static int pdo_mysql_stmt_next_rowset(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
                                }
                        }
                }
-               row_count = (long) mysql_stmt_affected_rows(S->stmt);
-               if (row_count != (long)-1) {
+               row_count = (php_int_t) mysql_stmt_affected_rows(S->stmt);
+               if (row_count != (php_int_t)-1) {
                        stmt->row_count = row_count;
                }
                PDO_DBG_RETURN(1);
@@ -551,9 +551,9 @@ static int pdo_mysql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_da
                                                mysqlnd_stmt_bind_one_param(S->stmt, param->paramno, parameter, MYSQL_TYPE_VAR_STRING);
                                                break;
                                        case IS_INT:
-#if SIZEOF_LONG==8
+#if SIZEOF_ZEND_INT==8
                                                mysqlnd_stmt_bind_one_param(S->stmt, param->paramno, parameter, MYSQL_TYPE_LONGLONG);
-#elif SIZEOF_LONG==4
+#elif SIZEOF_ZEND_INT==4
                                                mysqlnd_stmt_bind_one_param(S->stmt, param->paramno, parameter, MYSQL_TYPE_LONG);
 #endif /* SIZEOF_LONG */
                                                break;
@@ -608,7 +608,7 @@ static int pdo_mysql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_da
 }
 /* }}} */
 
-static int pdo_mysql_stmt_fetch(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori, long offset TSRMLS_DC) /* {{{ */
+static int pdo_mysql_stmt_fetch(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori, php_int_t offset TSRMLS_DC) /* {{{ */
 {
        pdo_mysql_stmt *S = (pdo_mysql_stmt*)stmt->driver_data;
 #if PDO_USE_MYSQLND
@@ -722,7 +722,7 @@ static int pdo_mysql_stmt_describe(pdo_stmt_t *stmt, int colno TSRMLS_DC) /* {{{
 }
 /* }}} */
 
-static int pdo_mysql_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, unsigned long *len, int *caller_frees TSRMLS_DC) /* {{{ */
+static int pdo_mysql_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, php_uint_t *len, int *caller_frees TSRMLS_DC) /* {{{ */
 {
        pdo_mysql_stmt *S = (pdo_mysql_stmt*)stmt->driver_data;
 
@@ -823,7 +823,7 @@ static char *type_to_name_native(int type) /* {{{ */
 #undef PDO_MYSQL_NATIVE_TYPE_NAME
 } /* }}} */
 
-static int pdo_mysql_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_value TSRMLS_DC) /* {{{ */
+static int pdo_mysql_stmt_col_meta(pdo_stmt_t *stmt, php_int_t colno, zval *return_value TSRMLS_DC) /* {{{ */
 {
        pdo_mysql_stmt *S = (pdo_mysql_stmt*)stmt->driver_data;
        const MYSQL_FIELD *F;

diff --git a/ext/pdo_mysql/pdo_mysql.c b/ext/pdo_mysql/pdo_mysql.c
index f77ac7deb8f2618ba07e4112ce0f07914f6cedcd..f57e06ca370dad885735171f1f464b8c4bb1f4a2 100644 (file)
--- a/ext/pdo_mysql/pdo_mysql.c
+++ b/ext/pdo_mysql/pdo_mysql.c
@@ -106,25 +106,25 @@ static PHP_MINIT_FUNCTION(pdo_mysql)
 {
        REGISTER_INI_ENTRIES();
 
-       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_USE_BUFFERED_QUERY", (long)PDO_MYSQL_ATTR_USE_BUFFERED_QUERY);
-       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_LOCAL_INFILE", (long)PDO_MYSQL_ATTR_LOCAL_INFILE);     
-       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_INIT_COMMAND", (long)PDO_MYSQL_ATTR_INIT_COMMAND);
+       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_USE_BUFFERED_QUERY", (php_int_t)PDO_MYSQL_ATTR_USE_BUFFERED_QUERY);
+       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_LOCAL_INFILE", (php_int_t)PDO_MYSQL_ATTR_LOCAL_INFILE);        
+       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_INIT_COMMAND", (php_int_t)PDO_MYSQL_ATTR_INIT_COMMAND);
 #ifndef PDO_USE_MYSQLND
-       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_MAX_BUFFER_SIZE", (long)PDO_MYSQL_ATTR_MAX_BUFFER_SIZE);
-       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_READ_DEFAULT_FILE", (long)PDO_MYSQL_ATTR_READ_DEFAULT_FILE);
-       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_READ_DEFAULT_GROUP", (long)PDO_MYSQL_ATTR_READ_DEFAULT_GROUP);
+       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_MAX_BUFFER_SIZE", (php_int_t)PDO_MYSQL_ATTR_MAX_BUFFER_SIZE);
+       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_READ_DEFAULT_FILE", (php_int_t)PDO_MYSQL_ATTR_READ_DEFAULT_FILE);
+       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_READ_DEFAULT_GROUP", (php_int_t)PDO_MYSQL_ATTR_READ_DEFAULT_GROUP);
 #endif
-       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_COMPRESS", (long)PDO_MYSQL_ATTR_COMPRESS);
-       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_DIRECT_QUERY", (long)PDO_MYSQL_ATTR_DIRECT_QUERY);
-       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_FOUND_ROWS", (long)PDO_MYSQL_ATTR_FOUND_ROWS);
-       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_IGNORE_SPACE", (long)PDO_MYSQL_ATTR_IGNORE_SPACE);
-       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_SSL_KEY", (long)PDO_MYSQL_ATTR_SSL_KEY);
-       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_SSL_CERT", (long)PDO_MYSQL_ATTR_SSL_CERT);
-       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_SSL_CA", (long)PDO_MYSQL_ATTR_SSL_CA);
-       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_SSL_CAPATH", (long)PDO_MYSQL_ATTR_SSL_CAPATH);
-       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_SSL_CIPHER", (long)PDO_MYSQL_ATTR_SSL_CIPHER);
+       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_COMPRESS", (php_int_t)PDO_MYSQL_ATTR_COMPRESS);
+       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_DIRECT_QUERY", (php_int_t)PDO_MYSQL_ATTR_DIRECT_QUERY);
+       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_FOUND_ROWS", (php_int_t)PDO_MYSQL_ATTR_FOUND_ROWS);
+       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_IGNORE_SPACE", (php_int_t)PDO_MYSQL_ATTR_IGNORE_SPACE);
+       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_SSL_KEY", (php_int_t)PDO_MYSQL_ATTR_SSL_KEY);
+       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_SSL_CERT", (php_int_t)PDO_MYSQL_ATTR_SSL_CERT);
+       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_SSL_CA", (php_int_t)PDO_MYSQL_ATTR_SSL_CA);
+       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_SSL_CAPATH", (php_int_t)PDO_MYSQL_ATTR_SSL_CAPATH);
+       REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_SSL_CIPHER", (php_int_t)PDO_MYSQL_ATTR_SSL_CIPHER);
 #if MYSQL_VERSION_ID > 50605 || defined(PDO_USE_MYSQLND)
-        REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_SERVER_PUBLIC_KEY", (long)PDO_MYSQL_ATTR_SERVER_PUBLIC_KEY);
+        REGISTER_PDO_CLASS_CONST_INT("MYSQL_ATTR_SERVER_PUBLIC_KEY", (php_int_t)PDO_MYSQL_ATTR_SERVER_PUBLIC_KEY);
 #endif
 
 

diff --git a/ext/pdo_mysql/php_pdo_mysql_int.h b/ext/pdo_mysql/php_pdo_mysql_int.h
index 4455dcbeb6ea916f912597fc65eff874c6aa7c59..e6fc079466b76f67221312460aa048d763ad46f9 100644 (file)
--- a/ext/pdo_mysql/php_pdo_mysql_int.h
+++ b/ext/pdo_mysql/php_pdo_mysql_int.h
@@ -122,9 +122,9 @@ typedef struct {
        const MYSQL_FIELD               *fields;
        MYSQL_ROW                               current_data;
 #if PDO_USE_MYSQLND
-       unsigned long                   *current_lengths;
+       php_uint_t              *current_lengths;
 #else
-       long                                    *current_lengths;
+       php_int_t               *current_lengths;
 #endif
        pdo_mysql_error_info    einfo;
 #if PDO_USE_MYSQLND
@@ -136,11 +136,11 @@ typedef struct {
        PDO_MYSQL_PARAM_BIND    *params;
 #ifndef PDO_USE_MYSQLND
        my_bool                                 *in_null;
-       unsigned long                   *in_length;
+       php_uint_t                      *in_length;
 #endif
        PDO_MYSQL_PARAM_BIND    *bound_result;
        my_bool                                 *out_null;
-       unsigned long                   *out_length;
+       php_uint_t                      *out_length;
        unsigned int                    params_given;
        unsigned                                max_length:1;
 } pdo_mysql_stmt;

diff --git a/ext/pdo_odbc/odbc_driver.c b/ext/pdo_odbc/odbc_driver.c
index 14f981375de43e228e9cd425a2b617414610c9ed..3a7bf0a37bb8eb46f25bcdbe27c6c31e33406602 100644 (file)
--- a/ext/pdo_odbc/odbc_driver.c
+++ b/ext/pdo_odbc/odbc_driver.c
@@ -142,7 +142,7 @@ static int odbc_handle_closer(pdo_dbh_t *dbh TSRMLS_DC)
        return 0;
 }
 
-static int odbc_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
+static int odbc_handle_preparer(pdo_dbh_t *dbh, const char *sql, php_int_t sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
 {
        RETCODE rc;
        pdo_odbc_db_handle *H = (pdo_odbc_db_handle *)dbh->driver_data;
@@ -220,7 +220,7 @@ static int odbc_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len, p
        return 1;
 }
 
-static long odbc_handle_doer(pdo_dbh_t *dbh, const char *sql, long sql_len TSRMLS_DC)
+static php_int_t odbc_handle_doer(pdo_dbh_t *dbh, const char *sql, php_int_t sql_len TSRMLS_DC)
 {
        pdo_odbc_db_handle *H = (pdo_odbc_db_handle *)dbh->driver_data;
        RETCODE rc;
@@ -336,7 +336,7 @@ static int odbc_handle_rollback(pdo_dbh_t *dbh TSRMLS_DC)
        return 1;
 }
 
-static int odbc_handle_set_attr(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC)
+static int odbc_handle_set_attr(pdo_dbh_t *dbh, php_int_t attr, zval *val TSRMLS_DC)
 {
        pdo_odbc_db_handle *H = (pdo_odbc_db_handle *)dbh->driver_data;
        switch (attr) {
@@ -351,7 +351,7 @@ static int odbc_handle_set_attr(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC)
        }
 }
 
-static int odbc_handle_get_attr(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC)
+static int odbc_handle_get_attr(pdo_dbh_t *dbh, php_int_t attr, zval *val TSRMLS_DC)
 {
        pdo_odbc_db_handle *H = (pdo_odbc_db_handle *)dbh->driver_data;
        switch (attr) {

diff --git a/ext/pdo_odbc/odbc_stmt.c b/ext/pdo_odbc/odbc_stmt.c
index 20f725e5b3276d79262fde5eeaef5b13d2d69f4f..7e2b958a53e6d9b2ba372bc2b313ff30b9ece08c 100644 (file)
--- a/ext/pdo_odbc/odbc_stmt.c
+++ b/ext/pdo_odbc/odbc_stmt.c
@@ -58,7 +58,7 @@ static int pdo_odbc_sqltype_is_unicode(pdo_odbc_stmt *S, SWORD sqltype)
 }
 
 static int pdo_odbc_utf82ucs2(pdo_stmt_t *stmt, int is_unicode, const char *buf, 
-       unsigned long buflen, unsigned long *outlen)
+       php_uint_t buflen, php_uint_t *outlen)
 {
 #ifdef PHP_WIN32
        if (is_unicode && buflen) {
@@ -93,7 +93,7 @@ static int pdo_odbc_utf82ucs2(pdo_stmt_t *stmt, int is_unicode, const char *buf,
 }
 
 static int pdo_odbc_ucs22utf8(pdo_stmt_t *stmt, int is_unicode, const char *buf, 
-       unsigned long buflen, unsigned long *outlen)
+       php_uint_t buflen, php_uint_t *outlen)
 {
 #ifdef PHP_WIN32
        if (is_unicode && buflen) {
@@ -190,7 +190,7 @@ static int odbc_stmt_execute(pdo_stmt_t *stmt TSRMLS_DC)
                        }
                        if (Z_TYPE_P(parameter) != IS_RESOURCE) {
                                /* they passed in a string */
-                               unsigned long ulen;
+                               php_uint_t ulen;
                                convert_to_string(parameter);
 
                                switch (pdo_odbc_utf82ucs2(stmt, P->is_unicode, 
@@ -458,7 +458,7 @@ static int odbc_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *p
                                } else {
                                        convert_to_string(parameter);
                                        if (P->outbuf) {
-                                               unsigned long ulen;
+                                               php_uint_t ulen;
                                                switch (pdo_odbc_utf82ucs2(stmt, P->is_unicode,
                                                                Z_STRVAL_P(parameter),
                                                                Z_STRSIZE_P(parameter),
@@ -483,9 +483,9 @@ static int odbc_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *p
                                P = param->driver_data;
 
                                if (P->outbuf) {
-                                       unsigned long ulen;
+                                       php_uint_t ulen;
                                        char *srcbuf;
-                                       unsigned long srclen = 0;
+                                       php_uint_t srclen = 0;
 
                                        if (Z_ISREF(param->parameter)) {
                                                parameter = Z_REFVAL(param->parameter);
@@ -524,7 +524,7 @@ static int odbc_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *p
 }
 
 static int odbc_stmt_fetch(pdo_stmt_t *stmt,
-       enum pdo_fetch_orientation ori, long offset TSRMLS_DC)
+       enum pdo_fetch_orientation ori, php_int_t offset TSRMLS_DC)
 {
        RETCODE rc;
        SQLSMALLINT odbcori;
@@ -628,15 +628,15 @@ static int odbc_stmt_describe(pdo_stmt_t *stmt, int colno TSRMLS_DC)
        return 1;
 }
 
-static int odbc_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, unsigned long *len, int *caller_frees TSRMLS_DC)
+static int odbc_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, php_uint_t *len, int *caller_frees TSRMLS_DC)
 {
        pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
        pdo_odbc_column *C = &S->cols[colno];
-       unsigned long ulen;
+       php_uint_t ulen;
 
        /* if it is a column containing "long" data, perform late binding now */
        if (C->is_long) {
-               unsigned long used = 0;
+               php_uint_t used = 0;
                char *buf;
                RETCODE rc;
 
@@ -755,7 +755,7 @@ in_data:
        return 1;
 }
 
-static int odbc_stmt_set_param(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC)
+static int odbc_stmt_set_param(pdo_stmt_t *stmt, php_int_t attr, zval *val TSRMLS_DC)
 {
        SQLRETURN rc;
        pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
@@ -782,7 +782,7 @@ static int odbc_stmt_set_param(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC)
        }
 }
 
-static int odbc_stmt_get_attr(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC)
+static int odbc_stmt_get_attr(pdo_stmt_t *stmt, php_int_t attr, zval *val TSRMLS_DC)
 {
        SQLRETURN rc;
        pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;

diff --git a/ext/pdo_odbc/php_pdo_odbc_int.h b/ext/pdo_odbc/php_pdo_odbc_int.h
index 5e42951f865b8892e0c2f7846c61df32d2bc4783..c467ecf83a75b443c1f46ab13dd47fa8d0d5f4c0 100644 (file)
--- a/ext/pdo_odbc/php_pdo_odbc_int.h
+++ b/ext/pdo_odbc/php_pdo_odbc_int.h
@@ -135,7 +135,7 @@ typedef struct {
 
 typedef struct {
        char *data;
-       unsigned long datalen;
+       php_uint_t datalen;
        SQLLEN fetched_len;
        SWORD   coltype;
        char colname[128];
@@ -150,7 +150,7 @@ typedef struct {
        pdo_odbc_db_handle *H;
        pdo_odbc_errinfo einfo;
        char *convbuf;
-       unsigned long convbufsize;
+       php_uint_t convbufsize;
        unsigned going_long:1;
        unsigned assume_utf8:1;
        unsigned _spare:30;

diff --git a/ext/pdo_pgsql/pdo_pgsql.c b/ext/pdo_pgsql/pdo_pgsql.c
index b3fd8ef879ba4c0c3e97412345c43446040646c2..fc7aa827abfc82361618669ac6d2b1405c77abfd 100644 (file)
--- a/ext/pdo_pgsql/pdo_pgsql.c
+++ b/ext/pdo_pgsql/pdo_pgsql.c
@@ -87,11 +87,11 @@ PHP_MINIT_FUNCTION(pdo_pgsql)
 {
        REGISTER_PDO_CLASS_CONST_INT("PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT", PDO_PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT);
        REGISTER_PDO_CLASS_CONST_INT("PGSQL_ATTR_DISABLE_PREPARES", PDO_PGSQL_ATTR_DISABLE_PREPARES);
-       REGISTER_PDO_CLASS_CONST_INT("PGSQL_TRANSACTION_IDLE", (long)PGSQL_TRANSACTION_IDLE);
-       REGISTER_PDO_CLASS_CONST_INT("PGSQL_TRANSACTION_ACTIVE", (long)PGSQL_TRANSACTION_ACTIVE);
-       REGISTER_PDO_CLASS_CONST_INT("PGSQL_TRANSACTION_INTRANS", (long)PGSQL_TRANSACTION_INTRANS);
-       REGISTER_PDO_CLASS_CONST_INT("PGSQL_TRANSACTION_INERROR", (long)PGSQL_TRANSACTION_INERROR);
-       REGISTER_PDO_CLASS_CONST_INT("PGSQL_TRANSACTION_UNKNOWN", (long)PGSQL_TRANSACTION_UNKNOWN);
+       REGISTER_PDO_CLASS_CONST_INT("PGSQL_TRANSACTION_IDLE", (php_int_t)PGSQL_TRANSACTION_IDLE);
+       REGISTER_PDO_CLASS_CONST_INT("PGSQL_TRANSACTION_ACTIVE", (php_int_t)PGSQL_TRANSACTION_ACTIVE);
+       REGISTER_PDO_CLASS_CONST_INT("PGSQL_TRANSACTION_INTRANS", (php_int_t)PGSQL_TRANSACTION_INTRANS);
+       REGISTER_PDO_CLASS_CONST_INT("PGSQL_TRANSACTION_INERROR", (php_int_t)PGSQL_TRANSACTION_INERROR);
+       REGISTER_PDO_CLASS_CONST_INT("PGSQL_TRANSACTION_UNKNOWN", (php_int_t)PGSQL_TRANSACTION_UNKNOWN);
 
        php_pdo_register_driver(&pdo_pgsql_driver);
        return SUCCESS;

diff --git a/ext/pdo_pgsql/pgsql_driver.c b/ext/pdo_pgsql/pgsql_driver.c
index 06016887b975db02bea18a974ddee55e79aa1576..809ee34f7c75f0ed61517d24c5d2cdc05b86719d 100644 (file)
--- a/ext/pdo_pgsql/pgsql_driver.c
+++ b/ext/pdo_pgsql/pgsql_driver.c
@@ -151,8 +151,8 @@ static int pgsql_lob_flush(php_stream *stream TSRMLS_DC)
        return 0;
 }
 
-static int pgsql_lob_seek(php_stream *stream, off_t offset, int whence,
-               off_t *newoffset TSRMLS_DC)
+static int pgsql_lob_seek(php_stream *stream, php_off_t offset, int whence,
+               php_off_t *newoffset TSRMLS_DC)
 {
        struct pdo_pgsql_lob_self *self = (struct pdo_pgsql_lob_self*)stream->abstract;
        int pos = lo_lseek(self->conn, self->lfd, offset, whence);
@@ -214,7 +214,7 @@ static int pgsql_handle_closer(pdo_dbh_t *dbh TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-static int pgsql_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
+static int pgsql_handle_preparer(pdo_dbh_t *dbh, const char *sql, php_int_t sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
 {
        pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
        pdo_pgsql_stmt *S = ecalloc(1, sizeof(pdo_pgsql_stmt));
@@ -287,11 +287,11 @@ static int pgsql_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len,
        return 1;
 }
 
-static long pgsql_handle_doer(pdo_dbh_t *dbh, const char *sql, long sql_len TSRMLS_DC)
+static php_int_t pgsql_handle_doer(pdo_dbh_t *dbh, const char *sql, php_int_t sql_len TSRMLS_DC)
 {
        pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
        PGresult *res;
-       long ret = 1;
+       php_int_t ret = 1;
        ExecStatusType qs;
 
        if (!(res = PQexec(H->server, sql))) {
@@ -306,7 +306,11 @@ static long pgsql_handle_doer(pdo_dbh_t *dbh, const char *sql, long sql_len TSRM
                return -1;
        }
        H->pgoid = PQoidValue(res);
-       ret = (qs == PGRES_COMMAND_OK) ? atol(PQcmdTuples(res)) : 0L;
+       if (qs == PGRES_COMMAND_OK) {
+               ZEND_ATOI(ret, PQcmdTuples(res));
+       } else {
+               ret = Z_I(0);
+       }
        PQclear(res);
 
        return ret;
@@ -350,7 +354,7 @@ static char *pdo_pgsql_last_insert_id(pdo_dbh_t *dbh, const char *name, unsigned
                if (H->pgoid == InvalidOid) {
                        return NULL;
                }
-               *len = spprintf(&id, 0, "%ld", (long) H->pgoid);
+               *len = spprintf(&id, 0, ZEND_INT_FMT, (php_int_t) H->pgoid);
        } else {
                PGresult *res;
                ExecStatusType status;
@@ -373,7 +377,7 @@ static char *pdo_pgsql_last_insert_id(pdo_dbh_t *dbh, const char *name, unsigned
        return id;
 }
 
-static int pdo_pgsql_get_attribute(pdo_dbh_t *dbh, long attr, zval *return_value TSRMLS_DC)
+static int pdo_pgsql_get_attribute(pdo_dbh_t *dbh, php_int_t attr, zval *return_value TSRMLS_DC)
 {
        pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
 
@@ -906,7 +910,7 @@ static PHP_METHOD(PDO, pgsqlLOBCreate)
        lfd = lo_creat(H->server, INV_READ|INV_WRITE);
 
        if (lfd != InvalidOid) {
-               zend_string *buf = strpprintf(0, "%lu", (long) lfd);
+               zend_string *buf = strpprintf(0, ZEND_UINT_FMT, (php_int_t) lfd);
 
                RETURN_STR(buf);
        }
@@ -1011,11 +1015,11 @@ static PHP_METHOD(PDO, pgsqlGetNotify)
 {
        pdo_dbh_t *dbh;
        pdo_pgsql_db_handle *H;
-       long result_type = PDO_FETCH_USE_DEFAULT;
-       long ms_timeout = 0;
+       php_int_t result_type = PDO_FETCH_USE_DEFAULT;
+       php_int_t ms_timeout = 0;
        PGnotify *pgsql_notify;
 
-       if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll",
+       if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ii",
                                &result_type, &ms_timeout)) {
                RETURN_FALSE;
        }
@@ -1107,7 +1111,7 @@ static const zend_function_entry *pdo_pgsql_get_driver_methods(pdo_dbh_t *dbh, i
        }
 }
 
-static int pdo_pgsql_set_attr(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC)
+static int pdo_pgsql_set_attr(pdo_dbh_t *dbh, php_int_t attr, zval *val TSRMLS_DC)
 {
        pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
 
@@ -1154,7 +1158,7 @@ static int pdo_pgsql_handle_factory(pdo_dbh_t *dbh, zval *driver_options TSRMLS_
        int ret = 0;
        char *conn_str, *p, *e;
        char *tmp_pass;
-       long connect_timeout = 30;
+       php_int_t connect_timeout = 30;
 
        H = pecalloc(1, sizeof(pdo_pgsql_db_handle), dbh->is_persistent);
        dbh->driver_data = H;

diff --git a/ext/pdo_pgsql/pgsql_statement.c b/ext/pdo_pgsql/pgsql_statement.c
index b464211f906896ea41006d228c7f341a4a1e361c..eb13548558358bff11e636395ac66050b22813f8 100644 (file)
--- a/ext/pdo_pgsql/pgsql_statement.c
+++ b/ext/pdo_pgsql/pgsql_statement.c
@@ -230,10 +230,10 @@ stmt_retry:
        }
 
        if (status == PGRES_COMMAND_OK) {
-               stmt->row_count = (long)atoi(PQcmdTuples(S->result));
+               ZEND_ATOI(stmt->row_count, PQcmdTuples(S->result));
                H->pgoid = PQoidValue(S->result);
        } else {
-               stmt->row_count = (long)PQntuples(S->result);
+               stmt->row_count = (php_int_t)PQntuples(S->result);
        }
 
        return 1;
@@ -256,14 +256,15 @@ static int pgsql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *
                                /* decode name from $1, $2 into 0, 1 etc. */
                                if (param->name) {
                                        if (param->name->val[0] == '$') {
-                                               param->paramno = atoi(param->name->val + 1);
+                                               ZEND_ATOI(param->paramno, param->name->val + 1);
                                        } else {
                                                /* resolve parameter name to rewritten name */
                                                char *namevar;
 
                                                if (stmt->bound_param_map && (namevar = zend_hash_find_ptr(stmt->bound_param_map,
                                                                param->name)) != NULL) {
-                                                       param->paramno = atoi(namevar + 1) - 1;
+                                                       ZEND_ATOI(param->paramno, namevar + 1);
+                                                       param->paramno--;
                                                } else {
                                                        pdo_raise_impl_error(stmt->dbh, stmt, "HY093", param->name->val TSRMLS_CC);
                                                        return 0;
@@ -390,7 +391,7 @@ static int pgsql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *
 }
 
 static int pgsql_stmt_fetch(pdo_stmt_t *stmt,
-       enum pdo_fetch_orientation ori, long offset TSRMLS_DC)
+       enum pdo_fetch_orientation ori, php_int_t offset TSRMLS_DC)
 {
        pdo_pgsql_stmt *S = (pdo_pgsql_stmt*)stmt->driver_data;
 
@@ -404,8 +405,8 @@ static int pgsql_stmt_fetch(pdo_stmt_t *stmt,
                        case PDO_FETCH_ORI_PRIOR:       spprintf(&ori_str, 0, "BACKWARD"); break;
                        case PDO_FETCH_ORI_FIRST:       spprintf(&ori_str, 0, "FIRST"); break;
                        case PDO_FETCH_ORI_LAST:        spprintf(&ori_str, 0, "LAST"); break;
-                       case PDO_FETCH_ORI_ABS:         spprintf(&ori_str, 0, "ABSOLUTE %ld", offset); break;
-                       case PDO_FETCH_ORI_REL:         spprintf(&ori_str, 0, "RELATIVE %ld", offset); break;
+                       case PDO_FETCH_ORI_ABS:         spprintf(&ori_str, 0, "ABSOLUTE %pd", offset); break;
+                       case PDO_FETCH_ORI_REL:         spprintf(&ori_str, 0, "RELATIVE %pd", offset); break;
                        default:
                                return 0;
                }
@@ -479,7 +480,7 @@ static int pgsql_stmt_describe(pdo_stmt_t *stmt, int colno TSRMLS_DC)
                        break;
 
                case INT8OID:
-                       if (sizeof(long)>=8) {
+                       if (sizeof(php_int_t)>=8) {
                                cols[colno].param_type = PDO_PARAM_INT;
                        } else {
                                cols[colno].param_type = PDO_PARAM_STR;
@@ -497,7 +498,7 @@ static int pgsql_stmt_describe(pdo_stmt_t *stmt, int colno TSRMLS_DC)
        return 1;
 }
 
-static int pgsql_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, unsigned long *len, int *caller_frees  TSRMLS_DC)
+static int pgsql_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, php_uint_t *len, int *caller_frees  TSRMLS_DC)
 {
        pdo_pgsql_stmt *S = (pdo_pgsql_stmt*)stmt->driver_data;
        struct pdo_column_data *cols = stmt->columns;
@@ -518,9 +519,9 @@ static int pgsql_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, unsigned
                switch (cols[colno].param_type) {
 
                        case PDO_PARAM_INT:
-                               S->cols[colno].intval = atol(*ptr);
+                               ZEND_ATOI(S->cols[colno].intval, *ptr);
                                *ptr = (char *) &(S->cols[colno].intval);
-                               *len = sizeof(long);
+                               *len = sizeof(php_int_t);
                                break;
 
                        case PDO_PARAM_BOOL:
@@ -576,7 +577,7 @@ static int pgsql_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, unsigned
        return 1;
 }
 
-static int pgsql_stmt_get_column_meta(pdo_stmt_t *stmt, long colno, zval *return_value TSRMLS_DC)
+static int pgsql_stmt_get_column_meta(pdo_stmt_t *stmt, php_int_t colno, zval *return_value TSRMLS_DC)
 {
        pdo_pgsql_stmt *S = (pdo_pgsql_stmt*)stmt->driver_data;
        PGresult *res;

diff --git a/ext/pdo_pgsql/php_pdo_pgsql_int.h b/ext/pdo_pgsql/php_pdo_pgsql_int.h
index 4d0652049e0aedb185913140be08916e0d877e11..0462daff1fadf10e989b405678f4556b9593ab5a 100644 (file)
--- a/ext/pdo_pgsql/php_pdo_pgsql_int.h
+++ b/ext/pdo_pgsql/php_pdo_pgsql_int.h
@@ -54,7 +54,7 @@ typedef struct {
 typedef struct {
        char         *def;
        Oid          pgsql_type;
-       long         intval;
+       php_int_t         intval;
        zend_bool    boolval;
 } pdo_pgsql_column;