From: Anatol Belski Date: Tue, 19 Aug 2014 16:32:08 +0000 (+0200) Subject: ported pdo and pdo_sqlite X-Git-Tag: POST_64BIT_BRANCH_MERGE^2~69 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=92269d25a37cbcfbb82364e9a58f232c880295a8;p=php ported pdo and pdo_sqlite --- diff --git a/ext/pdo/pdo.c b/ext/pdo/pdo.c index 3e10a6d003..440f5a7e0c 100644 --- a/ext/pdo/pdo.c +++ b/ext/pdo/pdo.c @@ -208,7 +208,7 @@ pdo_driver_t *pdo_find_driver(const char *name, int namelen) /* {{{ */ } /* }}} */ -PDO_API int php_pdo_parse_data_source(const char *data_source, unsigned long data_source_len, struct pdo_data_src_parser *parsed, int nparams) /* {{{ */ +PDO_API int php_pdo_parse_data_source(const char *data_source, php_uint_t data_source_len, struct pdo_data_src_parser *parsed, int nparams) /* {{{ */ { int i, j; int valstart = -1; @@ -314,7 +314,7 @@ PDO_API char *php_pdo_int64_to_str(pdo_int64_t i64 TSRMLS_DC) /* {{{ */ char buffer[65]; char outbuf[65] = ""; register char *p; - long long_val; + php_int_t long_val; char *dst = outbuf; if (i64 < 0) { @@ -331,15 +331,15 @@ PDO_API char *php_pdo_int64_to_str(pdo_int64_t i64 TSRMLS_DC) /* {{{ */ p = &buffer[sizeof(buffer)-1]; *p = '\0'; - while ((pdo_uint64_t)i64 > (pdo_uint64_t)LONG_MAX) { + while ((pdo_uint64_t)i64 > (pdo_uint64_t)PHP_INT_MAX) { pdo_uint64_t quo = (pdo_uint64_t)i64 / (unsigned int)10; unsigned int rem = (unsigned int)(i64 - quo*10U); *--p = digit_vec[rem]; i64 = (pdo_int64_t)quo; } - long_val = (long)i64; + long_val = (php_int_t)i64; while (long_val != 0) { - long quo = long_val / 10; + php_int_t quo = long_val / 10; *--p = digit_vec[(unsigned int)(long_val - quo * 10)]; long_val = quo; } diff --git a/ext/pdo/pdo_dbh.c b/ext/pdo/pdo_dbh.c index 096ad4c8aa..576b81762e 100644 --- a/ext/pdo/pdo_dbh.c +++ b/ext/pdo/pdo_dbh.c @@ -36,7 +36,7 @@ #include "zend_object_handlers.h" #include "zend_hash.h" -static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_DC); +static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, php_int_t attr, zval *value TSRMLS_DC); void pdo_raise_impl_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *sqlstate, const char *supp TSRMLS_DC) /* {{{ */ { @@ -103,7 +103,7 @@ PDO_API void pdo_handle_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt TSRMLS_DC) /* {{{ pdo_error_type *pdo_err = &dbh->error_code; const char *msg = "<>"; char *supp = NULL; - long native_code = 0; + php_int_t native_code = 0; zend_string *message = NULL; zval info; @@ -385,7 +385,7 @@ static PHP_METHOD(PDO, dbh_constructor) options: if (options) { zval *attr_value; - ulong long_key; + php_uint_t long_key; zend_string *str_key = NULL; ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(options), long_key, str_key, attr_value) { @@ -675,7 +675,7 @@ static PHP_METHOD(PDO, inTransaction) } /* }}} */ -static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_DC) /* {{{ */ +static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, php_int_t attr, zval *value TSRMLS_DC) /* {{{ */ { #define PDO_INT_PARAM_CHECK \ @@ -835,10 +835,10 @@ fail: static PHP_METHOD(PDO, setAttribute) { pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); - long attr; + php_int_t attr; zval *value; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz", &attr, &value)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "iz", &attr, &value)) { RETURN_FALSE; } @@ -857,9 +857,9 @@ static PHP_METHOD(PDO, setAttribute) static PHP_METHOD(PDO, getAttribute) { pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); - long attr; + php_int_t attr; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &attr)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &attr)) { RETURN_FALSE; } @@ -924,7 +924,7 @@ static PHP_METHOD(PDO, exec) pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); char *statement; int statement_len; - long ret; + php_int_t ret; if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &statement, &statement_len)) { RETURN_FALSE; @@ -1136,11 +1136,11 @@ static PHP_METHOD(PDO, quote) pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis()); char *str; int str_len; - long paramtype = PDO_PARAM_STR; + php_int_t paramtype = PDO_PARAM_STR; char *qstr; int qlen; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &str, &str_len, ¶mtype)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|i", &str, &str_len, ¶mtype)) { RETURN_FALSE; } @@ -1382,99 +1382,100 @@ void pdo_dbh_init(TSRMLS_D) pdo_dbh_object_handlers.get_method = dbh_method_get; pdo_dbh_object_handlers.compare_objects = dbh_compare; - REGISTER_PDO_CLASS_CONST_INT("PARAM_BOOL", (long)PDO_PARAM_BOOL); - REGISTER_PDO_CLASS_CONST_INT("PARAM_NULL", (long)PDO_PARAM_NULL); - REGISTER_PDO_CLASS_CONST_INT("PARAM_INT", (long)PDO_PARAM_INT); - REGISTER_PDO_CLASS_CONST_INT("PARAM_STR", (long)PDO_PARAM_STR); - REGISTER_PDO_CLASS_CONST_INT("PARAM_LOB", (long)PDO_PARAM_LOB); - REGISTER_PDO_CLASS_CONST_INT("PARAM_STMT", (long)PDO_PARAM_STMT); - REGISTER_PDO_CLASS_CONST_INT("PARAM_INPUT_OUTPUT", (long)PDO_PARAM_INPUT_OUTPUT); - - REGISTER_PDO_CLASS_CONST_INT("PARAM_EVT_ALLOC", (long)PDO_PARAM_EVT_ALLOC); - REGISTER_PDO_CLASS_CONST_INT("PARAM_EVT_FREE", (long)PDO_PARAM_EVT_FREE); - REGISTER_PDO_CLASS_CONST_INT("PARAM_EVT_EXEC_PRE", (long)PDO_PARAM_EVT_EXEC_PRE); - REGISTER_PDO_CLASS_CONST_INT("PARAM_EVT_EXEC_POST", (long)PDO_PARAM_EVT_EXEC_POST); - REGISTER_PDO_CLASS_CONST_INT("PARAM_EVT_FETCH_PRE", (long)PDO_PARAM_EVT_FETCH_PRE); - REGISTER_PDO_CLASS_CONST_INT("PARAM_EVT_FETCH_POST", (long)PDO_PARAM_EVT_FETCH_POST); - REGISTER_PDO_CLASS_CONST_INT("PARAM_EVT_NORMALIZE", (long)PDO_PARAM_EVT_NORMALIZE); - - REGISTER_PDO_CLASS_CONST_INT("FETCH_LAZY", (long)PDO_FETCH_LAZY); - REGISTER_PDO_CLASS_CONST_INT("FETCH_ASSOC",(long)PDO_FETCH_ASSOC); - REGISTER_PDO_CLASS_CONST_INT("FETCH_NUM", (long)PDO_FETCH_NUM); - REGISTER_PDO_CLASS_CONST_INT("FETCH_BOTH", (long)PDO_FETCH_BOTH); - REGISTER_PDO_CLASS_CONST_INT("FETCH_OBJ", (long)PDO_FETCH_OBJ); - REGISTER_PDO_CLASS_CONST_INT("FETCH_BOUND",(long)PDO_FETCH_BOUND); - REGISTER_PDO_CLASS_CONST_INT("FETCH_COLUMN",(long)PDO_FETCH_COLUMN); - REGISTER_PDO_CLASS_CONST_INT("FETCH_CLASS",(long)PDO_FETCH_CLASS); - REGISTER_PDO_CLASS_CONST_INT("FETCH_INTO", (long)PDO_FETCH_INTO); - REGISTER_PDO_CLASS_CONST_INT("FETCH_FUNC", (long)PDO_FETCH_FUNC); - REGISTER_PDO_CLASS_CONST_INT("FETCH_GROUP",(long)PDO_FETCH_GROUP); - REGISTER_PDO_CLASS_CONST_INT("FETCH_UNIQUE",(long)PDO_FETCH_UNIQUE); - REGISTER_PDO_CLASS_CONST_INT("FETCH_KEY_PAIR",(long)PDO_FETCH_KEY_PAIR); - REGISTER_PDO_CLASS_CONST_INT("FETCH_CLASSTYPE",(long)PDO_FETCH_CLASSTYPE); + REGISTER_PDO_CLASS_CONST_INT("PARAM_BOOL", (php_int_t)PDO_PARAM_BOOL); + REGISTER_PDO_CLASS_CONST_INT("PARAM_NULL", (php_int_t)PDO_PARAM_NULL); + REGISTER_PDO_CLASS_CONST_INT("PARAM_INT", (php_int_t)PDO_PARAM_INT); + REGISTER_PDO_CLASS_CONST_INT("PARAM_STR", (php_int_t)PDO_PARAM_STR); + REGISTER_PDO_CLASS_CONST_INT("PARAM_LOB", (php_int_t)PDO_PARAM_LOB); + REGISTER_PDO_CLASS_CONST_INT("PARAM_STMT", (php_int_t)PDO_PARAM_STMT); + REGISTER_PDO_CLASS_CONST_INT("PARAM_INPUT_OUTPUT", (php_int_t)PDO_PARAM_INPUT_OUTPUT); + + REGISTER_PDO_CLASS_CONST_INT("PARAM_EVT_ALLOC", (php_int_t)PDO_PARAM_EVT_ALLOC); + REGISTER_PDO_CLASS_CONST_INT("PARAM_EVT_FREE", (php_int_t)PDO_PARAM_EVT_FREE); + REGISTER_PDO_CLASS_CONST_INT("PARAM_EVT_EXEC_PRE", (php_int_t)PDO_PARAM_EVT_EXEC_PRE); + REGISTER_PDO_CLASS_CONST_INT("PARAM_EVT_EXEC_POST", (php_int_t)PDO_PARAM_EVT_EXEC_POST); + REGISTER_PDO_CLASS_CONST_INT("PARAM_EVT_FETCH_PRE", (php_int_t)PDO_PARAM_EVT_FETCH_PRE); + REGISTER_PDO_CLASS_CONST_INT("PARAM_EVT_FETCH_POST", (php_int_t)PDO_PARAM_EVT_FETCH_POST); + REGISTER_PDO_CLASS_CONST_INT("PARAM_EVT_NORMALIZE", (php_int_t)PDO_PARAM_EVT_NORMALIZE); + + REGISTER_PDO_CLASS_CONST_INT("FETCH_LAZY", (php_int_t)PDO_FETCH_LAZY); + REGISTER_PDO_CLASS_CONST_INT("FETCH_ASSOC", (php_int_t)PDO_FETCH_ASSOC); + REGISTER_PDO_CLASS_CONST_INT("FETCH_NUM", (php_int_t)PDO_FETCH_NUM); + REGISTER_PDO_CLASS_CONST_INT("FETCH_BOTH", (php_int_t)PDO_FETCH_BOTH); + REGISTER_PDO_CLASS_CONST_INT("FETCH_OBJ", (php_int_t)PDO_FETCH_OBJ); + REGISTER_PDO_CLASS_CONST_INT("FETCH_BOUND", (php_int_t)PDO_FETCH_BOUND); + REGISTER_PDO_CLASS_CONST_INT("FETCH_COLUMN", (php_int_t)PDO_FETCH_COLUMN); + REGISTER_PDO_CLASS_CONST_INT("FETCH_CLASS", (php_int_t)PDO_FETCH_CLASS); + REGISTER_PDO_CLASS_CONST_INT("FETCH_INTO", (php_int_t)PDO_FETCH_INTO); + REGISTER_PDO_CLASS_CONST_INT("FETCH_FUNC", (php_int_t)PDO_FETCH_FUNC); + REGISTER_PDO_CLASS_CONST_INT("FETCH_GROUP", (php_int_t)PDO_FETCH_GROUP); + REGISTER_PDO_CLASS_CONST_INT("FETCH_UNIQUE", (php_int_t)PDO_FETCH_UNIQUE); + REGISTER_PDO_CLASS_CONST_INT("FETCH_KEY_PAIR", (php_int_t)PDO_FETCH_KEY_PAIR); + REGISTER_PDO_CLASS_CONST_INT("FETCH_CLASSTYPE", (php_int_t)PDO_FETCH_CLASSTYPE); + #if PHP_VERSION_ID >= 50100 - REGISTER_PDO_CLASS_CONST_INT("FETCH_SERIALIZE",(long)PDO_FETCH_SERIALIZE); + REGISTER_PDO_CLASS_CONST_INT("FETCH_SERIALIZE",(php_int_t)PDO_FETCH_SERIALIZE); #endif - REGISTER_PDO_CLASS_CONST_INT("FETCH_PROPS_LATE",(long)PDO_FETCH_PROPS_LATE); - REGISTER_PDO_CLASS_CONST_INT("FETCH_NAMED",(long)PDO_FETCH_NAMED); - - REGISTER_PDO_CLASS_CONST_INT("ATTR_AUTOCOMMIT", (long)PDO_ATTR_AUTOCOMMIT); - REGISTER_PDO_CLASS_CONST_INT("ATTR_PREFETCH", (long)PDO_ATTR_PREFETCH); - REGISTER_PDO_CLASS_CONST_INT("ATTR_TIMEOUT", (long)PDO_ATTR_TIMEOUT); - REGISTER_PDO_CLASS_CONST_INT("ATTR_ERRMODE", (long)PDO_ATTR_ERRMODE); - REGISTER_PDO_CLASS_CONST_INT("ATTR_SERVER_VERSION", (long)PDO_ATTR_SERVER_VERSION); - REGISTER_PDO_CLASS_CONST_INT("ATTR_CLIENT_VERSION", (long)PDO_ATTR_CLIENT_VERSION); - REGISTER_PDO_CLASS_CONST_INT("ATTR_SERVER_INFO", (long)PDO_ATTR_SERVER_INFO); - REGISTER_PDO_CLASS_CONST_INT("ATTR_CONNECTION_STATUS", (long)PDO_ATTR_CONNECTION_STATUS); - REGISTER_PDO_CLASS_CONST_INT("ATTR_CASE", (long)PDO_ATTR_CASE); - REGISTER_PDO_CLASS_CONST_INT("ATTR_CURSOR_NAME", (long)PDO_ATTR_CURSOR_NAME); - REGISTER_PDO_CLASS_CONST_INT("ATTR_CURSOR", (long)PDO_ATTR_CURSOR); - REGISTER_PDO_CLASS_CONST_INT("ATTR_ORACLE_NULLS", (long)PDO_ATTR_ORACLE_NULLS); - REGISTER_PDO_CLASS_CONST_INT("ATTR_PERSISTENT", (long)PDO_ATTR_PERSISTENT); - REGISTER_PDO_CLASS_CONST_INT("ATTR_STATEMENT_CLASS", (long)PDO_ATTR_STATEMENT_CLASS); - REGISTER_PDO_CLASS_CONST_INT("ATTR_FETCH_TABLE_NAMES", (long)PDO_ATTR_FETCH_TABLE_NAMES); - REGISTER_PDO_CLASS_CONST_INT("ATTR_FETCH_CATALOG_NAMES", (long)PDO_ATTR_FETCH_CATALOG_NAMES); - REGISTER_PDO_CLASS_CONST_INT("ATTR_DRIVER_NAME", (long)PDO_ATTR_DRIVER_NAME); - REGISTER_PDO_CLASS_CONST_INT("ATTR_STRINGIFY_FETCHES",(long)PDO_ATTR_STRINGIFY_FETCHES); - REGISTER_PDO_CLASS_CONST_INT("ATTR_MAX_COLUMN_LEN",(long)PDO_ATTR_MAX_COLUMN_LEN); - REGISTER_PDO_CLASS_CONST_INT("ATTR_EMULATE_PREPARES",(long)PDO_ATTR_EMULATE_PREPARES); - REGISTER_PDO_CLASS_CONST_INT("ATTR_DEFAULT_FETCH_MODE",(long)PDO_ATTR_DEFAULT_FETCH_MODE); + REGISTER_PDO_CLASS_CONST_INT("FETCH_PROPS_LATE", (php_int_t)PDO_FETCH_PROPS_LATE); + REGISTER_PDO_CLASS_CONST_INT("FETCH_NAMED", (php_int_t)PDO_FETCH_NAMED); + + REGISTER_PDO_CLASS_CONST_INT("ATTR_AUTOCOMMIT", (php_int_t)PDO_ATTR_AUTOCOMMIT); + REGISTER_PDO_CLASS_CONST_INT("ATTR_PREFETCH", (php_int_t)PDO_ATTR_PREFETCH); + REGISTER_PDO_CLASS_CONST_INT("ATTR_TIMEOUT", (php_int_t)PDO_ATTR_TIMEOUT); + REGISTER_PDO_CLASS_CONST_INT("ATTR_ERRMODE", (php_int_t)PDO_ATTR_ERRMODE); + REGISTER_PDO_CLASS_CONST_INT("ATTR_SERVER_VERSION", (php_int_t)PDO_ATTR_SERVER_VERSION); + REGISTER_PDO_CLASS_CONST_INT("ATTR_CLIENT_VERSION", (php_int_t)PDO_ATTR_CLIENT_VERSION); + REGISTER_PDO_CLASS_CONST_INT("ATTR_SERVER_INFO", (php_int_t)PDO_ATTR_SERVER_INFO); + REGISTER_PDO_CLASS_CONST_INT("ATTR_CONNECTION_STATUS", (php_int_t)PDO_ATTR_CONNECTION_STATUS); + REGISTER_PDO_CLASS_CONST_INT("ATTR_CASE", (php_int_t)PDO_ATTR_CASE); + REGISTER_PDO_CLASS_CONST_INT("ATTR_CURSOR_NAME", (php_int_t)PDO_ATTR_CURSOR_NAME); + REGISTER_PDO_CLASS_CONST_INT("ATTR_CURSOR", (php_int_t)PDO_ATTR_CURSOR); + REGISTER_PDO_CLASS_CONST_INT("ATTR_ORACLE_NULLS", (php_int_t)PDO_ATTR_ORACLE_NULLS); + REGISTER_PDO_CLASS_CONST_INT("ATTR_PERSISTENT", (php_int_t)PDO_ATTR_PERSISTENT); + REGISTER_PDO_CLASS_CONST_INT("ATTR_STATEMENT_CLASS", (php_int_t)PDO_ATTR_STATEMENT_CLASS); + REGISTER_PDO_CLASS_CONST_INT("ATTR_FETCH_TABLE_NAMES", (php_int_t)PDO_ATTR_FETCH_TABLE_NAMES); + REGISTER_PDO_CLASS_CONST_INT("ATTR_FETCH_CATALOG_NAMES", (php_int_t)PDO_ATTR_FETCH_CATALOG_NAMES); + REGISTER_PDO_CLASS_CONST_INT("ATTR_DRIVER_NAME", (php_int_t)PDO_ATTR_DRIVER_NAME); + REGISTER_PDO_CLASS_CONST_INT("ATTR_STRINGIFY_FETCHES", (php_int_t)PDO_ATTR_STRINGIFY_FETCHES); + REGISTER_PDO_CLASS_CONST_INT("ATTR_MAX_COLUMN_LEN", (php_int_t)PDO_ATTR_MAX_COLUMN_LEN); + REGISTER_PDO_CLASS_CONST_INT("ATTR_EMULATE_PREPARES", (php_int_t)PDO_ATTR_EMULATE_PREPARES); + REGISTER_PDO_CLASS_CONST_INT("ATTR_DEFAULT_FETCH_MODE", (php_int_t)PDO_ATTR_DEFAULT_FETCH_MODE); - REGISTER_PDO_CLASS_CONST_INT("ERRMODE_SILENT", (long)PDO_ERRMODE_SILENT); - REGISTER_PDO_CLASS_CONST_INT("ERRMODE_WARNING", (long)PDO_ERRMODE_WARNING); - REGISTER_PDO_CLASS_CONST_INT("ERRMODE_EXCEPTION", (long)PDO_ERRMODE_EXCEPTION); + REGISTER_PDO_CLASS_CONST_INT("ERRMODE_SILENT", (php_int_t)PDO_ERRMODE_SILENT); + REGISTER_PDO_CLASS_CONST_INT("ERRMODE_WARNING", (php_int_t)PDO_ERRMODE_WARNING); + REGISTER_PDO_CLASS_CONST_INT("ERRMODE_EXCEPTION", (php_int_t)PDO_ERRMODE_EXCEPTION); - REGISTER_PDO_CLASS_CONST_INT("CASE_NATURAL", (long)PDO_CASE_NATURAL); - REGISTER_PDO_CLASS_CONST_INT("CASE_LOWER", (long)PDO_CASE_LOWER); - REGISTER_PDO_CLASS_CONST_INT("CASE_UPPER", (long)PDO_CASE_UPPER); + REGISTER_PDO_CLASS_CONST_INT("CASE_NATURAL", (php_int_t)PDO_CASE_NATURAL); + REGISTER_PDO_CLASS_CONST_INT("CASE_LOWER", (php_int_t)PDO_CASE_LOWER); + REGISTER_PDO_CLASS_CONST_INT("CASE_UPPER", (php_int_t)PDO_CASE_UPPER); - REGISTER_PDO_CLASS_CONST_INT("NULL_NATURAL", (long)PDO_NULL_NATURAL); - REGISTER_PDO_CLASS_CONST_INT("NULL_EMPTY_STRING", (long)PDO_NULL_EMPTY_STRING); - REGISTER_PDO_CLASS_CONST_INT("NULL_TO_STRING", (long)PDO_NULL_TO_STRING); + REGISTER_PDO_CLASS_CONST_INT("NULL_NATURAL", (php_int_t)PDO_NULL_NATURAL); + REGISTER_PDO_CLASS_CONST_INT("NULL_EMPTY_STRING", (php_int_t)PDO_NULL_EMPTY_STRING); + REGISTER_PDO_CLASS_CONST_INT("NULL_TO_STRING", (php_int_t)PDO_NULL_TO_STRING); REGISTER_PDO_CLASS_CONST_STRING("ERR_NONE", PDO_ERR_NONE); - REGISTER_PDO_CLASS_CONST_INT("FETCH_ORI_NEXT", (long)PDO_FETCH_ORI_NEXT); - REGISTER_PDO_CLASS_CONST_INT("FETCH_ORI_PRIOR", (long)PDO_FETCH_ORI_PRIOR); - REGISTER_PDO_CLASS_CONST_INT("FETCH_ORI_FIRST", (long)PDO_FETCH_ORI_FIRST); - REGISTER_PDO_CLASS_CONST_INT("FETCH_ORI_LAST", (long)PDO_FETCH_ORI_LAST); - REGISTER_PDO_CLASS_CONST_INT("FETCH_ORI_ABS", (long)PDO_FETCH_ORI_ABS); - REGISTER_PDO_CLASS_CONST_INT("FETCH_ORI_REL", (long)PDO_FETCH_ORI_REL); + REGISTER_PDO_CLASS_CONST_INT("FETCH_ORI_NEXT", (php_int_t)PDO_FETCH_ORI_NEXT); + REGISTER_PDO_CLASS_CONST_INT("FETCH_ORI_PRIOR", (php_int_t)PDO_FETCH_ORI_PRIOR); + REGISTER_PDO_CLASS_CONST_INT("FETCH_ORI_FIRST", (php_int_t)PDO_FETCH_ORI_FIRST); + REGISTER_PDO_CLASS_CONST_INT("FETCH_ORI_LAST", (php_int_t)PDO_FETCH_ORI_LAST); + REGISTER_PDO_CLASS_CONST_INT("FETCH_ORI_ABS", (php_int_t)PDO_FETCH_ORI_ABS); + REGISTER_PDO_CLASS_CONST_INT("FETCH_ORI_REL", (php_int_t)PDO_FETCH_ORI_REL); - REGISTER_PDO_CLASS_CONST_INT("CURSOR_FWDONLY", (long)PDO_CURSOR_FWDONLY); - REGISTER_PDO_CLASS_CONST_INT("CURSOR_SCROLL", (long)PDO_CURSOR_SCROLL); + REGISTER_PDO_CLASS_CONST_INT("CURSOR_FWDONLY", (php_int_t)PDO_CURSOR_FWDONLY); + REGISTER_PDO_CLASS_CONST_INT("CURSOR_SCROLL", (php_int_t)PDO_CURSOR_SCROLL); #if 0 - REGISTER_PDO_CLASS_CONST_INT("ERR_CANT_MAP", (long)PDO_ERR_CANT_MAP); - REGISTER_PDO_CLASS_CONST_INT("ERR_SYNTAX", (long)PDO_ERR_SYNTAX); - REGISTER_PDO_CLASS_CONST_INT("ERR_CONSTRAINT", (long)PDO_ERR_CONSTRAINT); - REGISTER_PDO_CLASS_CONST_INT("ERR_NOT_FOUND", (long)PDO_ERR_NOT_FOUND); - REGISTER_PDO_CLASS_CONST_INT("ERR_ALREADY_EXISTS", (long)PDO_ERR_ALREADY_EXISTS); - REGISTER_PDO_CLASS_CONST_INT("ERR_NOT_IMPLEMENTED", (long)PDO_ERR_NOT_IMPLEMENTED); - REGISTER_PDO_CLASS_CONST_INT("ERR_MISMATCH", (long)PDO_ERR_MISMATCH); - REGISTER_PDO_CLASS_CONST_INT("ERR_TRUNCATED", (long)PDO_ERR_TRUNCATED); - REGISTER_PDO_CLASS_CONST_INT("ERR_DISCONNECTED", (long)PDO_ERR_DISCONNECTED); - REGISTER_PDO_CLASS_CONST_INT("ERR_NO_PERM", (long)PDO_ERR_NO_PERM); + REGISTER_PDO_CLASS_CONST_INT("ERR_CANT_MAP", (php_int_t)PDO_ERR_CANT_MAP); + REGISTER_PDO_CLASS_CONST_INT("ERR_SYNTAX", (php_int_t)PDO_ERR_SYNTAX); + REGISTER_PDO_CLASS_CONST_INT("ERR_CONSTRAINT", (php_int_t)PDO_ERR_CONSTRAINT); + REGISTER_PDO_CLASS_CONST_INT("ERR_NOT_FOUND", (php_int_t)PDO_ERR_NOT_FOUND); + REGISTER_PDO_CLASS_CONST_INT("ERR_ALREADY_EXISTS", (php_int_t)PDO_ERR_ALREADY_EXISTS); + REGISTER_PDO_CLASS_CONST_INT("ERR_NOT_IMPLEMENTED", (php_int_t)PDO_ERR_NOT_IMPLEMENTED); + REGISTER_PDO_CLASS_CONST_INT("ERR_MISMATCH", (php_int_t)PDO_ERR_MISMATCH); + REGISTER_PDO_CLASS_CONST_INT("ERR_TRUNCATED", (php_int_t)PDO_ERR_TRUNCATED); + REGISTER_PDO_CLASS_CONST_INT("ERR_DISCONNECTED", (php_int_t)PDO_ERR_DISCONNECTED); + REGISTER_PDO_CLASS_CONST_INT("ERR_NO_PERM", (php_int_t)PDO_ERR_NO_PERM); #endif } diff --git a/ext/pdo/pdo_stmt.c b/ext/pdo/pdo_stmt.c index 6079e7227f..7d840a2a3f 100644 --- a/ext/pdo/pdo_stmt.c +++ b/ext/pdo/pdo_stmt.c @@ -447,7 +447,7 @@ static PHP_METHOD(PDOStatement, execute) struct pdo_bound_param_data param; zval *tmp; zend_string *key = NULL; - ulong num_index; + php_uint_t num_index; if (stmt->bound_params) { zend_hash_destroy(stmt->bound_params); @@ -544,7 +544,7 @@ static inline void fetch_value(pdo_stmt_t *stmt, zval *dest, int colno, int *typ { struct pdo_column_data *col; char *value = NULL; - unsigned long value_len = 0; + php_size_t value_len = 0; int caller_frees = 0; int type, new_type; @@ -571,8 +571,8 @@ static inline void fetch_value(pdo_stmt_t *stmt, zval *dest, int colno, int *typ break; case PDO_PARAM_INT: - if (value && value_len == sizeof(long)) { - ZVAL_INT(dest, *(long*)value); + if (value && value_len == sizeof(php_int_t)) { + ZVAL_INT(dest, *(php_int_t*)value); break; } ZVAL_NULL(dest); @@ -674,7 +674,7 @@ static inline void fetch_value(pdo_stmt_t *stmt, zval *dest, int colno, int *typ } /* }}} */ -static int do_fetch_common(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori, long offset, int do_bind TSRMLS_DC) /* {{{ */ +static int do_fetch_common(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori, php_int_t offset, int do_bind TSRMLS_DC) /* {{{ */ { if (!stmt->executed) { return 0; @@ -832,7 +832,7 @@ static int do_fetch_opt_finish(pdo_stmt_t *stmt, int free_ctor_agrs TSRMLS_DC) / /* perform a fetch. If do_bind is true, update any bound columns. * If return_value is not null, store values into it according to HOW. */ -static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_fetch_type how, enum pdo_fetch_orientation ori, long offset, zval *return_all TSRMLS_DC) /* {{{ */ +static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_fetch_type how, enum pdo_fetch_orientation ori, php_int_t offset, zval *return_all TSRMLS_DC) /* {{{ */ { int flags, idx, old_arg_count = 0; zend_class_entry *ce = NULL, *old_ce = NULL; @@ -1213,7 +1213,7 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_ } /* }}} */ -static int pdo_stmt_verify_mode(pdo_stmt_t *stmt, long mode, int fetch_all TSRMLS_DC) /* {{{ */ +static int pdo_stmt_verify_mode(pdo_stmt_t *stmt, php_int_t mode, int fetch_all TSRMLS_DC) /* {{{ */ { int flags = mode & PDO_FETCH_FLAGS; @@ -1269,9 +1269,9 @@ static int pdo_stmt_verify_mode(pdo_stmt_t *stmt, long mode, int fetch_all TSRML Fetches the next row and returns it, or false if there are no more rows */ static PHP_METHOD(PDOStatement, fetch) { - long how = PDO_FETCH_USE_DEFAULT; - long ori = PDO_FETCH_ORI_NEXT; - long off = 0; + php_int_t how = PDO_FETCH_USE_DEFAULT; + php_int_t ori = PDO_FETCH_ORI_NEXT; + php_int_t off = 0; PHP_STMT_GET_OBJ; if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lll", &how, @@ -1296,9 +1296,9 @@ static PHP_METHOD(PDOStatement, fetch) Fetches the next row and returns it as an object. */ static PHP_METHOD(PDOStatement, fetchObject) { - long how = PDO_FETCH_CLASS; - long ori = PDO_FETCH_ORI_NEXT; - long off = 0; + php_int_t how = PDO_FETCH_CLASS; + php_int_t ori = PDO_FETCH_ORI_NEXT; + php_int_t off = 0; zend_string *class_name = NULL; zend_class_entry *old_ce; zval old_ctor_args, *ctor_args = NULL; @@ -1361,10 +1361,10 @@ static PHP_METHOD(PDOStatement, fetchObject) Returns a data of the specified column in the result set. */ static PHP_METHOD(PDOStatement, fetchColumn) { - long col_n = 0; + php_int_t col_n = 0; PHP_STMT_GET_OBJ; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &col_n)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &col_n)) { RETURN_FALSE; } @@ -1383,7 +1383,7 @@ static PHP_METHOD(PDOStatement, fetchColumn) Returns an array of all of the results. */ static PHP_METHOD(PDOStatement, fetchAll) { - long how = PDO_FETCH_USE_DEFAULT; + php_int_t how = PDO_FETCH_USE_DEFAULT; zval data, *return_all; zval *arg2; zend_class_entry *old_ce; @@ -1391,7 +1391,7 @@ static PHP_METHOD(PDOStatement, fetchAll) int error = 0, flags, old_arg_count; PHP_STMT_GET_OBJ; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lzz", &how, &arg2, &ctor_args)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|izz", &how, &arg2, &ctor_args)) { RETURN_FALSE; } @@ -1545,15 +1545,15 @@ static PHP_METHOD(PDOStatement, fetchAll) static int register_bound_param(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, int is_param) /* {{{ */ { struct pdo_bound_param_data param = {0}; - long param_type = PDO_PARAM_STR; + php_int_t param_type = PDO_PARAM_STR; zval *parameter; param.paramno = -1; if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, - "lz|llz!", ¶m.paramno, ¶meter, ¶m_type, ¶m.max_value_len, + "iz|iiz!", ¶m.paramno, ¶meter, ¶m_type, ¶m.max_value_len, ¶m.driver_params)) { - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|llz!", ¶m.name, + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|iiz!", ¶m.name, ¶meter, ¶m_type, ¶m.max_value_len, ¶m.driver_params)) { return 0; @@ -1584,15 +1584,15 @@ static int register_bound_param(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, static PHP_METHOD(PDOStatement, bindValue) { struct pdo_bound_param_data param = {0}; - long param_type = PDO_PARAM_STR; + php_int_t param_type = PDO_PARAM_STR; zval *parameter; PHP_STMT_GET_OBJ; param.paramno = -1; if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, - "lz/|l", ¶m.paramno, ¶meter, ¶m_type)) { - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz/|l", ¶m.name, + "iz/|i", ¶m.paramno, ¶meter, ¶m_type)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz/|i", ¶m.name, ¶meter, ¶m_type)) { RETURN_FALSE; } @@ -1703,11 +1703,11 @@ static PHP_METHOD(PDOStatement, errorInfo) Set an attribute */ static PHP_METHOD(PDOStatement, setAttribute) { - long attr; + php_int_t attr; zval *value = NULL; PHP_STMT_GET_OBJ; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz!", &attr, &value)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "iz!", &attr, &value)) { RETURN_FALSE; } @@ -1733,7 +1733,7 @@ fail: /* {{{ proto mixed PDOStatement::getAttribute(long attribute) Get an attribute */ -static int generic_stmt_attr_get(pdo_stmt_t *stmt, zval *return_value, long attr) +static int generic_stmt_attr_get(pdo_stmt_t *stmt, zval *return_value, php_int_t attr) { switch (attr) { case PDO_ATTR_EMULATE_PREPARES: @@ -1745,10 +1745,10 @@ static int generic_stmt_attr_get(pdo_stmt_t *stmt, zval *return_value, long attr static PHP_METHOD(PDOStatement, getAttribute) { - long attr; + php_int_t attr; PHP_STMT_GET_OBJ; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &attr)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &attr)) { RETURN_FALSE; } @@ -1798,11 +1798,11 @@ static PHP_METHOD(PDOStatement, columnCount) Returns meta data for a numbered column */ static PHP_METHOD(PDOStatement, getColumnMeta) { - long colno; + php_int_t colno; struct pdo_column_data *col; PHP_STMT_GET_OBJ; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &colno)) { + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &colno)) { RETURN_FALSE; } if(colno < 0) { @@ -1838,7 +1838,7 @@ static PHP_METHOD(PDOStatement, getColumnMeta) int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, int skip) { - long mode = PDO_FETCH_BOTH; + php_int_t mode = PDO_FETCH_BOTH; int flags = 0, argc = ZEND_NUM_ARGS() - skip; zval *args; zend_class_entry *cep; @@ -2119,7 +2119,7 @@ static PHP_METHOD(PDOStatement, debugDumpParams) stmt->bound_params ? zend_hash_num_elements(stmt->bound_params) : 0); if (stmt->bound_params) { - ulong num; + php_uint_t num; zend_string *key = NULL; ZEND_HASH_FOREACH_KEY_PTR(stmt->bound_params, num, key, param) { if (key) { @@ -2372,7 +2372,7 @@ zend_object *pdo_dbstmt_new(zend_class_entry *ce TSRMLS_DC) struct php_pdo_iterator { zend_object_iterator iter; - ulong key; + php_uint_t key; zval fetch_ahead; }; diff --git a/ext/pdo/php_pdo.h b/ext/pdo/php_pdo.h index bbb75ea63f..2072dd3469 100644 --- a/ext/pdo/php_pdo.h +++ b/ext/pdo/php_pdo.h @@ -49,7 +49,7 @@ PHP_MSHUTDOWN_FUNCTION(pdo); PHP_MINFO_FUNCTION(pdo); ZEND_BEGIN_MODULE_GLOBALS(pdo) - long global_value; + php_int_t global_value; ZEND_END_MODULE_GLOBALS(pdo) #ifdef ZTS @@ -59,12 +59,12 @@ ZEND_END_MODULE_GLOBALS(pdo) #endif #define REGISTER_PDO_CLASS_CONST_INT(const_name, value) \ - zend_declare_class_constant_int(php_pdo_get_dbh_ce(), const_name, sizeof(const_name)-1, (long)value TSRMLS_CC); + zend_declare_class_constant_int(php_pdo_get_dbh_ce(), const_name, sizeof(const_name)-1, (php_int_t)value TSRMLS_CC); #define REGISTER_PDO_CONST_LONG(const_name, value) { \ zend_class_entry **pce; \ if (zend_hash_find(CG(class_table), "pdo", sizeof("pdo"), (void **) &pce) != FAILURE) \ - zend_declare_class_constant_int(*pce, const_name, sizeof(const_name)-1, (long)value TSRMLS_CC); \ + zend_declare_class_constant_int(*pce, const_name, sizeof(const_name)-1, (php_int_t)value TSRMLS_CC); \ } \ #define REGISTER_PDO_CLASS_CONST_STRING(const_name, value) \ diff --git a/ext/pdo/php_pdo_driver.h b/ext/pdo/php_pdo_driver.h index 8eed98952d..b7f7f46250 100644 --- a/ext/pdo/php_pdo_driver.h +++ b/ext/pdo/php_pdo_driver.h @@ -194,7 +194,7 @@ enum pdo_null_handling { }; /* {{{ utils for reading attributes set as driver_options */ -static inline long pdo_attr_ival(zval *options, enum pdo_attribute_type option_name, long defval TSRMLS_DC) +static inline php_int_t pdo_attr_ival(zval *options, enum pdo_attribute_type option_name, php_int_t defval TSRMLS_DC) { zval *v; @@ -220,8 +220,8 @@ static inline char *pdo_attr_strval(zval *options, enum pdo_attribute_type optio * initialized */ typedef struct { const char *driver_name; - unsigned long driver_name_len; - unsigned long api_version; /* needs to be compatible with PDO */ + php_uint_t driver_name_len; + php_uint_t api_version; /* needs to be compatible with PDO */ #define PDO_DRIVER_HEADER(name) \ #name, sizeof(#name)-1, \ @@ -244,10 +244,10 @@ typedef struct { typedef int (*pdo_dbh_close_func)(pdo_dbh_t *dbh TSRMLS_DC); /* prepare a statement and stash driver specific portion into stmt */ -typedef int (*pdo_dbh_prepare_func)(pdo_dbh_t *dbh, const char *sql, long sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC); +typedef int (*pdo_dbh_prepare_func)(pdo_dbh_t *dbh, const char *sql, php_int_t sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC); /* execute a statement (that does not return a result set) */ -typedef long (*pdo_dbh_do_func)(pdo_dbh_t *dbh, const char *sql, long sql_len TSRMLS_DC); +typedef php_int_t (*pdo_dbh_do_func)(pdo_dbh_t *dbh, const char *sql, php_int_t sql_len TSRMLS_DC); /* quote a string */ typedef int (*pdo_dbh_quote_func)(pdo_dbh_t *dbh, const char *unquoted, int unquotedlen, char **quoted, int *quotedlen, enum pdo_param_type paramtype TSRMLS_DC); @@ -256,7 +256,7 @@ typedef int (*pdo_dbh_quote_func)(pdo_dbh_t *dbh, const char *unquoted, int unqu typedef int (*pdo_dbh_txn_func)(pdo_dbh_t *dbh TSRMLS_DC); /* setting of attributes */ -typedef int (*pdo_dbh_set_attr_func)(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC); +typedef int (*pdo_dbh_set_attr_func)(pdo_dbh_t *dbh, php_int_t attr, zval *val TSRMLS_DC); /* return last insert id. NULL indicates error condition, otherwise, the return value * MUST be an emalloc'd NULL terminated string. */ @@ -271,7 +271,7 @@ typedef char *(*pdo_dbh_last_id_func)(pdo_dbh_t *dbh, const char *name, unsigned typedef int (*pdo_dbh_fetch_error_func)(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *info TSRMLS_DC); /* fetching of attributes */ -typedef int (*pdo_dbh_get_attr_func)(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC); +typedef int (*pdo_dbh_get_attr_func)(pdo_dbh_t *dbh, php_int_t attr, zval *val TSRMLS_DC); /* checking/pinging persistent connections; return SUCCESS if the connection * is still alive and ready to be used, FAILURE otherwise. @@ -329,7 +329,7 @@ typedef int (*pdo_stmt_execute_func)(pdo_stmt_t *stmt TSRMLS_DC); * more rows. The ori and offset params modify which row should be returned, * if the stmt represents a scrollable cursor */ typedef int (*pdo_stmt_fetch_func)(pdo_stmt_t *stmt, - enum pdo_fetch_orientation ori, long offset TSRMLS_DC); + enum pdo_fetch_orientation ori, php_int_t offset TSRMLS_DC); /* queries information about the type of a column, by index (0 based). * Driver should populate stmt->columns[colno] with appropriate info */ @@ -341,7 +341,7 @@ typedef int (*pdo_stmt_describe_col_func)(pdo_stmt_t *stmt, int colno TSRMLS_DC) * If the driver sets caller_frees, ptr should point to emalloc'd memory * and PDO will free it as soon as it is done using it. */ -typedef int (*pdo_stmt_get_col_data_func)(pdo_stmt_t *stmt, int colno, char **ptr, unsigned long *len, int *caller_frees TSRMLS_DC); +typedef int (*pdo_stmt_get_col_data_func)(pdo_stmt_t *stmt, int colno, char **ptr, php_uint_t *len, int *caller_frees TSRMLS_DC); /* hook for bound params */ enum pdo_param_event { @@ -357,10 +357,10 @@ enum pdo_param_event { typedef int (*pdo_stmt_param_hook_func)(pdo_stmt_t *stmt, struct pdo_bound_param_data *param, enum pdo_param_event event_type TSRMLS_DC); /* setting of attributes */ -typedef int (*pdo_stmt_set_attr_func)(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC); +typedef int (*pdo_stmt_set_attr_func)(pdo_stmt_t *stmt, php_int_t attr, zval *val TSRMLS_DC); /* fetching of attributes */ -typedef int (*pdo_stmt_get_attr_func)(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC); +typedef int (*pdo_stmt_get_attr_func)(pdo_stmt_t *stmt, php_int_t attr, zval *val TSRMLS_DC); /* retrieves meta data for a numbered column. * Returns SUCCESS/FAILURE. @@ -390,7 +390,7 @@ typedef int (*pdo_stmt_get_attr_func)(pdo_stmt_t *stmt, long attr, zval *val TSR * or * 'flags' => array('not_null', 'mysql:some_flag'); // to add data to an existing key */ -typedef int (*pdo_stmt_get_column_meta_func)(pdo_stmt_t *stmt, long colno, zval *return_value TSRMLS_DC); +typedef int (*pdo_stmt_get_column_meta_func)(pdo_stmt_t *stmt, php_int_t colno, zval *return_value TSRMLS_DC); /* advances the statement to the next rowset of the batch. * If it returns 1, PDO will tear down its idea of columns @@ -469,7 +469,7 @@ struct _pdo_dbh_t { /* data source string used to open this handle */ const char *data_source; - unsigned long data_source_len; + php_uint_t data_source_len; /* the global error code. */ pdo_error_type error_code; @@ -529,9 +529,9 @@ static inline pdo_dbh_object_t *php_pdo_dbh_fetch_object(zend_object *obj) { struct pdo_column_data { char *name; int namelen; - unsigned long maxlen; + php_uint_t maxlen; enum pdo_param_type param_type; - unsigned long precision; + php_uint_t precision; /* don't touch this unless your name is dbdo */ void *dbdo_data; @@ -539,10 +539,10 @@ struct pdo_column_data { /* describes a bound parameter */ struct pdo_bound_param_data { - long paramno; /* if -1, then it has a name, and we don't know the index *yet* */ + php_int_t paramno; /* if -1, then it has a name, and we don't know the index *yet* */ zend_string *name; - long max_value_len; /* as a hint for pre-allocation */ + php_int_t max_value_len; /* as a hint for pre-allocation */ zval parameter; /* the variable itself */ enum pdo_param_type param_type; /* desired or suggested type */ @@ -591,7 +591,7 @@ struct _pdo_stmt_t { HashTable *bound_columns; /* not always meaningful */ - long row_count; + php_int_t row_count; /* used to hold the statement's current query */ char *query_string; @@ -607,7 +607,7 @@ struct _pdo_stmt_t { /* for lazy fetches, we always return the same lazy object handle. * Let's keep it here. */ zval lazy_object_ref; - unsigned long refcount; + php_uint_t refcount; /* defaults for fetches */ enum pdo_fetch_type default_fetch_type; @@ -669,7 +669,7 @@ struct pdo_data_src_parser { }; PDO_API int php_pdo_parse_data_source(const char *data_source, - unsigned long data_source_len, struct pdo_data_src_parser *parsed, + php_uint_t data_source_len, struct pdo_data_src_parser *parsed, int nparams); PDO_API zend_class_entry *php_pdo_get_dbh_ce(void); diff --git a/ext/pdo_sqlite/sqlite_driver.c b/ext/pdo_sqlite/sqlite_driver.c index 27549bdc58..50887b4bb3 100644 --- a/ext/pdo_sqlite/sqlite_driver.c +++ b/ext/pdo_sqlite/sqlite_driver.c @@ -175,7 +175,7 @@ static int sqlite_handle_closer(pdo_dbh_t *dbh TSRMLS_DC) /* {{{ */ } /* }}} */ -static int sqlite_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC) +static int sqlite_handle_preparer(pdo_dbh_t *dbh, const char *sql, php_int_t sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC) { pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data; pdo_sqlite_stmt *S = ecalloc(1, sizeof(pdo_sqlite_stmt)); @@ -203,7 +203,7 @@ static int sqlite_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len, return 0; } -static long sqlite_handle_doer(pdo_dbh_t *dbh, const char *sql, long sql_len TSRMLS_DC) +static php_int_t sqlite_handle_doer(pdo_dbh_t *dbh, const char *sql, php_int_t sql_len TSRMLS_DC) { pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data; char *errmsg = NULL; @@ -280,7 +280,7 @@ static int sqlite_handle_rollback(pdo_dbh_t *dbh TSRMLS_DC) return 1; } -static int pdo_sqlite_get_attribute(pdo_dbh_t *dbh, long attr, zval *return_value TSRMLS_DC) +static int pdo_sqlite_get_attribute(pdo_dbh_t *dbh, php_int_t attr, zval *return_value TSRMLS_DC) { switch (attr) { case PDO_ATTR_CLIENT_VERSION: @@ -295,7 +295,7 @@ static int pdo_sqlite_get_attribute(pdo_dbh_t *dbh, long attr, zval *return_valu return 1; } -static int pdo_sqlite_set_attr(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC) +static int pdo_sqlite_set_attr(pdo_dbh_t *dbh, php_int_t attr, zval *val TSRMLS_DC) { pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data; @@ -522,13 +522,13 @@ static PHP_METHOD(SQLite, sqliteCreateFunction) zval *callback; char *func_name; int func_name_len; - long argc = -1; + php_int_t argc = -1; zend_string *cbname = NULL; pdo_dbh_t *dbh; pdo_sqlite_db_handle *H; int ret; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|i", &func_name, &func_name_len, &callback, &argc)) { RETURN_FALSE; } @@ -592,13 +592,13 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate) zval *step_callback, *fini_callback; char *func_name; int func_name_len; - long argc = -1; + php_int_t argc = -1; zend_string *cbname = NULL; pdo_dbh_t *dbh; pdo_sqlite_db_handle *H; int ret; - if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szz|l", + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szz|i", &func_name, &func_name_len, &step_callback, &fini_callback, &argc)) { RETURN_FALSE; } @@ -792,7 +792,7 @@ static int pdo_sqlite_handle_factory(pdo_dbh_t *dbh, zval *driver_options TSRMLS { pdo_sqlite_db_handle *H; int i, ret = 0; - long timeout = 60; + php_int_t timeout = 60; char *filename; H = pecalloc(1, sizeof(pdo_sqlite_db_handle), dbh->is_persistent); diff --git a/ext/pdo_sqlite/sqlite_statement.c b/ext/pdo_sqlite/sqlite_statement.c index ccd2dc5efd..ee6879544a 100644 --- a/ext/pdo_sqlite/sqlite_statement.c +++ b/ext/pdo_sqlite/sqlite_statement.c @@ -118,7 +118,7 @@ static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_d } } else { convert_to_int(parameter); -#if LONG_MAX > 2147483647 +#if PHP_INT_MAX > 2147483647 if (SQLITE_OK == sqlite3_bind_int64(S->stmt, param->paramno + 1, Z_IVAL_P(parameter))) { return 1; } @@ -198,7 +198,7 @@ static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_d } static int pdo_sqlite_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_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data; int i; @@ -259,7 +259,7 @@ static int pdo_sqlite_stmt_describe(pdo_stmt_t *stmt, int colno TSRMLS_DC) return 1; } -static int pdo_sqlite_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, unsigned long *len, int *caller_frees TSRMLS_DC) +static int pdo_sqlite_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, php_uint_t *len, int *caller_frees TSRMLS_DC) { pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data; if (!S->stmt) { @@ -288,7 +288,7 @@ static int pdo_sqlite_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, unsi } } -static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_value TSRMLS_DC) +static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, php_int_t colno, zval *return_value TSRMLS_DC) { pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data; const char *str;