PHP_METHOD(Test_Flow, testWhileDoNextTest) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_1 = NULL, *_2 = NULL;
zval *variable, *returnValue, *_0 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &variable);
ZEPHIR_INIT_VAR(returnValue);
array_init(returnValue);
do {
Z_SET_ISREF_P(variable);
ZEPHIR_CALL_FUNCTION(&_0, "current", &_1, variable);
Z_UNSET_ISREF_P(variable);
zephir_check_call_status();
zephir_array_append(&returnValue, _0, PH_SEPARATE, "test/flow.zep", 430);
Z_SET_ISREF_P(variable);
ZEPHIR_CALL_FUNCTION(&_0, "next", &_2, variable);
Z_UNSET_ISREF_P(variable);
zephir_check_call_status();
} while (zephir_is_true(_0));
RETURN_CCTOR(returnValue);
}
PHP_METHOD(Test_Flow, testWhileDoNextTest) {
zval *variable, *returnValue, *_0 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &variable);
ZEPHIR_INIT_VAR(returnValue);
array_init(returnValue);
do {
Z_SET_ISREF_P(variable);
ZEPHIR_INIT_NVAR(_0);
zephir_call_func_p1(_0, "current", variable);
Z_UNSET_ISREF_P(variable);
zephir_array_append(&returnValue, _0, PH_SEPARATE);
Z_SET_ISREF_P(variable);
ZEPHIR_INIT_NVAR(_0);
zephir_call_func_p1(_0, "next", variable);
Z_UNSET_ISREF_P(variable);
} while (zephir_is_true(_0));
RETURN_CCTOR(returnValue);
}
/**
* Check whether internal resource has rows to fetch
*
* @return boolean
*/
PHP_METHOD(Phalcon_Model_Resultset, valid){
zval *result = NULL, *row = NULL, *rows = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
zval *c0 = NULL, *c1 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_type", sizeof("_type")-1, PHALCON_NOISY TSRMLS_CC);
if (zend_is_true(t0)) {
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_result", sizeof("_result")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(result, t1);
if (Z_TYPE_P(result) != IS_BOOL || (Z_TYPE_P(result) == IS_BOOL && Z_BVAL_P(result))) {
PHALCON_INIT_VAR(c0);
ZVAL_LONG(c0, 1);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(result, "setfetchmode", c0, PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD_PARAMS_1(r0, result, "fetcharray", result, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(row, r0);
if (zend_is_true(row)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_model", sizeof("_model")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_STATIC_PARAMS_2(r1, "phalcon_model_base", "dumpresult", t2, row);
phalcon_update_property_zval(this_ptr, "_activeRow", strlen("_activeRow"), r1 TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_TRUE;
} else {
PHALCON_INIT_VAR(c1);
ZVAL_LONG(c1, 2);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(result, "setfetchmode", c1, PHALCON_NO_CHECK);
}
}
} else {
PHALCON_ALLOC_ZVAL_MM(t3);
phalcon_read_property(&t3, this_ptr, "_rows", sizeof("_rows")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(rows, t3);
PHALCON_ALLOC_ZVAL_MM(r2);
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1(r2, "current", rows, 0x054);
Z_UNSET_ISREF_P(rows);
PHALCON_CPY_WRT(row, r2);
if (zend_is_true(row)) {
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("next", rows, 0x059);
Z_UNSET_ISREF_P(rows);
phalcon_update_property_zval(this_ptr, "_activeRow", strlen("_activeRow"), row TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* Changes internal pointer to a specific position in the resultset
*/
PHP_METHOD(Phalcon_Model_Resultset, seek){
zval *position = NULL, *rows = NULL, *i = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &position) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_FUNC_PARAMS_1(r0, "intval", position, 0x020);
phalcon_update_property_zval(this_ptr, "_pointer", strlen("_pointer"), r0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_type", sizeof("_type")-1, PHALCON_NOISY TSRMLS_CC);
if (zend_is_true(t0)) {
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_connection", sizeof("_connection")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_resultResource", sizeof("_resultResource")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(t1, "dataseek", position, t2, PHALCON_NO_CHECK);
} else {
PHALCON_ALLOC_ZVAL_MM(t3);
phalcon_read_property(&t3, this_ptr, "_rows", sizeof("_rows")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(rows, t3);
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("reset", rows, 0x055);
Z_UNSET_ISREF_P(rows);
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
fs_fd08_0:
PHALCON_INIT_VAR(r1);
is_smaller_function(r1, i, position TSRMLS_CC);
if (!zend_is_true(r1)) {
goto fe_fd08_0;
}
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("next", rows, 0x059);
Z_UNSET_ISREF_P(rows);
PHALCON_SEPARATE(i);
increment_function(i);
goto fs_fd08_0;
fe_fd08_0:
if(0){}
}
PHALCON_MM_RESTORE();
}
/**
* Changes internal pointer to a specific position in the resultset
*
* @param int $position
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, seek){
zval *position = NULL, *int_position = NULL, *type = NULL, *result = NULL, *rows = NULL;
zval *i = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &position) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(int_position);
PHALCON_CALL_FUNC_PARAMS_1(int_position, "intval", position);
phalcon_update_property_zval(this_ptr, SL("_pointer"), int_position TSRMLS_CC);
PHALCON_INIT_VAR(type);
phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC);
if (zend_is_true(type)) {
PHALCON_INIT_VAR(result);
phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(result, "dataseek", position, PH_NO_CHECK);
} else {
PHALCON_INIT_VAR(rows);
phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC);
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("reset", rows);
Z_UNSET_ISREF_P(rows);
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
fs_ebc1_0:
PHALCON_INIT_VAR(r0);
is_smaller_function(r0, i, position TSRMLS_CC);
if (!zend_is_true(r0)) {
goto fe_ebc1_0;
}
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("next", rows);
Z_UNSET_ISREF_P(rows);
PHALCON_SEPARATE(i);
increment_function(i);
goto fs_ebc1_0;
fe_ebc1_0:
if(0){}
}
PHALCON_MM_RESTORE();
}
/**
* Defined by Iterator interface
*
* @return boolean
*/
PHP_METHOD(Yaf_Session, valid) {
zend_bool _3;
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_1 = NULL;
zval *key = NULL, *_0, *_2;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("session"), PH_NOISY_CC);
Z_SET_ISREF_P(_0);
ZEPHIR_CALL_FUNCTION(&key, "key", &_1, _0);
Z_UNSET_ISREF_P(_0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_2);
_3 = Z_TYPE_P(key) == IS_NULL;
if (!(_3)) {
_3 = ZEPHIR_IS_FALSE(key);
}
if (_3) {
ZVAL_BOOL(_2, 0);
} else {
ZVAL_BOOL(_2, 1);
}
RETURN_CCTOR(_2);
}
PHP_METHOD(Test_Pregmatch, testPregMatchFallback) {
int ZEPHIR_LAST_CALL_STATUS;
zval *pattern, *subject, *matches = NULL, *_0, *_1;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
ZEPHIR_INIT_NVAR(matches);
array_init(matches);
ZEPHIR_INIT_VAR(pattern);
ZVAL_STRING(pattern, "/def$/", 1);
ZEPHIR_INIT_VAR(subject);
ZVAL_STRING(subject, "abcdef", 1);
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, 0);
ZEPHIR_INIT_VAR(_1);
ZVAL_LONG(_1, 0);
Z_SET_ISREF_P(matches);
ZEPHIR_RETURN_CALL_FUNCTION("preg_match", NULL, 49, pattern, subject, matches, _0, _1);
Z_UNSET_ISREF_P(matches);
zephir_check_call_status();
RETURN_MM();
}
/**
* Rewinds resultset to its beginning
*
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, rewind){
zval *type = NULL, *result = NULL, *rows = NULL;
zval *c0 = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(type);
phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC);
if (zend_is_true(type)) {
PHALCON_INIT_VAR(result);
phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (Z_TYPE_P(result) != IS_BOOL || (Z_TYPE_P(result) == IS_BOOL && Z_BVAL_P(result))) {
phalcon_update_property_long(this_ptr, SL("_pointer"), 1 TSRMLS_CC);
PHALCON_INIT_VAR(c0);
ZVAL_LONG(c0, 0);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(result, "dataseek", c0, PH_NO_CHECK);
}
} else {
PHALCON_INIT_VAR(rows);
phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC);
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("reset", rows);
Z_UNSET_ISREF_P(rows);
}
PHALCON_MM_RESTORE();
}
/**
* Rewinds resultset to its beginning
*
*/
PHP_METHOD(Phalcon_Model_Resultset, rewind){
zval *result = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL;
zval *c0 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_type", sizeof("_type")-1, PHALCON_NOISY TSRMLS_CC);
if (zend_is_true(t0)) {
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_result", sizeof("_result")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(result, t1);
if (Z_TYPE_P(result) != IS_BOOL || (Z_TYPE_P(result) == IS_BOOL && Z_BVAL_P(result))) {
phalcon_update_property_long(this_ptr, "pointer", strlen("pointer"), 1 TSRMLS_CC);
PHALCON_INIT_VAR(c0);
ZVAL_LONG(c0, 0);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(result, "dataseek", c0, PHALCON_NO_CHECK);
}
} else {
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_rows", sizeof("_rows")-1, PHALCON_NOISY TSRMLS_CC);
Z_SET_ISREF_P(t2);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("reset", t2, 0x055);
Z_UNSET_ISREF_P(t2);
}
PHALCON_MM_RESTORE();
}
/**
* Render view
*/
PHP_METHOD(Owl_Mvc_View, render) {
int ZEPHIR_LAST_CALL_STATUS;
zval *parameters = NULL;
zval *path_param = NULL, *parameters_param = NULL, *_0, *_1, *_2, *_3, *_4, *tmp = NULL;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &path_param, ¶meters_param);
if (unlikely(Z_TYPE_P(path_param) != IS_STRING && Z_TYPE_P(path_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'path' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(path_param) == IS_STRING)) {
zephir_get_strval(path, path_param);
} else {
ZEPHIR_INIT_VAR(path);
ZVAL_EMPTY_STRING(path);
}
if (!parameters_param) {
ZEPHIR_INIT_VAR(parameters);
array_init(parameters);
} else {
zephir_get_arrval(parameters, parameters_param);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("path"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_VV(_1, _0, path);
if (!((zephir_file_exists(_1 TSRMLS_CC) == SUCCESS))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(owl_exception_ce, "File is not exists", "owl/Mvc/View.zep", 21);
return;
}
ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 23);
zephir_check_call_status();
if (!(Z_TYPE_P(parameters) == IS_NULL)) {
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, 0);
Z_SET_ISREF_P(parameters);
ZEPHIR_CALL_FUNCTION(NULL, "extract", NULL, 24, parameters, _2);
Z_UNSET_ISREF_P(parameters);
zephir_check_call_status();
}
_3 = zephir_fetch_nproperty_this(this_ptr, SL("path"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_4);
ZEPHIR_CONCAT_VV(_4, _3, path);
if (zephir_require_zval(_4 TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
ZEPHIR_CALL_FUNCTION(&tmp, "ob_get_contents", NULL, 25);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(NULL, "ob_end_clean", NULL, 26);
zephir_check_call_status();
RETURN_CCTOR(tmp);
}
/**
* Check whether internal resource has rows to fetch
*
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, valid){
zval *type = NULL, *result = NULL, *row = NULL, *model = NULL, *active_row = NULL, *rows = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(type);
phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC);
if (zend_is_true(type)) {
PHALCON_INIT_VAR(result);
phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (Z_TYPE_P(result) != IS_BOOL || (Z_TYPE_P(result) == IS_BOOL && Z_BVAL_P(result))) {
PHALCON_INIT_VAR(row);
PHALCON_CALL_METHOD_PARAMS_1(row, result, "fetcharray", result, PH_NO_CHECK);
if (Z_TYPE_P(row) != IS_BOOL || (Z_TYPE_P(row) == IS_BOOL && Z_BVAL_P(row))) {
PHALCON_INIT_VAR(model);
phalcon_read_property(&model, this_ptr, SL("_model"), PH_NOISY_CC);
PHALCON_INIT_VAR(active_row);
PHALCON_CALL_STATIC_PARAMS_2(active_row, "phalcon\\mvc\\model", "dumpresult", model, row);
phalcon_update_property_zval(this_ptr, SL("_activeRow"), active_row TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
}
} else {
PHALCON_INIT_VAR(rows);
phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC);
Z_SET_ISREF_P(rows);
PHALCON_INIT_VAR(row);
PHALCON_CALL_FUNC_PARAMS_1(row, "current", rows);
Z_UNSET_ISREF_P(rows);
if (zend_is_true(row)) {
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("next", rows);
Z_UNSET_ISREF_P(rows);
phalcon_update_property_zval(this_ptr, SL("_activeRow"), row TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* Executes the validator
*
* @return boolean
*/
PHP_METHOD(Phalcon_Model_Validator_Email, validate){
zval *regs = NULL, *field_name = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "isrequired", PHALCON_NO_CHECK);
if (zend_is_true(r0)) {
PHALCON_INIT_VAR(regs);
ZVAL_NULL(regs);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD(r1, this_ptr, "getfieldname", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(field_name, r1);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "/^[a-zA-Z0-9_\\.\\+]+@[a-zA-Z0-9_]+(\\.[a-zA-Z0-9_]+)*$/", 1);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CALL_METHOD(r3, this_ptr, "getvalue", PHALCON_NO_CHECK);
Z_SET_ISREF_P(regs);
PHALCON_CALL_FUNC_PARAMS_3(r2, "preg_match", c0, r3, regs, 0x006);
Z_UNSET_ISREF_P(regs);
if (zend_is_true(r2)) {
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_long(&r4, regs, 0, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CALL_METHOD(r5, this_ptr, "getvalue", PHALCON_NO_CHECK);
PHALCON_INIT_VAR(r6);
is_not_equal_function(r6, r4, r5 TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_CONCAT_SVS(r7, "Value of field '", field_name, "' should be a valid e-mail");
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "email", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r7, field_name, c1, PHALCON_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
} else {
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CONCAT_SVS(r8, "Value of field '", field_name, "' should be a valid e-mail");
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "email", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r8, field_name, c2, PHALCON_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Initializes the class. It assigns the attributes that can be obtained and modified.
*/
PHP_METHOD(Phady_Security_Core_Models_Entities_Resources, init) {
zval *_1, *_2 = NULL, *_3 = NULL, *_4 = NULL, *_6;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL, *_5 = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_CALL_PARENT(NULL, phady_security_core_models_entities_resources_ce, this_ptr, "init", &_0, 56);
zephir_check_call_status();
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_set"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "resource_id", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, "module_id", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_4);
ZVAL_STRING(_4, "name", ZEPHIR_TEMP_PARAM_COPY);
Z_SET_ISREF_P(_1);
ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_5, 57, _1, _2, _3, _4);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
Z_UNSET_ISREF_P(_1);
zephir_check_call_status();
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_get"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "resource_id", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "module_id", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "name", ZEPHIR_TEMP_PARAM_COPY);
Z_SET_ISREF_P(_6);
ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_5, 57, _6, _2, _3, _4);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_temp_parameter(_4);
Z_UNSET_ISREF_P(_6);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Rewinds resultset to its beginning
*
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, rewind){
zval *type, *result = NULL, *active_row, *zero, *rows = NULL;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(type);
phalcon_read_property_this(&type, this_ptr, SL("_type"), PH_NOISY_CC);
if (zend_is_true(type)) {
/**
* Here, the resultset act as a result that is fetched one by one
*/
PHALCON_OBS_VAR(result);
phalcon_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (PHALCON_IS_NOT_FALSE(result)) {
PHALCON_OBS_VAR(active_row);
phalcon_read_property_this(&active_row, this_ptr, SL("_activeRow"), PH_NOISY_CC);
if (Z_TYPE_P(active_row) != IS_NULL) {
PHALCON_INIT_VAR(zero);
ZVAL_LONG(zero, 0);
phalcon_call_method_p1_noret(result, "dataseek", zero);
}
}
} else {
/**
* Here, the resultset act as an array
*/
PHALCON_OBS_VAR(rows);
phalcon_read_property_this(&rows, this_ptr, SL("_rows"), PH_NOISY_CC);
if (Z_TYPE_P(rows) == IS_NULL) {
PHALCON_OBS_NVAR(result);
phalcon_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (Z_TYPE_P(result) == IS_OBJECT) {
PHALCON_INIT_NVAR(rows);
phalcon_call_method(rows, result, "fetchall");
phalcon_update_property_this(this_ptr, SL("_rows"), rows TSRMLS_CC);
}
}
if (Z_TYPE_P(rows) == IS_ARRAY) {
Z_SET_ISREF_P(rows);
phalcon_call_func_p1_noret("reset", rows);
Z_UNSET_ISREF_P(rows);
}
}
phalcon_update_property_long(this_ptr, SL("_pointer"), 0 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
static void
SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject TSRMLS_DC) {
swig_object_wrapper *value=NULL;
/*
* First test for Null pointers. Return those as PHP native NULL
*/
if (!ptr ) {
ZVAL_NULL(z);
return;
}
if (type->clientdata) {
if (! (*(int *)(type->clientdata)))
zend_error(E_ERROR, "Type: %s failed to register with zend",type->name);
value=(swig_object_wrapper *)emalloc(sizeof(swig_object_wrapper));
value->ptr=ptr;
value->newobject=newobject;
if (newobject <= 1) {
/* Just register the pointer as a resource. */
ZEND_REGISTER_RESOURCE(z, value, *(int *)(type->clientdata));
} else {
/*
* Wrap the resource in an object, the resource will be accessible
* via the "_cPtr" member. This is currently only used by
* directorin typemaps.
*/
value->newobject = 0;
zval *resource;
MAKE_STD_ZVAL(resource);
ZEND_REGISTER_RESOURCE(resource, value, *(int *)(type->clientdata));
zend_class_entry **ce = NULL;
zval *classname;
MAKE_STD_ZVAL(classname);
/* _p_Foo -> Foo */
ZVAL_STRING(classname, (char*)type->name+3, 1);
/* class names are stored in lowercase */
php_strtolower(Z_STRVAL_PP(&classname), Z_STRLEN_PP(&classname));
if (zend_lookup_class(Z_STRVAL_P(classname), Z_STRLEN_P(classname), &ce TSRMLS_CC) != SUCCESS) {
/* class does not exist */
object_init(z);
} else {
object_init_ex(z, *ce);
}
Z_SET_REFCOUNT_P(z, 1);
Z_SET_ISREF_P(z);
zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval), NULL);
FREE_ZVAL(classname);
}
return;
}
zend_error(E_ERROR, "Type: %s not registered with zend",type->name);
}
/**
* Defined by Iterator interface
*
* @return mixed
*/
PHP_METHOD(Yaf_Session, current) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_1 = NULL;
zval *_0;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("session"), PH_NOISY_CC);
Z_SET_ISREF_P(_0);
ZEPHIR_RETURN_CALL_FUNCTION("current", &_1, _0);
Z_UNSET_ISREF_P(_0);
zephir_check_call_status();
RETURN_MM();
}
/**
* Get the storage array of routes
*
* @return array
*/
PHP_METHOD(Prr_RouteCollection, all) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_1 = NULL;
zval *_0;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("storage"), PH_NOISY_CC);
Z_SET_ISREF_P(_0);
ZEPHIR_CALL_FUNCTION(NULL, "reset", &_1, _0);
Z_UNSET_ISREF_P(_0);
zephir_check_call_status();
RETURN_MM_MEMBER(this_ptr, "storage");
}
/**
* Rewinds resultset to its beginning
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, rewind) {
zephir_nts_static zephir_fcall_cache_entry *_3 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *rows = NULL, *result = NULL, *_0, *_1, *_2;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_type"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
ZEPHIR_OBS_VAR(result);
zephir_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (!ZEPHIR_IS_FALSE_IDENTICAL(result)) {
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_activeRow"), PH_NOISY_CC);
if (Z_TYPE_P(_1) != IS_NULL) {
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, 0);
ZEPHIR_CALL_METHOD(NULL, result, "dataseek", NULL, _2);
zephir_check_call_status();
}
}
} else {
ZEPHIR_OBS_VAR(rows);
zephir_read_property_this(&rows, this_ptr, SL("_rows"), PH_NOISY_CC);
if (Z_TYPE_P(rows) == IS_NULL) {
ZEPHIR_OBS_NVAR(result);
zephir_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (Z_TYPE_P(result) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&rows, result, "fetchall", NULL);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_rows"), rows TSRMLS_CC);
}
}
if (Z_TYPE_P(rows) == IS_ARRAY) {
Z_SET_ISREF_P(rows);
ZEPHIR_CALL_FUNCTION(NULL, "reset", &_3, rows);
Z_UNSET_ISREF_P(rows);
zephir_check_call_status();
}
}
ZEPHIR_INIT_ZVAL_NREF(_1);
ZVAL_LONG(_1, 0);
zephir_update_property_this(this_ptr, SL("_pointer"), _1 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_Pregmatch, testPregMatch5Params) {
int ZEPHIR_LAST_CALL_STATUS;
zval *pattern, *subject, *matches, *flags, *offset;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 5, 0, &pattern, &subject, &matches, &flags, &offset);
Z_SET_ISREF_P(matches);
ZEPHIR_RETURN_CALL_FUNCTION("preg_match", NULL, 49, pattern, subject, matches, flags, offset);
Z_UNSET_ISREF_P(matches);
zephir_check_call_status();
RETURN_MM();
}
/**
* Sorts an array
*/
PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, sort) {
int ZEPHIR_LAST_CALL_STATUS;
zval *value_param = NULL;
zval *value = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &value_param);
zephir_get_arrval(value, value_param);
Z_SET_ISREF_P(value);
ZEPHIR_CALL_FUNCTION(NULL, "asort", NULL, 381, value);
Z_UNSET_ISREF_P(value);
zephir_check_call_status();
RETURN_CTOR(value);
}
/**
* Rewind array position
*
* @see Iterator
* @return boolean
*/
PHP_METHOD(Prr_RouteCollection, valid) {
zend_bool _2;
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_1 = NULL;
zval *key = NULL, *_0;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("storage"), PH_NOISY_CC);
Z_SET_ISREF_P(_0);
ZEPHIR_CALL_FUNCTION(&key, "key", &_1, _0);
Z_UNSET_ISREF_P(_0);
zephir_check_call_status();
_2 = Z_TYPE_P(key) != IS_NULL;
if (_2) {
_2 = !ZEPHIR_IS_FALSE_IDENTICAL(key);
}
RETURN_MM_BOOL(_2);
}
/**
* Makes a connection to the Beanstalkd server
*/
PHP_METHOD(Phalcon_Queue_Beanstalk, connect) {
zephir_nts_static zephir_fcall_cache_entry *_4 = NULL, *_6 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *connection = NULL, *parameters, *_0, *_1, *_2, *_3, _5;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(connection);
zephir_read_property_this(&connection, this_ptr, SL("_connection"), PH_NOISY_CC);
if (Z_TYPE_P(connection) == IS_RESOURCE) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "disconnect", NULL);
zephir_check_call_status();
}
ZEPHIR_OBS_VAR(parameters);
zephir_read_property_this(¶meters, this_ptr, SL("_parameters"), PH_NOISY_CC);
zephir_array_fetch_string(&_0, parameters, SL("host"), PH_NOISY | PH_READONLY, "phalcon/queue/beanstalk.zep", 78 TSRMLS_CC);
zephir_array_fetch_string(&_1, parameters, SL("port"), PH_NOISY | PH_READONLY, "phalcon/queue/beanstalk.zep", 78 TSRMLS_CC);
ZEPHIR_INIT_VAR(_2);
ZVAL_NULL(_2);
ZEPHIR_INIT_VAR(_3);
ZVAL_NULL(_3);
Z_SET_ISREF_P(_2);
ZEPHIR_CALL_FUNCTION(&connection, "fsockopen", &_4, _0, _1, _2, _3);
Z_UNSET_ISREF_P(_2);
zephir_check_call_status();
if (Z_TYPE_P(connection) != IS_RESOURCE) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_exception_ce, "Can't connect to Beanstalk server", "phalcon/queue/beanstalk.zep", 80);
return;
}
ZEPHIR_SINIT_VAR(_5);
ZVAL_LONG(&_5, -1);
ZEPHIR_CALL_FUNCTION(NULL, "stream_set_timeout", &_6, connection, &_5, ZEPHIR_GLOBAL(global_null));
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_connection"), connection TSRMLS_CC);
RETURN_CCTOR(connection);
}
PHP_METHOD(Test_Pregmatch, testMatchAll) {
int ZEPHIR_LAST_CALL_STATUS;
zval *flags, *text, *matches, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &flags);
ZEPHIR_INIT_VAR(matches);
array_init(matches);
ZEPHIR_INIT_VAR(text);
ZVAL_STRING(text, "test1,test2", 1);
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "/(test[0-9]+)/", ZEPHIR_TEMP_PARAM_COPY);
Z_SET_ISREF_P(matches);
ZEPHIR_CALL_FUNCTION(NULL, "preg_match_all", NULL, 50, _0, text, matches, flags);
zephir_check_temp_parameter(_0);
Z_UNSET_ISREF_P(matches);
zephir_check_call_status();
RETURN_CCTOR(matches);
}
/**
* Applies a format to a message before sending it to the log
*
* @param string $message
* @param int $type
* @param int $timestamp
* @param array $context
*
* @return string
*/
PHP_METHOD(Phalcon_Logger_Formatter_Firephp, format) {
zval *_18;
HashTable *_7;
HashPosition _6;
zend_bool param, _11, _14;
int type, timestamp, ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *type_param = NULL, *timestamp_param = NULL, *context = NULL, *meta, *body = NULL, *backtrace = NULL, *encoded, *len, *lastTrace = NULL, *_0 = NULL, *_1 = NULL, *_2, *backtraceItem = NULL, *key = NULL, _3, _4, *_5, **_8, *_9, *_10, *_12, *_13, *_15, *_16, *_17;
zval *message = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &message_param, &type_param, ×tamp_param, &context);
zephir_get_strval(message, message_param);
type = zephir_get_intval(type_param);
timestamp = zephir_get_intval(timestamp_param);
if (!context) {
context = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(context) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&_0, this_ptr, "interpolate", NULL, 0, message, context);
zephir_check_call_status();
zephir_get_strval(message, _0);
}
ZEPHIR_INIT_VAR(meta);
zephir_create_array(meta, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_1);
ZVAL_LONG(_1, type);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "gettypestring", NULL, 0, _1);
zephir_check_call_status();
zephir_array_update_string(&meta, SL("Type"), &_0, PH_COPY | PH_SEPARATE);
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
if (zephir_is_true(_2)) {
param = 0;
ZEPHIR_INIT_NVAR(_1);
ZEPHIR_GET_CONSTANT(_1, "PHP_VERSION");
ZEPHIR_SINIT_VAR(_3);
ZVAL_STRING(&_3, "5.3.6", 0);
ZEPHIR_SINIT_VAR(_4);
ZVAL_STRING(&_4, "<", 0);
ZEPHIR_CALL_FUNCTION(&_0, "version_compare", NULL, 248, _1, &_3, &_4);
zephir_check_call_status();
if (!(zephir_is_true(_0))) {
param = (2) ? 1 : 0;
}
ZEPHIR_CALL_FUNCTION(&backtrace, "debug_backtrace", NULL, 150, (param ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)));
zephir_check_call_status();
Z_SET_ISREF_P(backtrace);
ZEPHIR_CALL_FUNCTION(&lastTrace, "end", NULL, 170, backtrace);
Z_UNSET_ISREF_P(backtrace);
zephir_check_call_status();
if (zephir_array_isset_string(lastTrace, SS("file"))) {
zephir_array_fetch_string(&_5, lastTrace, SL("file"), PH_NOISY | PH_READONLY, "phalcon/logger/formatter/firephp.zep", 133 TSRMLS_CC);
zephir_array_update_string(&meta, SL("File"), &_5, PH_COPY | PH_SEPARATE);
}
if (zephir_array_isset_string(lastTrace, SS("line"))) {
zephir_array_fetch_string(&_5, lastTrace, SL("line"), PH_NOISY | PH_READONLY, "phalcon/logger/formatter/firephp.zep", 137 TSRMLS_CC);
zephir_array_update_string(&meta, SL("Line"), &_5, PH_COPY | PH_SEPARATE);
}
zephir_is_iterable(backtrace, &_7, &_6, 1, 0, "phalcon/logger/formatter/firephp.zep", 146);
for (
; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS
; zephir_hash_move_forward_ex(_7, &_6)
) {
ZEPHIR_GET_HMKEY(key, _7, _6);
ZEPHIR_GET_HVALUE(backtraceItem, _8);
zephir_array_unset_string(&backtraceItem, SS("object"), PH_SEPARATE);
zephir_array_unset_string(&backtraceItem, SS("args"), PH_SEPARATE);
zephir_array_update_zval(&backtrace, key, &backtraceItem, PH_COPY | PH_SEPARATE);
}
}
_9 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
if (zephir_is_true(_9)) {
zephir_array_update_string(&meta, SL("Label"), &message, PH_COPY | PH_SEPARATE);
}
_10 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
_11 = !zephir_is_true(_10);
if (_11) {
_12 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
_11 = !zephir_is_true(_12);
}
_13 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
_14 = zephir_is_true(_13);
if (_14) {
_15 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
_14 = !zephir_is_true(_15);
}
if (_11) {
ZEPHIR_CPY_WRT(body, message);
} else if (_14) {
ZEPHIR_INIT_NVAR(body);
ZVAL_STRING(body, "", 1);
} else {
ZEPHIR_INIT_NVAR(body);
array_init(body);
_16 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC);
if (zephir_is_true(_16)) {
zephir_array_update_string(&body, SL("backtrace"), &backtrace, PH_COPY | PH_SEPARATE);
}
_17 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC);
if (!(zephir_is_true(_17))) {
zephir_array_update_string(&body, SL("message"), &message, PH_COPY | PH_SEPARATE);
}
}
ZEPHIR_INIT_VAR(_18);
zephir_create_array(_18, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_18, meta);
zephir_array_fast_append(_18, body);
ZEPHIR_INIT_VAR(encoded);
zephir_json_encode(encoded, &(encoded), _18, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(len);
ZVAL_LONG(len, zephir_fast_strlen_ev(encoded));
ZEPHIR_CONCAT_VSVS(return_value, len, "|", encoded, "|");
RETURN_MM();
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>
* print_r($connection->describeColumns("posts"));
* </code>
*
* @param string table
* @param string schema
* @return Phalcon\Db\Column[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeColumns) {
zephir_fcall_cache_entry *_17 = NULL;
zephir_nts_static zephir_fcall_cache_entry *_10 = NULL;
HashTable *_5;
HashPosition _4;
int ZEPHIR_LAST_CALL_STATUS;
zval *table_param = NULL, *schema_param = NULL, *columns, *columnType = NULL, *field = NULL, *definition = NULL, *oldColumn = NULL, *sizePattern, *matches = NULL, *matchOne = NULL, *matchTwo = NULL, *columnName, *_0 = NULL, *_1, *_2 = NULL, *_3 = NULL, **_6, *_7 = NULL, *_8 = NULL, *_9 = NULL, *_11 = NULL, *_12, *_13, *_14, *_15 = NULL, *_16;
zval *table = NULL, *schema = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table_param, &schema_param);
zephir_get_strval(table, table_param);
if (!schema_param) {
ZEPHIR_INIT_VAR(schema);
ZVAL_EMPTY_STRING(schema);
} else {
zephir_get_strval(schema, schema_param);
}
ZEPHIR_INIT_VAR(oldColumn);
ZVAL_NULL(oldColumn);
ZEPHIR_INIT_VAR(sizePattern);
ZVAL_STRING(sizePattern, "#\\(([0-9]+)(?:,\\s*([0-9]+))*\\)#", 1);
ZEPHIR_INIT_VAR(columns);
array_init(columns);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_dialect"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_2, _1, "describecolumns", NULL, table, schema);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZVAL_LONG(_3, 3);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "fetchall", NULL, _2, _3);
zephir_check_call_status();
zephir_is_iterable(_0, &_5, &_4, 0, 0, "phalcon/db/adapter/pdo/mysql.zep", 271);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HVALUE(field, _6);
ZEPHIR_INIT_NVAR(definition);
zephir_create_array(definition, 1, 0 TSRMLS_CC);
add_assoc_long_ex(definition, SS("bindType"), 2);
ZEPHIR_OBS_NVAR(columnType);
zephir_array_fetch_long(&columnType, field, 1, PH_NOISY, "phalcon/db/adapter/pdo/mysql.zep", 115 TSRMLS_CC);
while (1) {
if (zephir_memnstr_str(columnType, SL("enum"), "phalcon/db/adapter/pdo/mysql.zep", 122)) {
ZEPHIR_INIT_NVAR(_3);
ZVAL_LONG(_3, 5);
zephir_array_update_string(&definition, SL("type"), &_3, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("int"), "phalcon/db/adapter/pdo/mysql.zep", 130)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 0);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, 1);
zephir_array_update_string(&definition, SL("bindType"), &_8, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("varchar"), "phalcon/db/adapter/pdo/mysql.zep", 140)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 2);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("datetime"), "phalcon/db/adapter/pdo/mysql.zep", 148)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 4);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("decimal"), "phalcon/db/adapter/pdo/mysql.zep", 156)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 3);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, 32);
zephir_array_update_string(&definition, SL("bindType"), &_8, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("char"), "phalcon/db/adapter/pdo/mysql.zep", 166)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 5);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("date"), "phalcon/db/adapter/pdo/mysql.zep", 174)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 1);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("text"), "phalcon/db/adapter/pdo/mysql.zep", 182)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 6);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("float"), "phalcon/db/adapter/pdo/mysql.zep", 190)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 7);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, 3);
zephir_array_update_string(&definition, SL("bindType"), &_8, PH_COPY | PH_SEPARATE);
break;
}
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 2);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("("), "phalcon/db/adapter/pdo/mysql.zep", 207)) {
ZEPHIR_INIT_NVAR(matches);
ZVAL_NULL(matches);
Z_SET_ISREF_P(matches);
ZEPHIR_CALL_FUNCTION(&_9, "preg_match", &_10, sizePattern, columnType, matches);
Z_UNSET_ISREF_P(matches);
zephir_check_call_status();
if (zephir_is_true(_9)) {
ZEPHIR_OBS_NVAR(matchOne);
if (zephir_array_isset_long_fetch(&matchOne, matches, 1, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, zephir_get_intval(matchOne));
zephir_array_update_string(&definition, SL("size"), &_8, PH_COPY | PH_SEPARATE);
}
ZEPHIR_OBS_NVAR(matchTwo);
if (zephir_array_isset_long_fetch(&matchTwo, matches, 2, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_LONG(_11, zephir_get_intval(matchTwo));
zephir_array_update_string(&definition, SL("scale"), &_11, PH_COPY | PH_SEPARATE);
}
}
}
if (zephir_memnstr_str(columnType, SL("unsigned"), "phalcon/db/adapter/pdo/mysql.zep", 222)) {
zephir_array_update_string(&definition, SL("unsigned"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(oldColumn) == IS_NULL) {
zephir_array_update_string(&definition, SL("first"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
} else {
zephir_array_update_string(&definition, SL("after"), &oldColumn, PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_12, field, 3, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 238 TSRMLS_CC);
if (ZEPHIR_IS_STRING(_12, "PRI")) {
zephir_array_update_string(&definition, SL("primary"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_13, field, 2, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 245 TSRMLS_CC);
if (ZEPHIR_IS_STRING(_13, "NO")) {
zephir_array_update_string(&definition, SL("notNull"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_14, field, 5, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 252 TSRMLS_CC);
if (ZEPHIR_IS_STRING(_14, "auto_increment")) {
zephir_array_update_string(&definition, SL("autoIncrement"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
ZEPHIR_OBS_NVAR(_15);
zephir_array_fetch_long(&_15, field, 4, PH_NOISY, "phalcon/db/adapter/pdo/mysql.zep", 259 TSRMLS_CC);
if (Z_TYPE_P(_15) != IS_NULL) {
zephir_array_fetch_long(&_16, field, 4, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 260 TSRMLS_CC);
zephir_array_update_string(&definition, SL("default"), &_16, PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&columnName, field, 0, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 266 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_7);
object_init_ex(_7, phalcon_db_column_ce);
ZEPHIR_CALL_METHOD(NULL, _7, "__construct", &_17, columnName, definition);
zephir_check_call_status();
zephir_array_append(&columns, _7, PH_SEPARATE, "phalcon/db/adapter/pdo/mysql.zep", 267);
ZEPHIR_CPY_WRT(oldColumn, columnName);
}
RETURN_CCTOR(columns);
}
/**
* Handles routing information received from command-line arguments
*
* @param array arguments
*/
PHP_METHOD(Phalcon_Cli_Router, handle) {
zval *_16 = NULL;
zval *_6 = NULL, *_11 = NULL;
zephir_nts_static zephir_fcall_cache_entry *_5 = NULL, *_19 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_3, *_8;
HashPosition _2, _7;
zend_bool _0;
zval *arguments = NULL, *moduleName = NULL, *taskName = NULL, *actionName = NULL, *params = NULL, *route = NULL, *parts = NULL, *pattern = NULL, *routeFound = NULL, *matches, *paths = NULL, *beforeMatch = NULL, *converters = NULL, *converter = NULL, *part = NULL, *position = NULL, *matchPosition = NULL, *strParams, *_1, **_4, **_9, *_10 = NULL, *_12, *_13, *_14, *_15, _17, *_18 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &arguments);
if (!arguments) {
arguments = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(routeFound);
ZVAL_BOOL(routeFound, 0);
ZEPHIR_INIT_VAR(parts);
array_init(parts);
ZEPHIR_INIT_VAR(params);
array_init(params);
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_matchedRoute"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
if (Z_TYPE_P(arguments) != IS_ARRAY) {
_0 = Z_TYPE_P(arguments) != IS_STRING;
if (_0) {
_0 = Z_TYPE_P(arguments) != IS_NULL;
}
if (_0) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Arguments must be an array or string", "phalcon/cli/router.zep", 223);
return;
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC);
zephir_is_iterable(_1, &_3, &_2, 0, 1, "phalcon/cli/router.zep", 323);
for (
; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
; zephir_hash_move_backwards_ex(_3, &_2)
) {
ZEPHIR_GET_HVALUE(route, _4);
ZEPHIR_CALL_METHOD(&pattern, route, "getcompiledpattern", NULL);
zephir_check_call_status();
if (zephir_memnstr_str(pattern, SL("^"), "phalcon/cli/router.zep", 233)) {
Z_SET_ISREF_P(matches);
ZEPHIR_CALL_FUNCTION(&routeFound, "preg_match", &_5, pattern, arguments, matches);
Z_UNSET_ISREF_P(matches);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(routeFound);
ZVAL_BOOL(routeFound, ZEPHIR_IS_EQUAL(pattern, arguments));
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&beforeMatch, route, "getbeforematch", NULL);
zephir_check_call_status();
if (Z_TYPE_P(beforeMatch) != IS_NULL) {
if (!(zephir_is_callable(beforeMatch TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Before-Match callback is not callable in matched route", "phalcon/cli/router.zep", 251);
return;
}
ZEPHIR_INIT_NVAR(routeFound);
ZEPHIR_INIT_NVAR(_6);
zephir_create_array(_6, 3, 0 TSRMLS_CC);
zephir_array_fast_append(_6, arguments);
zephir_array_fast_append(_6, route);
zephir_array_fast_append(_6, this_ptr);
ZEPHIR_CALL_USER_FUNC_ARRAY(routeFound, beforeMatch, _6);
zephir_check_call_status();
}
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&paths, route, "getpaths", NULL);
zephir_check_call_status();
ZEPHIR_CPY_WRT(parts, paths);
if (Z_TYPE_P(matches) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&converters, route, "getconverters", NULL);
zephir_check_call_status();
zephir_is_iterable(paths, &_8, &_7, 0, 0, "phalcon/cli/router.zep", 312);
for (
; zephir_hash_get_current_data_ex(_8, (void**) &_9, &_7) == SUCCESS
; zephir_hash_move_forward_ex(_8, &_7)
) {
ZEPHIR_GET_HMKEY(part, _8, _7);
ZEPHIR_GET_HVALUE(position, _9);
ZEPHIR_OBS_NVAR(matchPosition);
if (zephir_array_isset_fetch(&matchPosition, matches, position, 0 TSRMLS_CC)) {
if (Z_TYPE_P(converters) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(converter);
if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_10);
ZEPHIR_INIT_NVAR(_6);
zephir_create_array(_6, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_6, matchPosition);
ZEPHIR_CALL_USER_FUNC_ARRAY(_10, converter, _6);
zephir_check_call_status();
zephir_array_update_zval(&parts, part, &_10, PH_COPY | PH_SEPARATE);
continue;
}
}
zephir_array_update_zval(&parts, part, &matchPosition, PH_COPY | PH_SEPARATE);
} else {
if (Z_TYPE_P(converters) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(converter);
if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_10);
ZEPHIR_INIT_NVAR(_11);
zephir_create_array(_11, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_11, position);
ZEPHIR_CALL_USER_FUNC_ARRAY(_10, converter, _11);
zephir_check_call_status();
zephir_array_update_zval(&parts, part, &_10, PH_COPY | PH_SEPARATE);
}
}
}
}
zephir_update_property_this(this_ptr, SL("_matches"), matches TSRMLS_CC);
}
zephir_update_property_this(this_ptr, SL("_matchedRoute"), route TSRMLS_CC);
break;
}
}
if (zephir_is_true(routeFound)) {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
_12 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_module"), _12 TSRMLS_CC);
_13 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultTask"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_task"), _13 TSRMLS_CC);
_14 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_action"), _14 TSRMLS_CC);
_15 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultParams"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_params"), _15 TSRMLS_CC);
RETURN_THIS();
}
} else {
ZEPHIR_CPY_WRT(parts, arguments);
}
ZEPHIR_INIT_VAR(moduleName);
ZVAL_NULL(moduleName);
ZEPHIR_INIT_VAR(taskName);
ZVAL_NULL(taskName);
ZEPHIR_INIT_VAR(actionName);
ZVAL_NULL(actionName);
ZEPHIR_OBS_NVAR(moduleName);
if (zephir_array_isset_string_fetch(&moduleName, parts, SS("module"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&parts, SS("module"), PH_SEPARATE);
} else {
ZEPHIR_OBS_NVAR(moduleName);
zephir_read_property_this(&moduleName, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
}
ZEPHIR_OBS_NVAR(taskName);
if (zephir_array_isset_string_fetch(&taskName, parts, SS("task"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&parts, SS("task"), PH_SEPARATE);
} else {
ZEPHIR_OBS_NVAR(taskName);
zephir_read_property_this(&taskName, this_ptr, SL("_defaultTask"), PH_NOISY_CC);
}
ZEPHIR_OBS_NVAR(actionName);
if (zephir_array_isset_string_fetch(&actionName, parts, SS("action"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&parts, SS("action"), PH_SEPARATE);
} else {
ZEPHIR_OBS_NVAR(actionName);
zephir_read_property_this(&actionName, this_ptr, SL("_defaultAction"), PH_NOISY_CC);
}
if (zephir_is_true(routeFound)) {
ZEPHIR_OBS_NVAR(params);
if (zephir_array_isset_string_fetch(¶ms, parts, SS("params"), 0 TSRMLS_CC)) {
if (Z_TYPE_P(params) != IS_ARRAY) {
zephir_get_strval(_16, params);
ZEPHIR_SINIT_VAR(_17);
ZVAL_LONG(&_17, 1);
ZEPHIR_INIT_VAR(strParams);
zephir_substr(strParams, _16, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
if (zephir_is_true(strParams)) {
ZEPHIR_INIT_NVAR(params);
ZEPHIR_CALL_CE_STATIC(&_18, phalcon_cli_router_route_ce, "getdelimiter", &_19);
zephir_check_call_status();
zephir_fast_explode(params, _18, strParams, LONG_MAX TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(params);
array_init(params);
}
}
zephir_array_unset_string(&parts, SS("params"), PH_SEPARATE);
}
if (zephir_fast_count_int(params TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_10);
zephir_fast_array_merge(_10, &(params), &(parts) TSRMLS_CC);
ZEPHIR_CPY_WRT(params, _10);
} else {
ZEPHIR_CPY_WRT(params, parts);
}
} else {
ZEPHIR_CPY_WRT(params, parts);
}
zephir_update_property_this(this_ptr, SL("_module"), moduleName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_task"), taskName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_action"), actionName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_params"), params TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Executes a prepared statement binding. This function uses integer indexes starting from zero
*
*<code>
* $statement = $connection->prepare('SELECT * FROM robots WHERE name = :name');
* $pdoResult = $connection->executePrepared($statement, array('name' => 'Voltron'));
*</code>
*
* @param \PDOStatement $statement
* @param array $placeholders
* @param array $dataTypes
* @return \PDOStatement
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, executePrepared){
zval *statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *z_one, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = NULL;
zval *profiler, *sql_statement;
HashTable *ah0;
HashPosition hp0;
zval **hd;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &statement, &placeholders, &data_types) == FAILURE) {
RETURN_NULL();
}
PHALCON_MM_GROW();
z_one = PHALCON_GLOBAL(z_one);
phalcon_is_iterable(placeholders, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(wildcard, ah0, hp0);
PHALCON_GET_HVALUE(value);
if (Z_TYPE_P(wildcard) == IS_LONG) {
PHALCON_INIT_NVAR(parameter);
phalcon_add_function(parameter, wildcard, z_one);
} else {
if (Z_TYPE_P(wildcard) == IS_STRING) {
PHALCON_CPY_WRT(parameter, wildcard);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
if (Z_TYPE_P(data_types) == IS_ARRAY) {
if (likely(phalcon_array_isset(data_types, wildcard))) {
/**
* The bind type is double so we try to get the double value
*/
PHALCON_OBS_NVAR(type);
phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY);
if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) {
PHALCON_INIT_NVAR(cast_value);
phalcon_cast(cast_value, value, IS_DOUBLE);
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 1024);
} else {
PHALCON_CPY_WRT(cast_value, value);
}
/**
* 1024 is ignore the bind type
*/
Z_SET_ISREF_P(cast_value);
if (phalcon_compare_strict_long(type, 1024 TSRMLS_CC)) {
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, cast_value);
} else {
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, cast_value, type);
}
Z_UNSET_ISREF_P(cast_value);
} else {
PHALCON_INIT_NVAR(type);
if (Z_TYPE_P(value) == IS_LONG) {
ZVAL_LONG(type, 1 /* BIND_PARAM_INT */);
}
else {
ZVAL_LONG(type, 2 /* BIND_PARAM_STR */);
}
Z_SET_ISREF_P(value);
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, value, type);
Z_UNSET_ISREF_P(value);
/*
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter");
return;
*/
}
} else {
Z_SET_ISREF_P(value);
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, value);
Z_UNSET_ISREF_P(value);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
profiler = phalcon_fetch_nproperty_this(this_ptr, SL("_profiler"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(profiler) == IS_OBJECT) {
sql_statement = phalcon_fetch_nproperty_this(this_ptr, SL("_sqlStatement"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(NULL, profiler, "startprofile", sql_statement, placeholders, data_types);
PHALCON_CALL_METHOD(NULL, statement, "execute");
PHALCON_CALL_METHOD(NULL, profiler, "stopprofile");
} else {
PHALCON_CALL_METHOD(NULL, statement, "execute");
}
RETURN_CTOR(statement);
}
PHP_METHOD(Test_RegexDNA, process) {
HashTable *_27;
HashPosition _26;
zval *path, *variants, *vIUB, *vIUBnew, *stuffToRemove, *contents = NULL, *initialLength, *regex = NULL, *codeLength, *discard, *_0, *_1, *_2, *_3, *_4, *_5, *_6, *_7, *_8, *_9, *_10, *_11, *_12, *_13, *_14, *_15, *_16, *_17, *_18, *_19, *_20, *_21, *_22, *_23, _24, *_25 = NULL, **_28, *_29 = NULL, *_30 = NULL, *_31;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &path);
ZEPHIR_INIT_VAR(variants);
array_init(variants);
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "agggtaaa|tttaccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "[cgt]gggtaaa|tttaccc[acg]", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "a[act]ggtaaa|tttacc[agt]t", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "ag[act]gtaaa|tttac[agt]ct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agg[act]taaa|ttta[agt]cct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "aggg[acg]aaa|ttt[cgt]ccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agggt[cgt]aa|tt[acg]accct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agggta[cgt]a|t[acg]taccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "agggtaa[cgt]|[acg]ttaccct", 1);
zephir_array_fast_append(variants, _0);
ZEPHIR_INIT_VAR(vIUB);
array_init(vIUB);
ZEPHIR_INIT_VAR(vIUBnew);
array_init(vIUBnew);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "/B/S", 1);
zephir_array_append(&vIUB, _0, PH_SEPARATE);
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "(c|g|t)", 1);
zephir_array_append(&vIUBnew, _1, PH_SEPARATE);
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "/D/S", 1);
zephir_array_append(&vIUB, _2, PH_SEPARATE);
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, "(a|g|t)", 1);
zephir_array_append(&vIUBnew, _3, PH_SEPARATE);
ZEPHIR_INIT_VAR(_4);
ZVAL_STRING(_4, "/H/S", 1);
zephir_array_append(&vIUB, _4, PH_SEPARATE);
ZEPHIR_INIT_VAR(_5);
ZVAL_STRING(_5, "(a|c|t)", 1);
zephir_array_append(&vIUBnew, _5, PH_SEPARATE);
ZEPHIR_INIT_VAR(_6);
ZVAL_STRING(_6, "/K/S", 1);
zephir_array_append(&vIUB, _6, PH_SEPARATE);
ZEPHIR_INIT_VAR(_7);
ZVAL_STRING(_7, "(g|t)", 1);
zephir_array_append(&vIUBnew, _7, PH_SEPARATE);
ZEPHIR_INIT_VAR(_8);
ZVAL_STRING(_8, "/M/S", 1);
zephir_array_append(&vIUB, _8, PH_SEPARATE);
ZEPHIR_INIT_VAR(_9);
ZVAL_STRING(_9, "(a|c)", 1);
zephir_array_append(&vIUBnew, _9, PH_SEPARATE);
ZEPHIR_INIT_VAR(_10);
ZVAL_STRING(_10, "/N/S", 1);
zephir_array_append(&vIUB, _10, PH_SEPARATE);
ZEPHIR_INIT_VAR(_11);
ZVAL_STRING(_11, "(a|c|g|t)", 1);
zephir_array_append(&vIUBnew, _11, PH_SEPARATE);
ZEPHIR_INIT_VAR(_12);
ZVAL_STRING(_12, "/R/S", 1);
zephir_array_append(&vIUB, _12, PH_SEPARATE);
ZEPHIR_INIT_VAR(_13);
ZVAL_STRING(_13, "(a|g)", 1);
zephir_array_append(&vIUBnew, _13, PH_SEPARATE);
ZEPHIR_INIT_VAR(_14);
ZVAL_STRING(_14, "/S/S", 1);
zephir_array_append(&vIUB, _14, PH_SEPARATE);
ZEPHIR_INIT_VAR(_15);
ZVAL_STRING(_15, "(c|g)", 1);
zephir_array_append(&vIUBnew, _15, PH_SEPARATE);
ZEPHIR_INIT_VAR(_16);
ZVAL_STRING(_16, "/V/S", 1);
zephir_array_append(&vIUB, _16, PH_SEPARATE);
ZEPHIR_INIT_VAR(_17);
ZVAL_STRING(_17, "(a|c|g)", 1);
zephir_array_append(&vIUBnew, _17, PH_SEPARATE);
ZEPHIR_INIT_VAR(_18);
ZVAL_STRING(_18, "/W/S", 1);
zephir_array_append(&vIUB, _18, PH_SEPARATE);
ZEPHIR_INIT_VAR(_19);
ZVAL_STRING(_19, "(a|t)", 1);
zephir_array_append(&vIUBnew, _19, PH_SEPARATE);
ZEPHIR_INIT_VAR(_20);
ZVAL_STRING(_20, "/Y/S", 1);
zephir_array_append(&vIUB, _20, PH_SEPARATE);
ZEPHIR_INIT_VAR(_21);
ZVAL_STRING(_21, "(c|t)", 1);
zephir_array_append(&vIUBnew, _21, PH_SEPARATE);
ZEPHIR_INIT_VAR(stuffToRemove);
ZVAL_STRING(stuffToRemove, "^>.*$|\n", 1);
ZEPHIR_INIT_VAR(discard);
ZVAL_NULL(discard);
ZEPHIR_INIT_VAR(contents);
zephir_call_func_p1(contents, "file_get_contents", path);
ZEPHIR_INIT_VAR(initialLength);
ZVAL_LONG(initialLength, zephir_fast_strlen_ev(contents));
ZEPHIR_INIT_VAR(_22);
ZEPHIR_CONCAT_SV(_22, "/", stuffToRemove);
ZEPHIR_INIT_VAR(_23);
ZEPHIR_CONCAT_VS(_23, _22, "/mS");
ZEPHIR_SINIT_VAR(_24);
ZVAL_STRING(&_24, "", 0);
ZEPHIR_INIT_VAR(_25);
zephir_call_func_p3(_25, "preg_replace", _23, &_24, contents);
ZEPHIR_CPY_WRT(contents, _25);
ZEPHIR_INIT_VAR(codeLength);
ZVAL_LONG(codeLength, zephir_fast_strlen_ev(contents));
zephir_is_iterable(variants, &_27, &_26, 0, 0);
for (
; zend_hash_get_current_data_ex(_27, (void**) &_28, &_26) == SUCCESS
; zend_hash_move_forward_ex(_27, &_26)
) {
ZEPHIR_GET_HVALUE(regex, _28);
zend_print_zval(regex, 0);
php_printf(" ");
ZEPHIR_INIT_LNVAR(_29);
ZEPHIR_CONCAT_SV(_29, "/", regex);
ZEPHIR_INIT_LNVAR(_30);
ZEPHIR_CONCAT_VS(_30, _29, "/iS");
Z_SET_ISREF_P(discard);
ZEPHIR_INIT_NVAR(_25);
zephir_call_func_p3(_25, "preg_match_all", _30, contents, discard);
zend_print_zval(_25, 0);
php_printf("%c", '\n');
}
ZEPHIR_INIT_VAR(_31);
zephir_call_func_p3(_31, "preg_replace", vIUB, vIUBnew, contents);
ZEPHIR_CPY_WRT(contents, _31);
php_printf("%c", '\n');
zend_print_zval(initialLength, 0);
php_printf("%c", '\n');
zend_print_zval(codeLength, 0);
php_printf("%c", '\n');
php_printf("%d", zephir_fast_strlen_ev(contents));
php_printf("%c", '\n');
ZEPHIR_MM_RESTORE();
}
static void
SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject TSRMLS_DC) {
/*
* First test for Null pointers. Return those as PHP native NULL
*/
if (!ptr ) {
ZVAL_NULL(z);
return;
}
if (type->clientdata) {
swig_object_wrapper *value;
if (! (*(int *)(type->clientdata)))
zend_error(E_ERROR, "Type: %s failed to register with zend",type->name);
value=(swig_object_wrapper *)emalloc(sizeof(swig_object_wrapper));
value->ptr=ptr;
value->newobject=(newobject & 1);
if ((newobject & 2) == 0) {
/* Just register the pointer as a resource. */
ZEND_REGISTER_RESOURCE(z, value, *(int *)(type->clientdata));
} else {
/*
* Wrap the resource in an object, the resource will be accessible
* via the "_cPtr" member. This is currently only used by
* directorin typemaps.
*/
zval *resource;
zend_class_entry **ce = NULL;
const char *type_name = type->name+3; /* +3 so: _p_Foo -> Foo */
size_t type_name_len;
int result;
const char * p;
/* Namespace__Foo -> Foo */
/* FIXME: ugly and goes wrong for classes with __ in their names. */
while ((p = strstr(type_name, "__")) != NULL) {
type_name = p + 2;
}
type_name_len = strlen(type_name);
MAKE_STD_ZVAL(resource);
ZEND_REGISTER_RESOURCE(resource, value, *(int *)(type->clientdata));
if (SWIG_PREFIX_LEN > 0) {
char * classname = (char*)emalloc(SWIG_PREFIX_LEN + type_name_len + 1);
strcpy(classname, SWIG_PREFIX);
strcpy(classname + SWIG_PREFIX_LEN, type_name);
result = zend_lookup_class(classname, SWIG_PREFIX_LEN + type_name_len, &ce TSRMLS_CC);
efree(classname);
} else {
result = zend_lookup_class((char *)type_name, type_name_len, &ce TSRMLS_CC);
}
if (result != SUCCESS) {
/* class does not exist */
object_init(z);
} else {
object_init_ex(z, *ce);
}
Z_SET_REFCOUNT_P(z, 1);
Z_SET_ISREF_P(z);
zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval), NULL);
}
return;
}
zend_error(E_ERROR, "Type: %s not registered with zend",type->name);
}
/**
* Converts bound parameters such as :name: or ?1 into PDO bind params ?
*
*<code>
* print_r($connection->convertBoundParams('SELECT * FROM robots WHERE name = :name:', array('Bender')));
*</code>
*
* @param string $sql
* @param array $params
* @return array
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, convertBoundParams){
zval *sql, *params, *query_params, *placeholders;
zval *matches, *set_order, *bind_pattern, *status = NULL;
zval *place_match = NULL, *numeric_place = NULL, *value = NULL, *str_place = NULL;
zval *question, *bound_sql = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &sql, ¶ms);
PHALCON_INIT_VAR(query_params);
array_init(query_params);
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
PHALCON_INIT_VAR(matches);
PHALCON_INIT_VAR(set_order);
ZVAL_LONG(set_order, 2);
PHALCON_INIT_VAR(bind_pattern);
ZVAL_STRING(bind_pattern, "/\\?([0-9]+)|:([a-zA-Z0-9_]+):/", 1);
Z_SET_ISREF_P(matches);
PHALCON_CALL_FUNCTION(&status, "preg_match_all", bind_pattern, sql, matches, set_order);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(status)) {
phalcon_is_iterable(matches, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(place_match);
PHALCON_OBS_NVAR(numeric_place);
phalcon_array_fetch_long(&numeric_place, place_match, 1, PH_NOISY);
if (phalcon_array_isset(params, numeric_place)) {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, params, numeric_place, PH_NOISY);
} else {
if (phalcon_array_isset_long(place_match, 2)) {
PHALCON_OBS_NVAR(str_place);
phalcon_array_fetch_long(&str_place, place_match, 2, PH_NOISY);
if (phalcon_array_isset(params, str_place)) {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, params, str_place, PH_NOISY);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Matched parameter wasn't found in parameters list");
return;
}
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Matched parameter wasn't found in parameters list");
return;
}
}
phalcon_array_append(&placeholders, value, PH_COPY);
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(question);
ZVAL_STRING(question, "?", 1);
PHALCON_CALL_FUNCTION(&bound_sql, "preg_replace", bind_pattern, question, sql);
} else {
PHALCON_CPY_WRT(bound_sql, sql);
}
/**
* Returns an array with the processed SQL and parameters
*/
array_init_size(return_value, 2);
phalcon_array_update_string(&return_value, SL("sql"), bound_sql, PH_COPY);
phalcon_array_update_string(&return_value, SL("params"), placeholders, PH_COPY);
RETURN_MM();
}
