}
/* }}} */
-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;
char buffer[65];
char outbuf[65] = "";
register char *p;
- long long_val;
+ php_int_t long_val;
char *dst = outbuf;
if (i64 < 0) {
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;
}
#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) /* {{{ */
{
pdo_error_type *pdo_err = &dbh->error_code;
const char *msg = "<<Unknown>>";
char *supp = NULL;
- long native_code = 0;
+ php_int_t native_code = 0;
zend_string *message = NULL;
zval info;
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) {
}
/* }}} */
-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 \
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;
}
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;
}
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;
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;
}
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
}
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);
{
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;
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);
}
/* }}} */
-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;
/* 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;
}
/* }}} */
-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;
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,
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;
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;
}
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;
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;
}
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;
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;
}
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;
}
/* {{{ 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:
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;
}
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) {
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;
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) {
struct php_pdo_iterator {
zend_object_iterator iter;
- ulong key;
+ php_uint_t key;
zval fetch_ahead;
};
PHP_MINFO_FUNCTION(pdo);
ZEND_BEGIN_MODULE_GLOBALS(pdo)
- long global_value;
+ php_int_t global_value;
ZEND_END_MODULE_GLOBALS(pdo)
#ifdef ZTS
#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) \
};
/* {{{ 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;
* 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, \
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);
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. */
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.
* 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 */
* 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 {
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.
* 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
/* 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;
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;
/* 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 */
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;
/* 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;
};
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);
}
/* }}} */
-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));
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;
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:
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;
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;
}
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;
}
{
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);
}
} 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;
}
}
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;
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) {
}
}
-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;
projects / php / commitdiff