/** * @param \Ouchbase\Entity entity * @param bool concurrent If entity may have concurrent updates * @throws \Ouchbase\Exception\EntityLogicException * @return this */ PHP_METHOD(Ouchbase_Repository, refresh) { zephir_fcall_cache_entry *_12 = NULL, *_14 = NULL, *_15 = NULL; HashTable *_9; HashPosition _8; zval *_4; int ZEPHIR_LAST_CALL_STATUS; zend_bool concurrent; zval *entity = NULL, *concurrent_param = NULL, *_0, *_1 = NULL, *_2, *_3 = NULL, *cas, *data = NULL, *dataWithCas = NULL, *_5 = NULL, *refreshed = NULL, *_6, *property = NULL, *propertyReflection = NULL, *_7 = NULL, **_10, *_11 = NULL, *_13 = NULL, *_16; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &entity, &concurrent_param); ZEPHIR_SEPARATE_PARAM(entity); if (!concurrent_param) { concurrent = 0; } else { concurrent = zephir_get_boolval(concurrent_param); } if (!(zephir_instance_of_ev(entity, ouchbase_entity_ce TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'entity' must be an instance of 'Ouchbase\\Entity'", "", 0); return; } _0 = zephir_fetch_nproperty_this(this_ptr, SL("im"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&_1, _0, "contains", NULL, entity); zephir_check_call_status(); if (!(zephir_is_true(_1))) { ZEPHIR_INIT_VAR(_2); object_init_ex(_2, ouchbase_exception_entitylogicexception_ce); ZEPHIR_INIT_VAR(_3); ZVAL_STRING(_3, "was not persisted", 0); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", NULL, entity, _3); zephir_check_temp_parameter(_3); zephir_check_call_status(); zephir_throw_exception_debug(_2, "ouchbase/Repository.zep", 97 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } if (zephir_instance_of_ev(entity, ouchbase_entityproxy_ce TSRMLS_CC)) { ZEPHIR_CALL_METHOD(&entity, entity, "_getobject", NULL); zephir_check_call_status(); } ZEPHIR_INIT_VAR(_4); array_init_size(_4, 2); ZEPHIR_CALL_METHOD(&_5, entity, "getid", NULL); zephir_check_call_status(); zephir_array_fast_append(_4, _5); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "__getWithCas", 0); ZEPHIR_CALL_METHOD(&dataWithCas, this_ptr, "executewithouttimeouts", NULL, _3, _4); zephir_check_temp_parameter(_3); zephir_check_call_status(); ZEPHIR_OBS_VAR(data); zephir_array_fetch_string(&data, dataWithCas, SL("data"), PH_NOISY TSRMLS_CC); ZEPHIR_OBS_VAR(cas); zephir_array_fetch_string(&cas, dataWithCas, SL("cas"), PH_NOISY TSRMLS_CC); if (!(zephir_is_true(data))) { RETURN_THIS(); } if (!(Z_TYPE_P(data) == IS_ARRAY)) { ZEPHIR_INIT_NVAR(_3); zephir_json_decode(_3, &(_3), data, zephir_get_intval(ZEPHIR_GLOBAL(global_true)) TSRMLS_CC); ZEPHIR_CPY_WRT(data, _3); } ZEPHIR_CALL_METHOD(&refreshed, this_ptr, "toobject", NULL, data); zephir_check_call_status(); _6 = zephir_fetch_nproperty_this(this_ptr, SL("im"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(NULL, _6, "updateoriginaldata", NULL, entity, data); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_5, this_ptr, "getclassreflection", NULL); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_7, _5, "getproperties", NULL); zephir_check_call_status(); zephir_is_iterable(_7, &_9, &_8, 0, 0); for ( ; zephir_hash_get_current_data_ex(_9, (void**) &_10, &_8) == SUCCESS ; zephir_hash_move_forward_ex(_9, &_8) ) { ZEPHIR_GET_HVALUE(property, _10); ZEPHIR_CALL_METHOD(&_11, property, "getname", NULL); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&propertyReflection, this_ptr, "getpropertyreflection", &_12, _11); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_13, propertyReflection, "getvalue", &_14, refreshed); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, propertyReflection, "setvalue", &_15, entity, _13); zephir_check_call_status(); } if (concurrent) { _16 = zephir_fetch_nproperty_this(this_ptr, SL("uow"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(NULL, _16, "persist", NULL, entity, cas); zephir_check_call_status(); } RETURN_THIS(); }
/** * Registers a set of PSR-0 directories for a given prefix, either * appending or prepending to the ones previously set for this prefix. * * @param string $prefix The prefix * @param array|string $paths The PSR-0 root directories * @param bool $prepend Whether to prepend the directories */ PHP_METHOD(Xpl_ClassLoader, add) { zend_bool prepend; zval *prefix, *paths = NULL, *prepend_param = NULL, *firstChar = NULL, *prefixPaths = NULL, _4, _5, *_6, *_7, *_0$$5, *_1$$5, *_2$$6, *_3$$6, *_8$$9, *_9$$10; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 1, &prefix, &paths, &prepend_param); ZEPHIR_SEPARATE_PARAM(paths); if (!prepend_param) { prepend = 0; } else { prepend = zephir_get_boolval(prepend_param); } if (Z_TYPE_P(paths) == IS_STRING) { ZEPHIR_INIT_NVAR(paths); zephir_create_array(paths, 1, 0 TSRMLS_CC); zephir_array_fast_append(paths, paths); } if (Z_TYPE_P(prefix) != IS_STRING) { if (prepend) { ZEPHIR_INIT_VAR(_0$$5); _1$$5 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr0"), PH_NOISY_CC); zephir_fast_array_merge(_0$$5, &(paths), &(_1$$5) TSRMLS_CC); zephir_update_property_this(this_ptr, SL("fallbackDirsPsr0"), _0$$5 TSRMLS_CC); } else { ZEPHIR_INIT_VAR(_2$$6); _3$$6 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr0"), PH_NOISY_CC); zephir_fast_array_merge(_2$$6, &(_3$$6), &(paths) TSRMLS_CC); zephir_update_property_this(this_ptr, SL("fallbackDirsPsr0"), _2$$6 TSRMLS_CC); } RETURN_MM_NULL(); } ZEPHIR_SINIT_VAR(_4); ZVAL_LONG(&_4, 0); ZEPHIR_SINIT_VAR(_5); ZVAL_LONG(&_5, 1); ZEPHIR_INIT_VAR(firstChar); zephir_substr(firstChar, prefix, 0 , 1 , 0); ZEPHIR_OBS_VAR(prefixPaths); _6 = zephir_fetch_nproperty_this(this_ptr, SL("prefixesPsr0"), PH_NOISY_CC); zephir_array_fetch(&_7, _6, firstChar, PH_READONLY, "xpl/classloader.zep", 262 TSRMLS_CC); if (!(zephir_array_isset_fetch(&prefixPaths, _7, prefix, 0 TSRMLS_CC))) { ZEPHIR_CPY_WRT(prefixPaths, paths); } else { if (prepend) { ZEPHIR_INIT_VAR(_8$$9); zephir_fast_array_merge(_8$$9, &(paths), &(prefixPaths) TSRMLS_CC); ZEPHIR_CPY_WRT(prefixPaths, _8$$9); } else { ZEPHIR_INIT_VAR(_9$$10); zephir_fast_array_merge(_9$$10, &(prefixPaths), &(paths) TSRMLS_CC); ZEPHIR_CPY_WRT(prefixPaths, _9$$10); } } zephir_update_property_array_multi(this_ptr, SL("prefixesPsr0"), &prefixPaths TSRMLS_CC, SL("zz"), 2, firstChar, prefix); ZEPHIR_MM_RESTORE(); }
/** * Finds the path to the file where the class is defined. * * @param string $class The name of the class * * @return string|false The path if found, false otherwise */ PHP_METHOD(Xpl_ClassLoader, findFile) { zephir_fcall_cache_entry *_4 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *className_param = NULL, *file = NULL, *_0, _1, *_2, *_3, _5$$5, *_6$$5 = NULL, *_7$$6; zval *className = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &className_param); if (unlikely(Z_TYPE_P(className_param) != IS_STRING && Z_TYPE_P(className_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'className' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(className_param) == IS_STRING)) { zephir_get_strval(className, className_param); } else { ZEPHIR_INIT_VAR(className); ZVAL_EMPTY_STRING(className); } ZEPHIR_INIT_VAR(_0); ZEPHIR_SINIT_VAR(_1); ZVAL_STRING(&_1, "\\", 0); zephir_fast_trim(_0, className, &_1, ZEPHIR_TRIM_LEFT TSRMLS_CC); zephir_get_strval(className, _0); ZEPHIR_OBS_VAR(file); _2 = zephir_fetch_nproperty_this(this_ptr, SL("classMap"), PH_NOISY_CC); if (zephir_array_isset_fetch(&file, _2, className, 0 TSRMLS_CC)) { RETURN_CCTOR(file); } ZEPHIR_INIT_VAR(_3); ZVAL_STRING(_3, ".php", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&file, this_ptr, "findfilewithextension", &_4, 0, className, _3); zephir_check_temp_parameter(_3); zephir_check_call_status(); if (Z_TYPE_P(file) == IS_STRING) { zephir_update_property_array(this_ptr, SL("classMap"), className, file TSRMLS_CC); } else { ZEPHIR_SINIT_VAR(_5$$5); ZVAL_STRING(&_5$$5, "HHVM_VERSION", 0); ZEPHIR_CALL_FUNCTION(&_6$$5, "defined", NULL, 55, &_5$$5); zephir_check_call_status(); if (zephir_is_true(_6$$5)) { ZEPHIR_INIT_VAR(_7$$6); ZVAL_STRING(_7$$6, ".hh", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&file, this_ptr, "findfilewithextension", &_4, 0, className, _7$$6); zephir_check_temp_parameter(_7$$6); zephir_check_call_status(); if (Z_TYPE_P(file) == IS_STRING) { zephir_update_property_array(this_ptr, SL("classMap"), className, file TSRMLS_CC); RETURN_CCTOR(file); } } ZEPHIR_INIT_NVAR(file); ZVAL_BOOL(file, 0); zephir_update_property_array(this_ptr, SL("classMap"), className, file TSRMLS_CC); } RETURN_CCTOR(file); }
/** * Removes padding @a padding_type from @a text * If the function detects that the text was not padded, it will return it unmodified * * @param return_value Result, possibly unpadded * @param text Message to be unpadded * @param mode Encryption mode; unpadding is applied only in CBC or ECB mode * @param block_size Cipher block size * @param padding_type Padding scheme */ PHP_METHOD(Phalcon_Crypt, _cryptUnpadText) { unsigned char _14, _16; zephir_fcall_cache_entry *_6 = NULL, *_9 = NULL, *_11 = NULL; zend_bool _0, _1, _2, _13, _15; long length; int blockSize, paddingType, i, paddingSize = 0, ord, ZEPHIR_LAST_CALL_STATUS; zval *text_param = NULL, *mode_param = NULL, *blockSize_param = NULL, *paddingType_param = NULL, *padding = NULL, *last = NULL, _3 = zval_used_for_init, _4 = zval_used_for_init, *_5 = NULL, _7 = zval_used_for_init, *_8 = NULL, *_10 = NULL, *_12 = NULL; zval *text = NULL, *mode = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 4, 0, &text_param, &mode_param, &blockSize_param, &paddingType_param); zephir_get_strval(text, text_param); if (unlikely(Z_TYPE_P(mode_param) != IS_STRING && Z_TYPE_P(mode_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'mode' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(mode_param) == IS_STRING)) { zephir_get_strval(mode, mode_param); } else { ZEPHIR_INIT_VAR(mode); ZVAL_EMPTY_STRING(mode); } if (unlikely(Z_TYPE_P(blockSize_param) != IS_LONG)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'blockSize' must be a long/integer") TSRMLS_CC); RETURN_MM_NULL(); } blockSize = Z_LVAL_P(blockSize_param); if (unlikely(Z_TYPE_P(paddingType_param) != IS_LONG)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'paddingType' must be a long/integer") TSRMLS_CC); RETURN_MM_NULL(); } paddingType = Z_LVAL_P(paddingType_param); length = zephir_fast_strlen_ev(text); _0 = length > 0; if (_0) { _0 = (zephir_safe_mod_long_long(length, blockSize TSRMLS_CC) == 0); } _1 = _0; if (_1) { _2 = ZEPHIR_IS_STRING(mode, "cbc"); if (!(_2)) { _2 = ZEPHIR_IS_STRING(mode, "ecb"); } _1 = _2; } if (_1) { do { if (paddingType == 1) { ZEPHIR_SINIT_VAR(_3); ZVAL_LONG(&_3, (length - 1)); ZEPHIR_SINIT_VAR(_4); ZVAL_LONG(&_4, 1); ZEPHIR_INIT_VAR(last); zephir_substr(last, text, zephir_get_intval(&_3), 1 , 0); ZEPHIR_CALL_FUNCTION(&_5, "ord", &_6, 130, last); zephir_check_call_status(); ord = zephir_get_intval(_5); if (ord <= blockSize) { paddingSize = ord; ZEPHIR_SINIT_VAR(_7); ZVAL_LONG(&_7, 0); ZEPHIR_CALL_FUNCTION(&_8, "chr", &_9, 128, &_7); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_7); ZVAL_LONG(&_7, (paddingSize - 1)); ZEPHIR_CALL_FUNCTION(&_10, "str_repeat", &_11, 129, _8, &_7); zephir_check_call_status(); ZEPHIR_INIT_VAR(padding); ZEPHIR_CONCAT_VV(padding, _10, last); ZEPHIR_SINIT_NVAR(_7); ZVAL_LONG(&_7, (length - paddingSize)); ZEPHIR_INIT_VAR(_12); zephir_substr(_12, text, zephir_get_intval(&_7), 0, ZEPHIR_SUBSTR_NO_LENGTH); if (!ZEPHIR_IS_EQUAL(_12, padding)) { paddingSize = 0; } } break; } if (paddingType == 2) { ZEPHIR_SINIT_NVAR(_3); ZVAL_LONG(&_3, (length - 1)); ZEPHIR_SINIT_NVAR(_4); ZVAL_LONG(&_4, 1); ZEPHIR_INIT_NVAR(last); zephir_substr(last, text, zephir_get_intval(&_3), 1 , 0); ZEPHIR_CALL_FUNCTION(&_5, "ord", &_6, 130, last); zephir_check_call_status(); ord = zephir_get_intval(_5); if (ord <= blockSize) { paddingSize = ord; ZEPHIR_SINIT_NVAR(_7); ZVAL_LONG(&_7, paddingSize); ZEPHIR_CALL_FUNCTION(&_8, "chr", &_9, 128, &_7); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_7); ZVAL_LONG(&_7, paddingSize); ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_11, 129, _8, &_7); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_7); ZVAL_LONG(&_7, (length - paddingSize)); ZEPHIR_INIT_NVAR(_12); zephir_substr(_12, text, zephir_get_intval(&_7), 0, ZEPHIR_SUBSTR_NO_LENGTH); if (!ZEPHIR_IS_EQUAL(_12, padding)) { paddingSize = 0; } } break; } if (paddingType == 3) { ZEPHIR_SINIT_NVAR(_3); ZVAL_LONG(&_3, (length - 1)); ZEPHIR_SINIT_NVAR(_4); ZVAL_LONG(&_4, 1); ZEPHIR_INIT_NVAR(last); zephir_substr(last, text, zephir_get_intval(&_3), 1 , 0); ZEPHIR_CALL_FUNCTION(&_5, "ord", &_6, 130, last); zephir_check_call_status(); paddingSize = zephir_get_intval(_5); break; } if (paddingType == 4) { i = (length - 1); while (1) { _13 = i > 0; if (_13) { _14 = ZEPHIR_STRING_OFFSET(text, i); _13 = _14 == 0x00; } _15 = _13; if (_15) { _15 = paddingSize < blockSize; } if (!(_15)) { break; } paddingSize++; i--; } _16 = ZEPHIR_STRING_OFFSET(text, i); if (_16 == 0x80) { paddingSize++; } else { paddingSize = 0; } break; } if (paddingType == 5) { i = (length - 1); while (1) { _13 = i >= 0; if (_13) { _14 = ZEPHIR_STRING_OFFSET(text, i); _13 = _14 == 0x00; } _15 = _13; if (_15) { _15 = paddingSize <= blockSize; } if (!(_15)) { break; } paddingSize++; i--; } break; } if (paddingType == 6) { i = (length - 1); while (1) { _13 = i >= 0; if (_13) { _14 = ZEPHIR_STRING_OFFSET(text, i); _13 = _14 == 0x20; } _15 = _13; if (_15) { _15 = paddingSize <= blockSize; } if (!(_15)) { break; } paddingSize++; i--; } break; } break; } while(0); _13 = (paddingSize) ? 1 : 0; if (_13) { _13 = paddingSize <= blockSize; } if (_13) { if (paddingSize < length) { ZEPHIR_SINIT_NVAR(_3); ZVAL_LONG(&_3, 0); ZEPHIR_SINIT_NVAR(_4); ZVAL_LONG(&_4, (length - paddingSize)); zephir_substr(return_value, text, 0 , zephir_get_intval(&_4), 0); RETURN_MM(); } RETURN_MM_STRING("", 1); } else { paddingSize = 0; } } if (!(paddingSize)) { RETURN_CTOR(text); } ZEPHIR_MM_RESTORE(); }
/** * Decrypts an encrypted text * *<code> * echo $crypt->decrypt($encrypted, "decrypt password"); *</code> */ PHP_METHOD(Phalcon_Crypt, decrypt) { zend_bool _3; int ZEPHIR_LAST_CALL_STATUS; zval *text_param = NULL, *key = NULL, *decryptKey = NULL, *ivSize = NULL, *cipher, *mode, *keySize, *length, *blockSize = NULL, *paddingType, *decrypted = NULL, *_0, _1, *_2; zval *text = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &text_param, &key); if (unlikely(Z_TYPE_P(text_param) != IS_STRING && Z_TYPE_P(text_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'text' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(text_param) == IS_STRING)) { zephir_get_strval(text, text_param); } else { ZEPHIR_INIT_VAR(text); ZVAL_EMPTY_STRING(text); } if (!key) { key = ZEPHIR_GLOBAL(global_null); } if (!((zephir_function_exists_ex(SS("mcrypt_get_iv_size") TSRMLS_CC) == SUCCESS))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "mcrypt extension is required", "phalcon/crypt.zep", 356); return; } if (Z_TYPE_P(key) == IS_NULL) { ZEPHIR_OBS_VAR(decryptKey); zephir_read_property_this(&decryptKey, this_ptr, SL("_key"), PH_NOISY_CC); } else { ZEPHIR_CPY_WRT(decryptKey, key); } if (ZEPHIR_IS_EMPTY(decryptKey)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Decryption key cannot be empty", "phalcon/crypt.zep", 366); return; } ZEPHIR_OBS_VAR(cipher); zephir_read_property_this(&cipher, this_ptr, SL("_cipher"), PH_NOISY_CC); ZEPHIR_OBS_VAR(mode); zephir_read_property_this(&mode, this_ptr, SL("_mode"), PH_NOISY_CC); ZEPHIR_CALL_FUNCTION(&ivSize, "mcrypt_get_iv_size", NULL, 131, cipher, mode); zephir_check_call_status(); ZEPHIR_INIT_VAR(keySize); ZVAL_LONG(keySize, zephir_fast_strlen_ev(decryptKey)); if (ZEPHIR_GT(keySize, ivSize)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Size of key is too large for this algorithm", "phalcon/crypt.zep", 375); return; } ZEPHIR_INIT_VAR(length); ZVAL_LONG(length, zephir_fast_strlen_ev(text)); if (ZEPHIR_GT(keySize, length)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Size of IV is larger than text to decrypt", "phalcon/crypt.zep", 380); return; } ZEPHIR_INIT_VAR(_0); zephir_substr(_0, text, zephir_get_intval(ivSize), 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_SINIT_VAR(_1); ZVAL_LONG(&_1, 0); ZEPHIR_INIT_VAR(_2); zephir_substr(_2, text, 0 , zephir_get_intval(ivSize), 0); ZEPHIR_CALL_FUNCTION(&decrypted, "mcrypt_decrypt", NULL, 135, cipher, decryptKey, _0, mode, _2); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&blockSize, "mcrypt_get_block_size", NULL, 133, cipher, mode); zephir_check_call_status(); ZEPHIR_OBS_VAR(paddingType); zephir_read_property_this(&paddingType, this_ptr, SL("_padding"), PH_NOISY_CC); _3 = ZEPHIR_IS_STRING(mode, "cbc"); if (!(_3)) { _3 = ZEPHIR_IS_STRING(mode, "ecb"); } if (_3) { ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_cryptunpadtext", NULL, 0, decrypted, mode, blockSize, paddingType); zephir_check_call_status(); RETURN_MM(); } RETURN_CCTOR(decrypted); }
/** * 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> */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, convertBoundParams) { HashTable *_3$$3; HashPosition _2$$3; int ZEPHIR_LAST_CALL_STATUS, setOrder = 0; zval *params = NULL; zval *sql_param = NULL, *params_param = NULL, *boundSql = NULL, *placeHolders = NULL, *bindPattern = NULL, *matches = NULL, *placeMatch = NULL, *value = NULL, *_0, *_1 = NULL, **_4$$3, *_7$$3, *_5$$4, *_6$$6; zval *sql = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &sql_param, ¶ms_param); if (unlikely(Z_TYPE_P(sql_param) != IS_STRING && Z_TYPE_P(sql_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'sql' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(sql_param) == IS_STRING)) { zephir_get_strval(sql, sql_param); } else { ZEPHIR_INIT_VAR(sql); ZVAL_EMPTY_STRING(sql); } if (!params_param) { ZEPHIR_INIT_VAR(params); array_init(params); } else { zephir_get_arrval(params, params_param); } ZEPHIR_INIT_VAR(placeHolders); array_init(placeHolders); ZEPHIR_INIT_VAR(bindPattern); ZVAL_STRING(bindPattern, "/\\?([0-9]+)|:([a-zA-Z0-9_]+):/", 1); ZEPHIR_INIT_VAR(matches); ZVAL_NULL(matches); setOrder = 2; ZEPHIR_INIT_VAR(_0); ZVAL_LONG(_0, setOrder); ZEPHIR_MAKE_REF(matches); ZEPHIR_CALL_FUNCTION(&_1, "preg_match_all", NULL, 38, bindPattern, sql, matches, _0); ZEPHIR_UNREF(matches); zephir_check_call_status(); if (zephir_is_true(_1)) { zephir_is_iterable(matches, &_3$$3, &_2$$3, 0, 0, "phalcon/db/adapter/pdo.zep", 483); for ( ; zephir_hash_get_current_data_ex(_3$$3, (void**) &_4$$3, &_2$$3) == SUCCESS ; zephir_hash_move_forward_ex(_3$$3, &_2$$3) ) { ZEPHIR_GET_HVALUE(placeMatch, _4$$3); ZEPHIR_OBS_NVAR(value); zephir_array_fetch_long(&_5$$4, placeMatch, 1, PH_READONLY, "phalcon/db/adapter/pdo.zep", 470 TSRMLS_CC); if (!(zephir_array_isset_fetch(&value, params, _5$$4, 0 TSRMLS_CC))) { if (zephir_array_isset_long(placeMatch, 2)) { ZEPHIR_OBS_NVAR(value); zephir_array_fetch_long(&_6$$6, placeMatch, 2, PH_READONLY, "phalcon/db/adapter/pdo.zep", 472 TSRMLS_CC); if (!(zephir_array_isset_fetch(&value, params, _6$$6, 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Matched parameter wasn't found in parameters list", "phalcon/db/adapter/pdo.zep", 473); return; } } else { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Matched parameter wasn't found in parameters list", "phalcon/db/adapter/pdo.zep", 476); return; } } zephir_array_append(&placeHolders, value, PH_SEPARATE, "phalcon/db/adapter/pdo.zep", 480); } ZEPHIR_INIT_VAR(_7$$3); ZVAL_STRING(_7$$3, "?", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_FUNCTION(&boundSql, "preg_replace", NULL, 39, bindPattern, _7$$3, sql); zephir_check_temp_parameter(_7$$3); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(boundSql, sql); } zephir_create_array(return_value, 2, 0 TSRMLS_CC); zephir_array_update_string(&return_value, SL("sql"), &boundSql, PH_COPY | PH_SEPARATE); zephir_array_update_string(&return_value, SL("params"), &placeHolders, PH_COPY | PH_SEPARATE); RETURN_MM(); }
/** * Commits the active transaction in the connection */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, commit) { int ZEPHIR_LAST_CALL_STATUS, transactionLevel = 0; zval *nesting_param = NULL, *pdo = NULL, *eventsManager = NULL, *savepointName = NULL, *_0, *_1$$5, *_2$$6, *_5$$7 = NULL, *_6$$8, *_7$$9; zend_bool nesting, _3$$7, _4$$7; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &nesting_param); if (!nesting_param) { nesting = 1; } else { nesting = zephir_get_boolval(nesting_param); } ZEPHIR_OBS_VAR(pdo); zephir_read_property_this(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC); if (Z_TYPE_P(pdo) != IS_OBJECT) { RETURN_MM_BOOL(0); } ZEPHIR_OBS_VAR(_0); zephir_read_property_this(&_0, this_ptr, SL("_transactionLevel"), PH_NOISY_CC); transactionLevel = zephir_get_intval(_0); if (!(transactionLevel)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "There is no active transaction", "phalcon/db/adapter/pdo.zep", 670); return; } if (transactionLevel == 1) { _1$$5 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC); ZEPHIR_CPY_WRT(eventsManager, _1$$5); if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(_2$$6); ZVAL_STRING(_2$$6, "db:commitTransaction", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _2$$6, this_ptr); zephir_check_temp_parameter(_2$$6); zephir_check_call_status(); } RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC)); ZEPHIR_RETURN_CALL_METHOD(pdo, "commit", NULL, 0); zephir_check_call_status(); RETURN_MM(); } else { _3$$7 = ((transactionLevel) ? 1 : 0); if (_3$$7) { _3$$7 = nesting; } _4$$7 = _3$$7; if (_4$$7) { ZEPHIR_CALL_METHOD(&_5$$7, this_ptr, "isnestedtransactionswithsavepoints", NULL, 0); zephir_check_call_status(); _4$$7 = zephir_is_true(_5$$7); } if (_4$$7) { _6$$8 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC); ZEPHIR_CPY_WRT(eventsManager, _6$$8); ZEPHIR_CALL_METHOD(&savepointName, this_ptr, "getnestedtransactionsavepointname", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(_7$$9); ZVAL_STRING(_7$$9, "db:releaseSavepoint", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _7$$9, this_ptr, savepointName); zephir_check_temp_parameter(_7$$9); zephir_check_call_status(); } RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC)); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "releasesavepoint", NULL, 0, savepointName); zephir_check_call_status(); RETURN_MM(); } } if (transactionLevel > 0) { RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC)); } RETURN_MM_BOOL(0); }
/** * * @param array rawData * <code> * rawData = ["service":"Demo", "method":"demo", "args": <ProtoBuffer>] * </code> * @return <ProtoBuffer> * @throw \Exception * */ PHP_METHOD(PhalconPlus_RPC_Server_AbstractServer, callByObject) { zend_bool _3; zephir_nts_static zephir_fcall_cache_entry *_2 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *rawData_param = NULL, *service = NULL, *method = NULL, *request, *response = NULL, *logId = NULL, *message = NULL, *_0 = NULL, *_1 = NULL, *_4, *_5 = NULL, *_6, *_7 = NULL, *_8 = NULL, *_9, *_10 = NULL; zval *rawData = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &rawData_param); zephir_get_arrval(rawData, rawData_param); ZEPHIR_INIT_VAR(logId); ZVAL_STRING(logId, "", 1); ZEPHIR_INIT_VAR(message); ZVAL_STRING(message, "", 1); ZEPHIR_OBS_VAR(service); if (!(zephir_array_isset_string_fetch(&service, rawData, SS("service"), 0 TSRMLS_CC))) { ZEPHIR_INIT_VAR(_0); object_init_ex(_0, zend_exception_get_default(TSRMLS_C)); ZEPHIR_INIT_VAR(_1); ZEPHIR_CONCAT_SVS(_1, "service ", service, " not exists"); ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_2, _1); zephir_check_call_status(); zephir_throw_exception_debug(_0, "phalconplus/RPC/Server/AbstractServer.zep", 78 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_OBS_VAR(method); if (!(zephir_array_isset_string_fetch(&method, rawData, SS("method"), 0 TSRMLS_CC))) { ZEPHIR_INIT_NVAR(_0); object_init_ex(_0, zend_exception_get_default(TSRMLS_C)); ZEPHIR_INIT_LNVAR(_1); ZEPHIR_CONCAT_SVS(_1, "method ", method, " not exists"); ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_2, _1); zephir_check_call_status(); zephir_throw_exception_debug(_0, "phalconplus/RPC/Server/AbstractServer.zep", 82 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_OBS_VAR(request); if (!(zephir_array_isset_string_fetch(&request, rawData, SS("args"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_exception_get_default(TSRMLS_C), "args not exists", "phalconplus/RPC/Server/AbstractServer.zep", 86); return; } ZEPHIR_INIT_NVAR(_0); zephir_fast_trim(_0, service, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC); ZEPHIR_CPY_WRT(service, _0); ZEPHIR_INIT_NVAR(_0); zephir_fast_trim(_0, method, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC); ZEPHIR_CPY_WRT(method, _0); _3 = ZEPHIR_IS_EMPTY(service); if (!(_3)) { _3 = ZEPHIR_IS_EMPTY(method); } if (_3) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_exception_get_default(TSRMLS_C), "service:method(args) must exists. All of them!!!", "phalconplus/RPC/Server/AbstractServer.zep", 93); return; } ZEPHIR_OBS_NVAR(logId); if (zephir_array_isset_string_fetch(&logId, rawData, SS("logId"), 0 TSRMLS_CC)) { } _4 = zephir_fetch_nproperty_this(this_ptr, SL("di"), PH_NOISY_CC); ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "logger", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_5, _4, "has", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (zephir_is_true(_5)) { ZEPHIR_INIT_NVAR(_0); zephir_json_encode(_0, &(_0), request, 0 TSRMLS_CC); ZEPHIR_INIT_NVAR(message); ZEPHIR_CONCAT_SVSVSVSV(message, "RPC Request - logId: ", logId, ", invoke: ", service, "::", method, ", args: ", _0); _6 = zephir_fetch_nproperty_this(this_ptr, SL("di"), PH_NOISY_CC); ZEPHIR_INIT_VAR(_8); ZVAL_STRING(_8, "logger", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_7, _6, "get", NULL, _8); zephir_check_temp_parameter(_8); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, _7, "log", NULL, message); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&response, this_ptr, "callbyparams", NULL, service, method, request, rawData); zephir_check_call_status(); _6 = zephir_fetch_nproperty_this(this_ptr, SL("di"), PH_NOISY_CC); ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "logger", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_7, _6, "has", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (zephir_is_true(_7)) { ZEPHIR_INIT_NVAR(_0); zephir_json_encode(_0, &(_0), response, 0 TSRMLS_CC); ZEPHIR_INIT_NVAR(message); ZEPHIR_CONCAT_SVSVSVSV(message, "RPC Response - logId: ", logId, ", invoke: ", service, "::", method, ", response: ", _0); _9 = zephir_fetch_nproperty_this(this_ptr, SL("di"), PH_NOISY_CC); ZEPHIR_INIT_NVAR(_8); ZVAL_STRING(_8, "logger", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_10, _9, "get", NULL, _8); zephir_check_temp_parameter(_8); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, _10, "log", NULL, message); zephir_check_call_status(); } RETURN_CCTOR(response); }
PHP_METHOD(PhalconPlus_RPC_Server_AbstractServer, callByParams) { zend_class_entry *_10, *_17; zephir_nts_static zephir_fcall_cache_entry *_5 = NULL, *_7 = NULL, *_13 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *_3 = NULL, *_18, *_19; zend_bool _2; zval *service_param = NULL, *method_param = NULL, *request = NULL, *rawData, *serviceClass = NULL, *_0 = NULL, *_1, *tmp = NULL, *param, *paramClass = NULL, *_4 = NULL, *_6 = NULL, *_8 = NULL, *_9 = NULL, *_11 = NULL, *_12 = NULL, *_14, *_15, *serviceObj, *response = NULL, *e = NULL, *_16 = NULL, *_20; zval *service = NULL, *method = NULL, *_21; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 4, 0, &service_param, &method_param, &request, &rawData); if (unlikely(Z_TYPE_P(service_param) != IS_STRING && Z_TYPE_P(service_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'service' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(service_param) == IS_STRING)) { zephir_get_strval(service, service_param); } else { ZEPHIR_INIT_VAR(service); ZVAL_EMPTY_STRING(service); } if (unlikely(Z_TYPE_P(method_param) != IS_STRING && Z_TYPE_P(method_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'method' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(method_param) == IS_STRING)) { zephir_get_strval(method, method_param); } else { ZEPHIR_INIT_VAR(method); ZVAL_EMPTY_STRING(method); } ZEPHIR_INIT_VAR(serviceClass); ZVAL_STRING(serviceClass, "", 1); ZEPHIR_INIT_VAR(tmp); array_init(tmp); ZEPHIR_INIT_VAR(_1); zephir_ucfirst(_1, service); ZEPHIR_INIT_NVAR(serviceClass); ZEPHIR_CONCAT_VS(serviceClass, _1, "Service"); _2 = Z_TYPE_P(request) == IS_OBJECT; if (_2) { _2 = zephir_instance_of_ev(request, phalconplus_base_protobuffer_ce TSRMLS_CC); } if (_2) { zephir_update_property_this(this_ptr, SL("phpOnly"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } else if (Z_TYPE_P(request) == IS_ARRAY) { ZEPHIR_CPY_WRT(tmp, request); ZEPHIR_INIT_VAR(param); object_init_ex(param, zephir_get_internal_ce(SS("reflectionparameter") TSRMLS_CC)); ZEPHIR_INIT_VAR(_3); zephir_create_array(_3, 2, 0 TSRMLS_CC); zephir_array_fast_append(_3, serviceClass); zephir_array_fast_append(_3, method); ZEPHIR_INIT_VAR(_4); ZVAL_LONG(_4, 0); ZEPHIR_CALL_METHOD(NULL, param, "__construct", &_5, _3, _4); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_6, param, "getclass", &_7); zephir_check_call_status(); if (zephir_is_true(_6)) { ZEPHIR_CALL_METHOD(&_8, param, "getclass", &_7); zephir_check_call_status(); ZEPHIR_CALL_METHOD(¶mClass, _8, "getname", NULL); zephir_check_call_status(); ZEPHIR_INIT_NVAR(request); zephir_fetch_safe_class(_9, paramClass); _10 = zend_fetch_class(Z_STRVAL_P(_9), Z_STRLEN_P(_9), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); object_init_ex(request, _10); if (zephir_has_constructor(request TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, request, "__construct", NULL); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(NULL, request, "softclone", NULL, tmp); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(_4); object_init_ex(_4, zend_exception_get_default(TSRMLS_C)); ZEPHIR_INIT_VAR(_11); zephir_json_encode(_11, &(_11), request, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_12); ZEPHIR_CONCAT_SVSVSV(_12, "Service class:method definition is invalid. Detail: ", service, " : ", method, ". Request: ", _11); ZEPHIR_CALL_METHOD(NULL, _4, "__construct", &_13, _12); zephir_check_call_status(); zephir_throw_exception_debug(_4, "phalconplus/RPC/Server/AbstractServer.zep", 36 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } } else { ZEPHIR_INIT_NVAR(_4); object_init_ex(_4, zend_exception_get_default(TSRMLS_C)); ZEPHIR_INIT_NVAR(_11); zephir_json_encode(_11, &(_11), request, 0 TSRMLS_CC); ZEPHIR_INIT_LNVAR(_12); ZEPHIR_CONCAT_SV(_12, "Your input is not allowed. Request: ", _11); ZEPHIR_CALL_METHOD(NULL, _4, "__construct", &_13, _12); zephir_check_call_status(); zephir_throw_exception_debug(_4, "phalconplus/RPC/Server/AbstractServer.zep", 39 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } _14 = zephir_fetch_nproperty_this(this_ptr, SL("di"), PH_NOISY_CC); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "requestCheck", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_6, _14, "has", NULL, _4); zephir_check_temp_parameter(_4); zephir_check_call_status(); if (zephir_is_true(_6)) { _15 = zephir_fetch_nproperty_this(this_ptr, SL("di"), PH_NOISY_CC); ZEPHIR_INIT_NVAR(_3); zephir_create_array(_3, 3, 0 TSRMLS_CC); zephir_array_fast_append(_3, serviceClass); zephir_array_fast_append(_3, method); zephir_array_fast_append(_3, rawData); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "requestCheck", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _15, "get", NULL, _4, _3); zephir_check_temp_parameter(_4); zephir_check_call_status(); } else { ZEPHIR_CALL_METHOD(NULL, this_ptr, "requestcheck", NULL, serviceClass, method, request); zephir_check_call_status(); } ZEPHIR_INIT_VAR(serviceObj); zephir_fetch_safe_class(_16, serviceClass); _17 = zend_fetch_class(Z_STRVAL_P(_16), Z_STRLEN_P(_16), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); object_init_ex(serviceObj, _17); if (zephir_has_constructor(serviceObj TSRMLS_CC)) { _15 = zephir_fetch_nproperty_this(this_ptr, SL("di"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(NULL, serviceObj, "__construct", NULL, _15); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_3); zephir_create_array(_3, 2, 0 TSRMLS_CC); zephir_array_fast_append(_3, serviceObj); zephir_array_fast_append(_3, method); if (zephir_is_callable(_3 TSRMLS_CC)) { /* try_start_1: */ ZEPHIR_INIT_NVAR(_4); ZEPHIR_INIT_VAR(_18); zephir_create_array(_18, 2, 0 TSRMLS_CC); zephir_array_fast_append(_18, serviceObj); zephir_array_fast_append(_18, method); ZEPHIR_INIT_VAR(_19); zephir_create_array(_19, 1, 0 TSRMLS_CC); zephir_array_fast_append(_19, request); ZEPHIR_CALL_USER_FUNC_ARRAY(_4, _18, _19); zephir_check_call_status_or_jump(try_end_1); ZEPHIR_CPY_WRT(response, _4); try_end_1: if (EG(exception)) { ZEPHIR_CPY_WRT(e, EG(exception)); if (zephir_instance_of_ev(e, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); zephir_throw_exception_debug(e, "phalconplus/RPC/Server/AbstractServer.zep", 55 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } } ZEPHIR_INIT_NVAR(_4); _20 = zephir_fetch_nproperty_this(this_ptr, SL("phpOnly"), PH_NOISY_CC); if (ZEPHIR_IS_TRUE(_20)) { ZEPHIR_CPY_WRT(_4, response); } else { ZEPHIR_CALL_METHOD(&_4, response, "toarray", NULL); zephir_check_call_status(); } RETURN_CCTOR(_4); } else { object_init_ex(_4, zend_exception_get_default(TSRMLS_C)); ZEPHIR_INIT_VAR(_21); ZEPHIR_CONCAT_SVSV(_21, "Service:method not found. Detail: ", service, " : ", method); ZEPHIR_CALL_METHOD(NULL, _4, "__construct", &_13, _21); zephir_check_call_status(); zephir_throw_exception_debug(_4, "phalconplus/RPC/Server/AbstractServer.zep", 59 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } }
/** * Generates the SQL for LIMIT clause */ PHP_METHOD(Phalcon_Db_Dialect_Oracle, limit) { int limit = 0, offset; zval *sqlQuery_param = NULL, *number, *_0$$4, *_1$$4, _2$$4, *_3$$3, *_4$$3, _5$$3, *_6$$5, _7$$5, _9$$6, _11$$7; zval *sqlQuery = NULL, *_8, *_10$$6, *_12$$7; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &sqlQuery_param, &number); if (unlikely(Z_TYPE_P(sqlQuery_param) != IS_STRING && Z_TYPE_P(sqlQuery_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'sqlQuery' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(sqlQuery_param) == IS_STRING)) { zephir_get_strval(sqlQuery, sqlQuery_param); } else { ZEPHIR_INIT_VAR(sqlQuery); ZVAL_EMPTY_STRING(sqlQuery); } offset = 0; if (Z_TYPE_P(number) == IS_ARRAY) { if (zephir_array_isset_long(number, 1)) { ZEPHIR_INIT_VAR(_0$$4); zephir_array_fetch_long(&_1$$4, number, 1, PH_NOISY | PH_READONLY, "phalcon/db/dialect/oracle.zep", 51 TSRMLS_CC); ZEPHIR_SINIT_VAR(_2$$4); ZVAL_STRING(&_2$$4, "'", 0); zephir_fast_trim(_0$$4, _1$$4, &_2$$4, ZEPHIR_TRIM_BOTH TSRMLS_CC); offset = zephir_get_intval(_0$$4); } ZEPHIR_INIT_VAR(_3$$3); zephir_array_fetch_long(&_4$$3, number, 0, PH_NOISY | PH_READONLY, "phalcon/db/dialect/oracle.zep", 54 TSRMLS_CC); ZEPHIR_SINIT_VAR(_5$$3); ZVAL_STRING(&_5$$3, "'", 0); zephir_fast_trim(_3$$3, _4$$3, &_5$$3, ZEPHIR_TRIM_BOTH TSRMLS_CC); limit = (zephir_get_intval(_3$$3) + offset); } else { ZEPHIR_INIT_VAR(_6$$5); ZEPHIR_SINIT_VAR(_7$$5); ZVAL_STRING(&_7$$5, "'", 0); zephir_fast_trim(_6$$5, number, &_7$$5, ZEPHIR_TRIM_BOTH TSRMLS_CC); limit = zephir_get_intval(_6$$5); } ZEPHIR_INIT_VAR(_8); ZEPHIR_CONCAT_SVS(_8, "SELECT * FROM (SELECT Z1.*, ROWNUM PHALCON_RN FROM (", sqlQuery, ") Z1"); ZEPHIR_CPY_WRT(sqlQuery, _8); if (limit != 0) { ZEPHIR_SINIT_VAR(_9$$6); ZVAL_LONG(&_9$$6, limit); ZEPHIR_INIT_VAR(_10$$6); ZEPHIR_CONCAT_SV(_10$$6, " WHERE ROWNUM <= ", &_9$$6); zephir_concat_self(&sqlQuery, _10$$6 TSRMLS_CC); } zephir_concat_self_str(&sqlQuery, ")", sizeof(")")-1 TSRMLS_CC); if (offset != 0) { ZEPHIR_SINIT_VAR(_11$$7); ZVAL_LONG(&_11$$7, offset); ZEPHIR_INIT_VAR(_12$$7); ZEPHIR_CONCAT_SV(_12$$7, " WHERE PHALCON_RN >= ", &_11$$7); zephir_concat_self(&sqlQuery, _12$$7 TSRMLS_CC); } RETURN_CTOR(sqlQuery); }
/** * Executes the validation */ PHP_METHOD(Phalcon_Validation_Validator_Digit, validate) { zend_bool _2; int ZEPHIR_LAST_CALL_STATUS; zval *field = NULL; zval *validation, *field_param = NULL, *value = NULL, *message = NULL, *label = NULL, *replacePairs, *_0 = NULL, *_1 = NULL, *_3 = NULL, *_4 = NULL, *_5; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &validation, &field_param); if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(field_param) == IS_STRING)) { zephir_get_strval(field, field_param); } else { ZEPHIR_INIT_VAR(field); ZVAL_EMPTY_STRING(field); } ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field); zephir_check_call_status(); ZEPHIR_INIT_VAR(_1); ZVAL_STRING(_1, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_0, this_ptr, "issetoption", NULL, 0, _1); zephir_check_temp_parameter(_1); zephir_check_call_status(); _2 = zephir_is_true(_0); if (_2) { _2 = ZEPHIR_IS_EMPTY(value); } if (_2) { RETURN_MM_BOOL(1); } ZEPHIR_CALL_FUNCTION(&_3, "ctype_digit", NULL, 434, value); zephir_check_call_status(); if (!(zephir_is_true(_3))) { ZEPHIR_INIT_NVAR(_1); ZVAL_STRING(_1, "label", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _1); zephir_check_temp_parameter(_1); zephir_check_call_status(); if (ZEPHIR_IS_EMPTY(label)) { ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_1); ZVAL_STRING(_1, "message", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _1); zephir_check_temp_parameter(_1); zephir_check_call_status(); ZEPHIR_INIT_VAR(replacePairs); zephir_create_array(replacePairs, 1, 0 TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE); if (ZEPHIR_IS_EMPTY(message)) { ZEPHIR_INIT_NVAR(_1); ZVAL_STRING(_1, "Digit", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _1); zephir_check_temp_parameter(_1); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_1); object_init_ex(_1, phalcon_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_4, "strtr", NULL, 53, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_VAR(_5); ZVAL_STRING(_5, "Digit", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 430, _4, field, _5); zephir_check_temp_parameter(_5); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _1); zephir_check_call_status(); RETURN_MM_BOOL(0); } RETURN_MM_BOOL(1); }
/** * Gets the column name in Oracle */ PHP_METHOD(Phalcon_Db_Dialect_Oracle, getColumnDefinition) { int ZEPHIR_LAST_CALL_STATUS; zval *column, *columnSql = NULL, *size = NULL, *scale = NULL, *type = NULL, *_0$$14, *_1$$14 = NULL, *_2$$14; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &column); ZEPHIR_CALL_METHOD(&type, column, "gettype", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&size, column, "getsize", NULL, 0); zephir_check_call_status(); do { if (ZEPHIR_IS_LONG(type, 0)) { ZEPHIR_INIT_VAR(columnSql); ZVAL_STRING(columnSql, "INTEGER", 1); break; } if (ZEPHIR_IS_LONG(type, 1)) { ZEPHIR_INIT_NVAR(columnSql); ZVAL_STRING(columnSql, "DATE", 1); break; } if (ZEPHIR_IS_LONG(type, 2)) { ZEPHIR_INIT_NVAR(columnSql); ZEPHIR_CONCAT_SVS(columnSql, "VARCHAR2(", size, ")"); break; } if (ZEPHIR_IS_LONG(type, 3)) { ZEPHIR_CALL_METHOD(&scale, column, "getscale", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(columnSql); ZEPHIR_CONCAT_SVSVS(columnSql, "NUMBER(", size, ",", scale, ")"); break; } if (ZEPHIR_IS_LONG(type, 4)) { ZEPHIR_INIT_NVAR(columnSql); ZVAL_STRING(columnSql, "TIMESTAMP", 1); break; } if (ZEPHIR_IS_LONG(type, 17)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("TIMESTAMP") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(type, 5)) { ZEPHIR_INIT_NVAR(columnSql); ZEPHIR_CONCAT_SVS(columnSql, "CHAR(", size, ")"); break; } if (ZEPHIR_IS_LONG(type, 6)) { ZEPHIR_INIT_NVAR(columnSql); ZVAL_STRING(columnSql, "TEXT", 1); break; } if (ZEPHIR_IS_LONG(type, 7)) { ZEPHIR_CALL_METHOD(&scale, column, "getscale", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(columnSql); ZEPHIR_CONCAT_SVSVS(columnSql, "FLOAT(", size, ",", scale, ")"); break; } if (ZEPHIR_IS_LONG(type, 8)) { ZEPHIR_INIT_NVAR(columnSql); ZVAL_STRING(columnSql, "TINYINT(1)", 1); break; } ZEPHIR_INIT_VAR(_0$$14); object_init_ex(_0$$14, phalcon_db_exception_ce); ZEPHIR_CALL_METHOD(&_1$$14, column, "getname", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(_2$$14); ZEPHIR_CONCAT_SV(_2$$14, "Unrecognized Oracle data type at column ", _1$$14); ZEPHIR_CALL_METHOD(NULL, _0$$14, "__construct", NULL, 9, _2$$14); zephir_check_call_status(); zephir_throw_exception_debug(_0$$14, "phalcon/db/dialect/oracle.zep", 131 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } while(0); RETURN_CCTOR(columnSql); }
/** * @todo cas argument is inconsistent here * * @param \Ouchbase\Entity entity * @param string|null cas * @throws \Ouchbase\Exception\EntityLogicException * @throws \Ouchbase\Exception\EntityModifiedException * @return this */ PHP_METHOD(Ouchbase_Repository, update) { zend_class_entry *_8; zval *_5 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *entity = NULL, *cas = NULL, *_0 = NULL, *data = NULL, *originalData = NULL, *_1, *_2 = NULL, *_3 = NULL, *_4, *_6 = NULL, *e = NULL, *_7 = NULL, *ex; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &entity, &cas); ZEPHIR_SEPARATE_PARAM(entity); if (!cas) { cas = ZEPHIR_GLOBAL(global_null); } if (!(zephir_instance_of_ev(entity, ouchbase_entity_ce TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'entity' must be an instance of 'Ouchbase\\Entity'", "", 0); return; } if (zephir_instance_of_ev(entity, ouchbase_entityproxy_ce TSRMLS_CC)) { ZEPHIR_CALL_METHOD(&_0, entity, "isproxied", NULL); zephir_check_call_status(); if (!(zephir_is_true(_0))) { RETURN_THIS(); } ZEPHIR_CALL_METHOD(&entity, entity, "_getobject", NULL); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&data, this_ptr, "toarray", NULL, entity); zephir_check_call_status(); _1 = zephir_fetch_nproperty_this(this_ptr, SL("im"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&originalData, _1, "getoriginaldata", NULL, entity); zephir_check_call_status(); if (!(zephir_is_true(originalData))) { ZEPHIR_INIT_VAR(_2); object_init_ex(_2, ouchbase_exception_entitylogicexception_ce); ZEPHIR_INIT_VAR(_3); ZVAL_STRING(_3, "was not registered in the identity map", 0); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", NULL, entity, _3); zephir_check_temp_parameter(_3); zephir_check_call_status(); zephir_throw_exception_debug(_2, "ouchbase/Repository.zep", 215 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } if (ZEPHIR_IS_EQUAL(data, originalData)) { RETURN_THIS(); } _4 = zephir_fetch_nproperty_this(this_ptr, SL("im"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(NULL, _4, "updateoriginaldata", NULL, entity, data); zephir_check_call_status(); if (!(zephir_is_true(cas))) { ZEPHIR_INIT_VAR(_5); array_init_size(_5, 3); ZEPHIR_CALL_METHOD(&_6, entity, "getid", NULL); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_0, this_ptr, "getkey", NULL, _6); zephir_check_call_status(); zephir_array_fast_append(_5, _0); ZEPHIR_INIT_NVAR(_3); zephir_json_encode(_3, &(_3), data, 0 TSRMLS_CC); zephir_array_fast_append(_5, _3); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "replace", 0); ZEPHIR_CALL_METHOD(NULL, this_ptr, "executewithouttimeouts", NULL, _3, _5); zephir_check_temp_parameter(_3); zephir_check_call_status(); RETURN_THIS(); } /* try_start_1: */ ZEPHIR_INIT_NVAR(_5); array_init_size(_5, 6); ZEPHIR_CALL_METHOD(&_7, entity, "getid", NULL); zephir_check_call_status_or_jump(try_end_1); ZEPHIR_CALL_METHOD(&_6, this_ptr, "getkey", NULL, _7); zephir_check_call_status_or_jump(try_end_1); zephir_array_fast_append(_5, _6); ZEPHIR_INIT_NVAR(_3); zephir_json_encode(_3, &(_3), data, 0 TSRMLS_CC); zephir_array_fast_append(_5, _3); ZEPHIR_INIT_NVAR(_3); ZVAL_LONG(_3, 0); zephir_array_fast_append(_5, _3); zephir_array_fast_append(_5, cas); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "replace", 0); ZEPHIR_CALL_METHOD(&_0, this_ptr, "executewithouttimeouts", NULL, _3, _5); zephir_check_temp_parameter(_3); zephir_check_call_status_or_jump(try_end_1); if (!(zephir_is_true(_0))) { ZEPHIR_INIT_LNVAR(_2); _8 = zend_fetch_class(SL("CouchbaseKeyMutatedException"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); object_init_ex(_2, _8); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", NULL); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(_2, "ouchbase/Repository.zep", 233 TSRMLS_CC); goto try_end_1; } RETURN_THIS(); try_end_1: ZEPHIR_CPY_WRT(e, EG(exception)); if (zephir_is_instance_of(e, SL("CouchbaseKeyMutatedException") TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); ZEPHIR_INIT_VAR(ex); object_init_ex(ex, ouchbase_exception_entitymodifiedexception_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "was modified", 0); ZEPHIR_CALL_METHOD(NULL, ex, "__construct", NULL, entity, _3); zephir_check_temp_parameter(_3); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "update", 0); ZEPHIR_CALL_METHOD(NULL, ex, "setaction", NULL, _3); zephir_check_temp_parameter(_3); zephir_check_call_status(); zephir_throw_exception_debug(ex, "ouchbase/Repository.zep", 242 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } RETURN_THIS(); }
/** * @param array ids * @param bool concurrent Only for entities fetched in this query * @return \Ouchbase\Entity[] */ PHP_METHOD(Ouchbase_Repository, findAll) { zephir_fcall_cache_entry *_7 = NULL; HashTable *_3; HashPosition _2; int ZEPHIR_LAST_CALL_STATUS; zval *_0; zend_bool concurrent; zval *ids, *concurrent_param = NULL, *entity = NULL, *entities, *cas, *data, *dataWithCas = NULL, *id = NULL, *entityData = NULL, *_1 = NULL, **_4, *_5, *_6, *_8, *_9, *_10 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &ids, &concurrent_param); if (!concurrent_param) { concurrent = 0; } else { concurrent = zephir_get_boolval(concurrent_param); } ZEPHIR_INIT_VAR(entities); array_init(entities); ZEPHIR_INIT_VAR(_0); array_init_size(_0, 2); zephir_array_fast_append(_0, ids); ZEPHIR_INIT_VAR(_1); ZVAL_STRING(_1, "__getMultiWithCas", 0); ZEPHIR_CALL_METHOD(&dataWithCas, this_ptr, "executewithouttimeouts", NULL, _1, _0); zephir_check_temp_parameter(_1); zephir_check_call_status(); ZEPHIR_OBS_VAR(data); zephir_array_fetch_string(&data, dataWithCas, SL("data"), PH_NOISY TSRMLS_CC); ZEPHIR_OBS_VAR(cas); zephir_array_fetch_string(&cas, dataWithCas, SL("cas"), PH_NOISY TSRMLS_CC); zephir_is_iterable(data, &_3, &_2, 0, 0); for ( ; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS ; zephir_hash_move_forward_ex(_3, &_2) ) { ZEPHIR_GET_HMKEY(id, _3, _2); ZEPHIR_GET_HVALUE(entityData, _4); _5 = zephir_fetch_nproperty_this(this_ptr, SL("im"), PH_NOISY_CC); _6 = zephir_fetch_nproperty_this(this_ptr, SL("className"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&entity, _5, "getentity", NULL, _6, id); zephir_check_call_status(); if (zephir_is_true(entity)) { zephir_array_append(&entities, entity, PH_SEPARATE); continue; } if (!(Z_TYPE_P(entityData) == IS_ARRAY)) { ZEPHIR_INIT_NVAR(_1); zephir_json_decode(_1, &(_1), entityData, zephir_get_intval(ZEPHIR_GLOBAL(global_true)) TSRMLS_CC); ZEPHIR_CPY_WRT(entityData, _1); } ZEPHIR_CALL_METHOD(&entity, this_ptr, "toobject", &_7, entityData); zephir_check_call_status(); _8 = zephir_fetch_nproperty_this(this_ptr, SL("im"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(NULL, _8, "register", NULL, entity, entityData); zephir_check_call_status(); _9 = zephir_fetch_nproperty_this(this_ptr, SL("uow"), PH_NOISY_CC); ZEPHIR_INIT_LNVAR(_10); if (concurrent) { ZEPHIR_OBS_NVAR(_10); zephir_array_fetch(&_10, cas, id, PH_NOISY TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(_10); ZVAL_NULL(_10); } ZEPHIR_CALL_METHOD(NULL, _9, "persist", NULL, entity, _10); zephir_check_call_status(); zephir_array_append(&entities, entity, PH_SEPARATE); } RETURN_CCTOR(entities); }
/** * Executes a prepared statement binding. This function uses integer indexes starting from zero * *<code> * use Phalcon\Db\Column; * * $statement = $db->prepare('SELECT * FROM robots WHERE name = :name'); * $result = $connection->executePrepared($statement, ['name' => 'Voltron'], ['name' => Column::BIND_PARAM_INT]); *</code> * * @param \PDOStatement statement * @param array placeholders * @param array dataTypes * @return \PDOStatement */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, executePrepared) { zval *_6$$13 = NULL; zend_bool _3$$3; HashTable *_1, *_9$$22, *_14$$28; HashPosition _0, _8$$22, _13$$28; int ZEPHIR_LAST_CALL_STATUS; zephir_fcall_cache_entry *_5 = NULL, *_7 = NULL; zval *placeholders = NULL; zval *statement, *placeholders_param = NULL, *dataTypes, *wildcard = NULL, *value = NULL, *type = NULL, *castValue = NULL, *parameter = NULL, *position = NULL, *itemValue = NULL, **_2, _4$$12 = zval_used_for_init, **_10$$22, *_11$$24 = NULL, *_12$$25 = NULL, **_15$$28, *_16$$29 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 3, 0, &statement, &placeholders_param, &dataTypes); placeholders = placeholders_param; zephir_is_iterable(placeholders, &_1, &_0, 0, 0, "phalcon/db/adapter/pdo.zep", 282); for ( ; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS ; zephir_hash_move_forward_ex(_1, &_0) ) { ZEPHIR_GET_HMKEY(wildcard, _1, _0); ZEPHIR_GET_HVALUE(value, _2); if (Z_TYPE_P(wildcard) == IS_LONG) { ZEPHIR_INIT_NVAR(parameter); ZVAL_LONG(parameter, (zephir_get_numberval(wildcard) + 1)); } else if (Z_TYPE_P(wildcard) == IS_STRING) { ZEPHIR_CPY_WRT(parameter, wildcard); } else { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Invalid bind parameter (1)", "phalcon/db/adapter/pdo.zep", 209); return; } _3$$3 = Z_TYPE_P(dataTypes) == IS_ARRAY; if (_3$$3) { ZEPHIR_OBS_NVAR(type); _3$$3 = zephir_array_isset_fetch(&type, dataTypes, wildcard, 0 TSRMLS_CC); } if (_3$$3) { if (ZEPHIR_IS_LONG(type, 32)) { ZEPHIR_INIT_NVAR(castValue); ZVAL_DOUBLE(castValue, zephir_get_doubleval(value)); ZEPHIR_INIT_NVAR(type); ZVAL_LONG(type, 1024); } else { if (ZEPHIR_GLOBAL(db).force_casting) { if (Z_TYPE_P(value) != IS_ARRAY) { do { if (ZEPHIR_IS_LONG(type, 1)) { ZEPHIR_SINIT_NVAR(_4$$12); ZVAL_LONG(&_4$$12, 10); ZEPHIR_CALL_FUNCTION(&castValue, "intval", &_5, 36, value, &_4$$12); zephir_check_call_status(); break; } if (ZEPHIR_IS_LONG(type, 2)) { zephir_get_strval(_6$$13, value); ZEPHIR_CPY_WRT(castValue, _6$$13); break; } if (ZEPHIR_IS_LONG(type, 0)) { ZEPHIR_INIT_NVAR(castValue); ZVAL_NULL(castValue); break; } if (ZEPHIR_IS_LONG(type, 5)) { ZEPHIR_INIT_NVAR(castValue); ZVAL_BOOL(castValue, zephir_get_boolval(value)); break; } ZEPHIR_CPY_WRT(castValue, value); break; } while(0); } else { ZEPHIR_CPY_WRT(castValue, value); } } else { ZEPHIR_CPY_WRT(castValue, value); } } if (Z_TYPE_P(castValue) != IS_ARRAY) { if (ZEPHIR_IS_LONG(type, 1024)) { ZEPHIR_CALL_METHOD(NULL, statement, "bindvalue", &_7, 0, parameter, castValue); zephir_check_call_status(); } else { ZEPHIR_CALL_METHOD(NULL, statement, "bindvalue", &_7, 0, parameter, castValue, type); zephir_check_call_status(); } } else { zephir_is_iterable(castValue, &_9$$22, &_8$$22, 0, 0, "phalcon/db/adapter/pdo.zep", 270); for ( ; zephir_hash_get_current_data_ex(_9$$22, (void**) &_10$$22, &_8$$22) == SUCCESS ; zephir_hash_move_forward_ex(_9$$22, &_8$$22) ) { ZEPHIR_GET_HMKEY(position, _9$$22, _8$$22); ZEPHIR_GET_HVALUE(itemValue, _10$$22); if (ZEPHIR_IS_LONG(type, 1024)) { ZEPHIR_INIT_LNVAR(_11$$24); ZEPHIR_CONCAT_VV(_11$$24, parameter, position); ZEPHIR_CALL_METHOD(NULL, statement, "bindvalue", &_7, 0, _11$$24, itemValue); zephir_check_call_status(); } else { ZEPHIR_INIT_LNVAR(_12$$25); ZEPHIR_CONCAT_VV(_12$$25, parameter, position); ZEPHIR_CALL_METHOD(NULL, statement, "bindvalue", &_7, 0, _12$$25, itemValue, type); zephir_check_call_status(); } } } } else { if (Z_TYPE_P(value) != IS_ARRAY) { ZEPHIR_CALL_METHOD(NULL, statement, "bindvalue", &_7, 0, parameter, value); zephir_check_call_status(); } else { zephir_is_iterable(value, &_14$$28, &_13$$28, 0, 0, "phalcon/db/adapter/pdo.zep", 278); for ( ; zephir_hash_get_current_data_ex(_14$$28, (void**) &_15$$28, &_13$$28) == SUCCESS ; zephir_hash_move_forward_ex(_14$$28, &_13$$28) ) { ZEPHIR_GET_HMKEY(position, _14$$28, _13$$28); ZEPHIR_GET_HVALUE(itemValue, _15$$28); ZEPHIR_INIT_LNVAR(_16$$29); ZEPHIR_CONCAT_VV(_16$$29, parameter, position); ZEPHIR_CALL_METHOD(NULL, statement, "bindvalue", &_7, 0, _16$$29, itemValue); zephir_check_call_status(); } } } } ZEPHIR_CALL_METHOD(NULL, statement, "execute", NULL, 0); zephir_check_call_status(); RETVAL_ZVAL(statement, 1, 0); RETURN_MM(); }
/** * Transforms an intermediate representation for a expression into a database system valid expression * * @param array expression * @param string escapeChar * @return string */ PHP_METHOD(Pdm_Db_AbstractDialect, getSqlExpression) { zephir_fcall_cache_entry *_10 = NULL; HashTable *_7, *_13; HashPosition _6, _12; int ZEPHIR_LAST_CALL_STATUS; zval *escapeChar = NULL, *_1 = NULL; zval *expression, *escapeChar_param = NULL, *type, *domain, *operator, *left = NULL, *right = NULL, *name = NULL, *sqlItems, *escapedName = NULL, *sqlArguments, *arguments, *argument = NULL, *item = NULL, *_0, *_2, *_3, *_4, *_5 = NULL, **_8, *_9 = NULL, *_11 = NULL, **_14, *_15, *_16; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &expression, &escapeChar_param); if (!escapeChar_param) { ZEPHIR_INIT_VAR(escapeChar); ZVAL_EMPTY_STRING(escapeChar); } else { zephir_get_strval(escapeChar, escapeChar_param); } if (ZEPHIR_GLOBAL(db).escape_identifiers) { if (ZEPHIR_IS_STRING_IDENTICAL(escapeChar, "")) { ZEPHIR_OBS_VAR(_0); zephir_read_property_this(&_0, this_ptr, SL("escapeChar"), PH_NOISY_CC); zephir_get_strval(_1, _0); ZEPHIR_CPY_WRT(escapeChar, _1); } } if (Z_TYPE_P(expression) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "Invalid SQL expression", "pdm/db/abstractdialect.zep", 176); return; } ZEPHIR_OBS_VAR(type); if (!(zephir_array_isset_string_fetch(&type, expression, SS("type"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "Invalid SQL expression", "pdm/db/abstractdialect.zep", 180); return; } if (ZEPHIR_IS_STRING(type, "qualified")) { ZEPHIR_OBS_VAR(name); zephir_array_fetch_string(&name, expression, SL("name"), PH_NOISY TSRMLS_CC); if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_INIT_VAR(escapedName); ZEPHIR_CONCAT_VVV(escapedName, escapeChar, name, escapeChar); } else { ZEPHIR_CPY_WRT(escapedName, name); } ZEPHIR_OBS_VAR(domain); if (zephir_array_isset_string_fetch(&domain, expression, SS("domain"), 0 TSRMLS_CC)) { if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_CONCAT_VVVSV(return_value, escapeChar, domain, escapeChar, ".", escapedName); RETURN_MM(); } else { ZEPHIR_CONCAT_VSV(return_value, domain, ".", escapedName); RETURN_MM(); } } RETURN_CCTOR(escapedName); } if (ZEPHIR_IS_STRING(type, "literal")) { zephir_array_fetch_string(&_2, expression, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC); RETURN_CTOR(_2); } if (ZEPHIR_IS_STRING(type, "binary-op")) { zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&left, this_ptr, "getsqlexpression", NULL, _2, escapeChar); zephir_check_call_status(); zephir_array_fetch_string(&_3, expression, SL("right"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&right, this_ptr, "getsqlexpression", NULL, _3, escapeChar); zephir_check_call_status(); zephir_array_fetch_string(&_4, expression, SL("op"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CONCAT_VSVSV(return_value, left, " ", _4, " ", right); RETURN_MM(); } if (ZEPHIR_IS_STRING(type, "unary-op")) { ZEPHIR_OBS_VAR(operator); zephir_array_fetch_string(&operator, expression, SL("op"), PH_NOISY TSRMLS_CC); ZEPHIR_OBS_NVAR(left); if (zephir_array_isset_string_fetch(&left, expression, SS("left"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", NULL, left, escapeChar); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, _5, operator); RETURN_MM(); } ZEPHIR_OBS_NVAR(right); if (zephir_array_isset_string_fetch(&right, expression, SS("right"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", NULL, right, escapeChar); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, _5, operator); RETURN_MM(); } } if (ZEPHIR_IS_STRING(type, "placeholder")) { zephir_array_fetch_string(&_2, expression, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC); RETURN_CTOR(_2); } if (ZEPHIR_IS_STRING(type, "parentheses")) { zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", NULL, _2, escapeChar); zephir_check_call_status(); ZEPHIR_CONCAT_SVS(return_value, "(", _5, ")"); RETURN_MM(); } if (ZEPHIR_IS_STRING(type, "functionCall")) { ZEPHIR_OBS_NVAR(name); zephir_array_fetch_string(&name, expression, SL("name"), PH_NOISY TSRMLS_CC); ZEPHIR_INIT_VAR(sqlArguments); array_init(sqlArguments); ZEPHIR_OBS_VAR(arguments); if (zephir_array_isset_string_fetch(&arguments, expression, SS("arguments"), 0 TSRMLS_CC)) { zephir_is_iterable(arguments, &_7, &_6, 0, 0); for ( ; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS ; zephir_hash_move_forward_ex(_7, &_6) ) { ZEPHIR_GET_HVALUE(argument, _8); ZEPHIR_CALL_METHOD(&_9, this_ptr, "getsqlexpression", &_10, argument, escapeChar); zephir_check_call_status(); zephir_array_append(&sqlArguments, _9, PH_SEPARATE); } ZEPHIR_INIT_VAR(_11); zephir_fast_join_str(_11, SL(", "), sqlArguments TSRMLS_CC); ZEPHIR_CONCAT_VSVS(return_value, name, "(", _11, ")"); RETURN_MM(); } else { ZEPHIR_CONCAT_VS(return_value, name, "()"); RETURN_MM(); } } if (ZEPHIR_IS_STRING(type, "list")) { ZEPHIR_INIT_VAR(sqlItems); array_init(sqlItems); zephir_array_fetch_long(&_2, expression, 0, PH_NOISY | PH_READONLY TSRMLS_CC); zephir_is_iterable(_2, &_13, &_12, 0, 0); for ( ; zephir_hash_get_current_data_ex(_13, (void**) &_14, &_12) == SUCCESS ; zephir_hash_move_forward_ex(_13, &_12) ) { ZEPHIR_GET_HVALUE(item, _14); ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", &_10, item, escapeChar); zephir_check_call_status(); zephir_array_append(&sqlItems, _5, PH_SEPARATE); } ZEPHIR_INIT_NVAR(_11); zephir_fast_join_str(_11, SL(", "), sqlItems TSRMLS_CC); ZEPHIR_CONCAT_SVS(return_value, "(", _11, ")"); RETURN_MM(); } if (ZEPHIR_IS_STRING(type, "all")) { RETURN_MM_STRING("*", 1); } if (ZEPHIR_IS_STRING(type, "cast")) { zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&left, this_ptr, "getsqlexpression", &_10, _2, escapeChar); zephir_check_call_status(); zephir_array_fetch_string(&_3, expression, SL("right"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&right, this_ptr, "getsqlexpression", &_10, _3, escapeChar); zephir_check_call_status(); ZEPHIR_CONCAT_SVSVS(return_value, "CAST(", left, " AS ", right, ")"); RETURN_MM(); } if (ZEPHIR_IS_STRING(type, "convert")) { zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&left, this_ptr, "getsqlexpression", &_10, _2, escapeChar); zephir_check_call_status(); zephir_array_fetch_string(&_3, expression, SL("right"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&right, this_ptr, "getsqlexpression", &_10, _3, escapeChar); zephir_check_call_status(); ZEPHIR_CONCAT_SVSVS(return_value, "CONVERT(", left, " USING ", right, ")"); RETURN_MM(); } ZEPHIR_INIT_VAR(_15); object_init_ex(_15, pdm_db_exception_ce); ZEPHIR_INIT_VAR(_16); ZEPHIR_CONCAT_SVS(_16, "Invalid SQL expression type '", type, "'"); ZEPHIR_CALL_METHOD(NULL, _15, "__construct", NULL, _16); zephir_check_call_status(); zephir_throw_exception_debug(_15, "pdm/db/abstractdialect.zep", 287 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; }
/** * Sends SQL statements to the database server returning the success state. * Use this method only when the SQL statement sent to the server doesn't return any rows * *<code> * //Inserting data * $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')"); * $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy')); *</code> */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, execute) { int ZEPHIR_LAST_CALL_STATUS; zval *sqlStatement_param = NULL, *bindParams = NULL, *bindTypes = NULL, *eventsManager = NULL, *affectedRows = NULL, *pdo = NULL, *newStatement = NULL, *statement = NULL, *_0, *_1$$3 = NULL, *_2$$3, *_3$$9; zval *sqlStatement = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 2, &sqlStatement_param, &bindParams, &bindTypes); if (unlikely(Z_TYPE_P(sqlStatement_param) != IS_STRING && Z_TYPE_P(sqlStatement_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'sqlStatement' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(sqlStatement_param) == IS_STRING)) { zephir_get_strval(sqlStatement, sqlStatement_param); } else { ZEPHIR_INIT_VAR(sqlStatement); ZVAL_EMPTY_STRING(sqlStatement); } if (!bindParams) { bindParams = ZEPHIR_GLOBAL(global_null); } if (!bindTypes) { bindTypes = ZEPHIR_GLOBAL(global_null); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC); ZEPHIR_CPY_WRT(eventsManager, _0); if (Z_TYPE_P(eventsManager) == IS_OBJECT) { zephir_update_property_this(this_ptr, SL("_sqlStatement"), sqlStatement TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_sqlVariables"), bindParams TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_sqlBindTypes"), bindTypes TSRMLS_CC); ZEPHIR_INIT_VAR(_2$$3); ZVAL_STRING(_2$$3, "db:beforeQuery", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_1$$3, eventsManager, "fire", NULL, 0, _2$$3, this_ptr); zephir_check_temp_parameter(_2$$3); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(_1$$3)) { RETURN_MM_BOOL(0); } } ZEPHIR_INIT_VAR(affectedRows); ZVAL_LONG(affectedRows, 0); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_pdo"), PH_NOISY_CC); ZEPHIR_CPY_WRT(pdo, _0); if (Z_TYPE_P(bindParams) == IS_ARRAY) { ZEPHIR_CALL_METHOD(&statement, pdo, "prepare", NULL, 0, sqlStatement); zephir_check_call_status(); if (Z_TYPE_P(statement) == IS_OBJECT) { ZEPHIR_CALL_METHOD(&newStatement, this_ptr, "executeprepared", NULL, 0, statement, bindParams, bindTypes); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&affectedRows, newStatement, "rowcount", NULL, 0); zephir_check_call_status(); } } else { ZEPHIR_CALL_METHOD(&affectedRows, pdo, "exec", NULL, 0, sqlStatement); zephir_check_call_status(); } if (Z_TYPE_P(affectedRows) == IS_LONG) { zephir_update_property_this(this_ptr, SL("_affectedRows"), affectedRows TSRMLS_CC); if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(_3$$9); ZVAL_STRING(_3$$9, "db:afterQuery", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _3$$9, this_ptr); zephir_check_temp_parameter(_3$$9); zephir_check_call_status(); } } RETURN_MM_BOOL(1); }
/** * Transform an intermediate representation for a schema/table into a database system valid expression * * @param array table * @param string escapeChar * @return string */ PHP_METHOD(Pdm_Db_AbstractDialect, getSqlTable) { zval *escapeChar = NULL, *_1 = NULL; zval *table, *escapeChar_param = NULL, *sqlTable = NULL, *sqlSchema = NULL, *aliasName, *sqlTableAlias = NULL, *schemaName, *tableName, *_0; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &table, &escapeChar_param); if (!escapeChar_param) { ZEPHIR_INIT_VAR(escapeChar); ZVAL_EMPTY_STRING(escapeChar); } else { zephir_get_strval(escapeChar, escapeChar_param); } if (ZEPHIR_IS_STRING_IDENTICAL(escapeChar, "")) { ZEPHIR_OBS_VAR(_0); zephir_read_property_this(&_0, this_ptr, SL("escapeChar"), PH_NOISY_CC); zephir_get_strval(_1, _0); ZEPHIR_CPY_WRT(escapeChar, _1); } if (Z_TYPE_P(table) == IS_ARRAY) { ZEPHIR_OBS_VAR(tableName); zephir_array_fetch_long(&tableName, table, 0, PH_NOISY TSRMLS_CC); if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_INIT_VAR(sqlTable); ZEPHIR_CONCAT_VVV(sqlTable, escapeChar, tableName, escapeChar); } else { ZEPHIR_CPY_WRT(sqlTable, tableName); } ZEPHIR_OBS_VAR(schemaName); zephir_array_fetch_long(&schemaName, table, 1, PH_NOISY TSRMLS_CC); if (Z_TYPE_P(schemaName) != IS_ARRAY) { ZEPHIR_INIT_VAR(sqlSchema); if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_CONCAT_VVVSV(sqlSchema, escapeChar, schemaName, escapeChar, ".", sqlTable); } else { ZEPHIR_CONCAT_VSV(sqlSchema, schemaName, ".", sqlTable); } } else { ZEPHIR_CPY_WRT(sqlSchema, sqlTable); } ZEPHIR_OBS_VAR(aliasName); if (zephir_array_isset_long_fetch(&aliasName, table, 2, 0 TSRMLS_CC)) { ZEPHIR_INIT_VAR(sqlTableAlias); if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_CONCAT_VSVVV(sqlTableAlias, sqlSchema, " AS ", escapeChar, aliasName, escapeChar); } else { ZEPHIR_CONCAT_VSV(sqlTableAlias, sqlSchema, " AS ", aliasName); } } else { ZEPHIR_CPY_WRT(sqlTableAlias, sqlSchema); } RETURN_CCTOR(sqlTableAlias); } if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_CONCAT_VVV(return_value, escapeChar, table, escapeChar); RETURN_MM(); } RETURN_CCTOR(table); }
/** * Starts a transaction in the connection */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, begin) { int ZEPHIR_LAST_CALL_STATUS, transactionLevel = 0; zval *nesting_param = NULL, *pdo = NULL, *eventsManager = NULL, *savepointName = NULL, *_0, *_1$$4, *_2$$5, *_5$$6 = NULL, *_6$$7, *_7$$8; zend_bool nesting, _3$$6, _4$$6; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &nesting_param); if (!nesting_param) { nesting = 1; } else { nesting = zephir_get_boolval(nesting_param); } ZEPHIR_OBS_VAR(pdo); zephir_read_property_this(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC); if (Z_TYPE_P(pdo) != IS_OBJECT) { RETURN_MM_BOOL(0); } RETURN_ON_FAILURE(zephir_property_incr(this_ptr, SL("_transactionLevel") TSRMLS_CC)); ZEPHIR_OBS_VAR(_0); zephir_read_property_this(&_0, this_ptr, SL("_transactionLevel"), PH_NOISY_CC); transactionLevel = zephir_get_intval(_0); if (transactionLevel == 1) { _1$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC); ZEPHIR_CPY_WRT(eventsManager, _1$$4); if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(_2$$5); ZVAL_STRING(_2$$5, "db:beginTransaction", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _2$$5, this_ptr); zephir_check_temp_parameter(_2$$5); zephir_check_call_status(); } ZEPHIR_RETURN_CALL_METHOD(pdo, "begintransaction", NULL, 0); zephir_check_call_status(); RETURN_MM(); } else { _3$$6 = ((transactionLevel) ? 1 : 0); if (_3$$6) { _3$$6 = nesting; } _4$$6 = _3$$6; if (_4$$6) { ZEPHIR_CALL_METHOD(&_5$$6, this_ptr, "isnestedtransactionswithsavepoints", NULL, 0); zephir_check_call_status(); _4$$6 = zephir_is_true(_5$$6); } if (_4$$6) { _6$$7 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC); ZEPHIR_CPY_WRT(eventsManager, _6$$7); ZEPHIR_CALL_METHOD(&savepointName, this_ptr, "getnestedtransactionsavepointname", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(_7$$8); ZVAL_STRING(_7$$8, "db:createSavepoint", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _7$$8, this_ptr, savepointName); zephir_check_temp_parameter(_7$$8); zephir_check_call_status(); } ZEPHIR_RETURN_CALL_METHOD(this_ptr, "createsavepoint", NULL, 0, savepointName); zephir_check_call_status(); RETURN_MM(); } } RETURN_MM_BOOL(0); }
/** * Builds a SELECT statement * * @param array definition * @return string */ PHP_METHOD(Pdm_Db_AbstractDialect, select) { zephir_fcall_cache_entry *_4 = NULL, *_9 = NULL; int ZEPHIR_LAST_CALL_STATUS; HashTable *_2, *_6, *_11, *_16, *_22, *_26; HashPosition _1, _5, _10, _15, _21, _25; zval *definition, *tables, *columns = NULL, *escapeChar = NULL, *columnItem = NULL, *column = NULL, *selectedColumns, *columnSql = NULL, *columnDomainSql = NULL, *columnAlias = NULL, *selectedTables, *sqlJoin = NULL, *joinExpressions = NULL, *joinCondition = NULL, *joinConditionsArray = NULL, *tablesSql = NULL, *columnDomain = NULL, *columnAliasSql = NULL, *columnsSql = NULL, *table = NULL, *sql, *joins, *join = NULL, *sqlTable = NULL, *whereConditions, *groupFields, *groupField = NULL, *groupItems, *havingConditions, *orderFields, *orderItem = NULL, *orderItems, *orderSqlItem = NULL, *sqlOrderType = NULL, *orderSqlItemType = NULL, *limitValue, *number, *offset, *_0, **_3, **_7, *_8 = NULL, **_12, *_13, *_14, **_17, *_18 = NULL, *_19 = NULL, *_20 = NULL, **_23, *_24 = NULL, **_27, *_28, *_29; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &definition); if (Z_TYPE_P(definition) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "Invalid SELECT definition", "pdm/db/abstractdialect.zep", 375); return; } ZEPHIR_OBS_VAR(tables); if (!(zephir_array_isset_string_fetch(&tables, definition, SS("tables"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "The index 'tables' is required in the definition array", "pdm/db/abstractdialect.zep", 379); return; } ZEPHIR_OBS_VAR(columns); if (!(zephir_array_isset_string_fetch(&columns, definition, SS("columns"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "The index 'columns' is required in the definition array", "pdm/db/abstractdialect.zep", 383); return; } if (ZEPHIR_GLOBAL(db).escape_identifiers) { _0 = zephir_fetch_nproperty_this(this_ptr, SL("escapeChar"), PH_NOISY_CC); ZEPHIR_CPY_WRT(escapeChar, _0); } else { ZEPHIR_INIT_VAR(escapeChar); ZVAL_NULL(escapeChar); } ZEPHIR_OBS_NVAR(columns); zephir_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY TSRMLS_CC); if (Z_TYPE_P(columns) == IS_ARRAY) { ZEPHIR_INIT_VAR(selectedColumns); array_init(selectedColumns); zephir_is_iterable(columns, &_2, &_1, 0, 0); for ( ; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS ; zephir_hash_move_forward_ex(_2, &_1) ) { ZEPHIR_GET_HVALUE(column, _3); ZEPHIR_OBS_NVAR(columnItem); zephir_array_fetch_long(&columnItem, column, 0, PH_NOISY TSRMLS_CC); if (Z_TYPE_P(columnItem) == IS_ARRAY) { ZEPHIR_CALL_METHOD(&columnSql, this_ptr, "getsqlexpression", &_4, columnItem, escapeChar); zephir_check_call_status(); } else { if (ZEPHIR_IS_STRING(columnItem, "*")) { ZEPHIR_CPY_WRT(columnSql, columnItem); } else { if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_INIT_NVAR(columnSql); ZEPHIR_CONCAT_VVV(columnSql, escapeChar, columnItem, escapeChar); } else { ZEPHIR_CPY_WRT(columnSql, columnItem); } } } ZEPHIR_OBS_NVAR(columnDomain); if (zephir_array_isset_long_fetch(&columnDomain, column, 1, 0 TSRMLS_CC)) { if (zephir_is_true(columnDomain)) { ZEPHIR_INIT_NVAR(columnDomainSql); if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_CONCAT_VVVSV(columnDomainSql, escapeChar, columnDomain, escapeChar, ".", columnSql); } else { ZEPHIR_CONCAT_VSV(columnDomainSql, columnDomain, ".", columnSql); } } else { ZEPHIR_CPY_WRT(columnDomainSql, columnSql); } } else { ZEPHIR_CPY_WRT(columnDomainSql, columnSql); } ZEPHIR_OBS_NVAR(columnAlias); if (zephir_array_isset_long_fetch(&columnAlias, column, 2, 0 TSRMLS_CC)) { if (zephir_is_true(columnAlias)) { ZEPHIR_INIT_NVAR(columnAliasSql); if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_CONCAT_VSVVV(columnAliasSql, columnDomainSql, " AS ", escapeChar, columnAlias, escapeChar); } else { ZEPHIR_CONCAT_VSV(columnAliasSql, columnDomainSql, " AS ", columnAlias); } } else { ZEPHIR_CPY_WRT(columnAliasSql, columnDomainSql); } } else { ZEPHIR_CPY_WRT(columnAliasSql, columnDomainSql); } zephir_array_append(&selectedColumns, columnAliasSql, PH_SEPARATE); } ZEPHIR_INIT_VAR(columnsSql); zephir_fast_join_str(columnsSql, SL(", "), selectedColumns TSRMLS_CC); } else { ZEPHIR_CPY_WRT(columnsSql, columns); } if (Z_TYPE_P(tables) == IS_ARRAY) { ZEPHIR_INIT_VAR(selectedTables); array_init(selectedTables); zephir_is_iterable(tables, &_6, &_5, 0, 0); for ( ; zephir_hash_get_current_data_ex(_6, (void**) &_7, &_5) == SUCCESS ; zephir_hash_move_forward_ex(_6, &_5) ) { ZEPHIR_GET_HVALUE(table, _7); ZEPHIR_CALL_METHOD(&_8, this_ptr, "getsqltable", &_9, table, escapeChar); zephir_check_call_status(); zephir_array_append(&selectedTables, _8, PH_SEPARATE); } ZEPHIR_INIT_VAR(tablesSql); zephir_fast_join_str(tablesSql, SL(", "), selectedTables TSRMLS_CC); } else { ZEPHIR_CPY_WRT(tablesSql, tables); } ZEPHIR_INIT_VAR(sql); ZEPHIR_CONCAT_SVSV(sql, "SELECT ", columnsSql, " FROM ", tablesSql); ZEPHIR_OBS_VAR(joins); if (zephir_array_isset_string_fetch(&joins, definition, SS("joins"), 0 TSRMLS_CC)) { zephir_is_iterable(joins, &_11, &_10, 0, 0); for ( ; zephir_hash_get_current_data_ex(_11, (void**) &_12, &_10) == SUCCESS ; zephir_hash_move_forward_ex(_11, &_10) ) { ZEPHIR_GET_HVALUE(join, _12); zephir_array_fetch_string(&_13, join, SL("source"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&sqlTable, this_ptr, "getsqltable", &_9, _13, escapeChar); zephir_check_call_status(); zephir_array_append(&selectedTables, sqlTable, PH_SEPARATE); zephir_array_fetch_string(&_14, join, SL("type"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_INIT_NVAR(sqlJoin); ZEPHIR_CONCAT_SVSV(sqlJoin, " ", _14, " JOIN ", sqlTable); ZEPHIR_OBS_NVAR(joinConditionsArray); if (zephir_array_isset_string_fetch(&joinConditionsArray, join, SS("conditions"), 0 TSRMLS_CC)) { if (zephir_fast_count_int(joinConditionsArray TSRMLS_CC)) { ZEPHIR_INIT_NVAR(joinExpressions); array_init(joinExpressions); zephir_is_iterable(joinConditionsArray, &_16, &_15, 0, 0); for ( ; zephir_hash_get_current_data_ex(_16, (void**) &_17, &_15) == SUCCESS ; zephir_hash_move_forward_ex(_16, &_15) ) { ZEPHIR_GET_HVALUE(joinCondition, _17); ZEPHIR_CALL_METHOD(&_8, this_ptr, "getsqlexpression", &_4, joinCondition, escapeChar); zephir_check_call_status(); zephir_array_append(&joinExpressions, _8, PH_SEPARATE); } ZEPHIR_INIT_NVAR(_18); zephir_fast_join_str(_18, SL(" AND "), joinExpressions TSRMLS_CC); ZEPHIR_INIT_LNVAR(_19); ZEPHIR_CONCAT_SVS(_19, " ON ", _18, " "); zephir_concat_self(&sqlJoin, _19 TSRMLS_CC); } } zephir_concat_self(&sql, sqlJoin TSRMLS_CC); } } ZEPHIR_OBS_VAR(whereConditions); if (zephir_array_isset_string_fetch(&whereConditions, definition, SS("where"), 0 TSRMLS_CC)) { if (Z_TYPE_P(whereConditions) == IS_ARRAY) { ZEPHIR_CALL_METHOD(&_8, this_ptr, "getsqlexpression", &_4, whereConditions, escapeChar); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_19); ZEPHIR_CONCAT_SV(_19, " WHERE ", _8); zephir_concat_self(&sql, _19 TSRMLS_CC); } else { ZEPHIR_INIT_VAR(_20); ZEPHIR_CONCAT_SV(_20, " WHERE ", whereConditions); zephir_concat_self(&sql, _20 TSRMLS_CC); } } ZEPHIR_OBS_VAR(groupFields); if (zephir_array_isset_string_fetch(&groupFields, definition, SS("group"), 0 TSRMLS_CC)) { ZEPHIR_INIT_VAR(groupItems); array_init(groupItems); zephir_is_iterable(groupFields, &_22, &_21, 0, 0); for ( ; zephir_hash_get_current_data_ex(_22, (void**) &_23, &_21) == SUCCESS ; zephir_hash_move_forward_ex(_22, &_21) ) { ZEPHIR_GET_HVALUE(groupField, _23); ZEPHIR_CALL_METHOD(&_8, this_ptr, "getsqlexpression", &_4, groupField, escapeChar); zephir_check_call_status(); zephir_array_append(&groupItems, _8, PH_SEPARATE); } ZEPHIR_INIT_NVAR(_18); zephir_fast_join_str(_18, SL(", "), groupItems TSRMLS_CC); ZEPHIR_INIT_LNVAR(_20); ZEPHIR_CONCAT_SV(_20, " GROUP BY ", _18); zephir_concat_self(&sql, _20 TSRMLS_CC); ZEPHIR_OBS_VAR(havingConditions); if (zephir_array_isset_string_fetch(&havingConditions, definition, SS("having"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(&_8, this_ptr, "getsqlexpression", &_4, havingConditions, escapeChar); zephir_check_call_status(); ZEPHIR_INIT_VAR(_24); ZEPHIR_CONCAT_SV(_24, " HAVING ", _8); zephir_concat_self(&sql, _24 TSRMLS_CC); } } ZEPHIR_OBS_VAR(orderFields); if (zephir_array_isset_string_fetch(&orderFields, definition, SS("order"), 0 TSRMLS_CC)) { ZEPHIR_INIT_VAR(orderItems); array_init(orderItems); zephir_is_iterable(orderFields, &_26, &_25, 0, 0); for ( ; zephir_hash_get_current_data_ex(_26, (void**) &_27, &_25) == SUCCESS ; zephir_hash_move_forward_ex(_26, &_25) ) { ZEPHIR_GET_HVALUE(orderItem, _27); zephir_array_fetch_long(&_13, orderItem, 0, PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&orderSqlItem, this_ptr, "getsqlexpression", &_4, _13, escapeChar); zephir_check_call_status(); ZEPHIR_OBS_NVAR(sqlOrderType); if (zephir_array_isset_long_fetch(&sqlOrderType, orderItem, 1, 0 TSRMLS_CC)) { ZEPHIR_INIT_NVAR(orderSqlItemType); ZEPHIR_CONCAT_VSV(orderSqlItemType, orderSqlItem, " ", sqlOrderType); } else { ZEPHIR_CPY_WRT(orderSqlItemType, orderSqlItem); } zephir_array_append(&orderItems, orderSqlItemType, PH_SEPARATE); } ZEPHIR_INIT_VAR(_28); zephir_fast_join_str(_28, SL(", "), orderItems TSRMLS_CC); ZEPHIR_INIT_LNVAR(_20); ZEPHIR_CONCAT_SV(_20, " ORDER BY ", _28); zephir_concat_self(&sql, _20 TSRMLS_CC); } if (zephir_array_isset_string_fetch(&limitValue, definition, SS("limit"), 1 TSRMLS_CC)) { if (Z_TYPE_P(limitValue) == IS_ARRAY) { zephir_array_fetch_string(&_13, limitValue, SL("number"), PH_NOISY | PH_READONLY TSRMLS_CC); zephir_array_fetch_string(&number, _13, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC); if (zephir_array_isset_string_fetch(&offset, limitValue, SS("offset"), 1 TSRMLS_CC)) { zephir_array_fetch_string(&_14, offset, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_INIT_LNVAR(_24); ZEPHIR_CONCAT_SVSV(_24, " LIMIT ", number, " OFFSET ", _14); zephir_concat_self(&sql, _24 TSRMLS_CC); } else { ZEPHIR_INIT_VAR(_29); ZEPHIR_CONCAT_SV(_29, " LIMIT ", number); zephir_concat_self(&sql, _29 TSRMLS_CC); } } else { ZEPHIR_INIT_LNVAR(_20); ZEPHIR_CONCAT_SV(_20, " LIMIT ", limitValue); zephir_concat_self(&sql, _20 TSRMLS_CC); } } RETURN_CCTOR(sql); }
/** * Pads texts before encryption * * @see http://www.di-mgt.com.au/cryptopad.html */ PHP_METHOD(Phalcon_Crypt, _cryptPadText) { zephir_fcall_cache_entry *_3 = NULL, *_5 = NULL, *_10 = NULL; zend_bool _0, _7; int blockSize, paddingType, i, paddingSize = 0, ZEPHIR_LAST_CALL_STATUS, _8, _9; zval *text_param = NULL, *mode_param = NULL, *blockSize_param = NULL, *paddingType_param = NULL, *padding = NULL, _1 = zval_used_for_init, *_2 = NULL, *_4 = NULL, *_6 = NULL, _11 = zval_used_for_init, *_12; zval *text = NULL, *mode = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 4, 0, &text_param, &mode_param, &blockSize_param, &paddingType_param); zephir_get_strval(text, text_param); if (unlikely(Z_TYPE_P(mode_param) != IS_STRING && Z_TYPE_P(mode_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'mode' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(mode_param) == IS_STRING)) { zephir_get_strval(mode, mode_param); } else { ZEPHIR_INIT_VAR(mode); ZVAL_EMPTY_STRING(mode); } if (unlikely(Z_TYPE_P(blockSize_param) != IS_LONG)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'blockSize' must be a long/integer") TSRMLS_CC); RETURN_MM_NULL(); } blockSize = Z_LVAL_P(blockSize_param); if (unlikely(Z_TYPE_P(paddingType_param) != IS_LONG)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'paddingType' must be a long/integer") TSRMLS_CC); RETURN_MM_NULL(); } paddingType = Z_LVAL_P(paddingType_param); ZEPHIR_INIT_VAR(padding); ZVAL_NULL(padding); _0 = ZEPHIR_IS_STRING(mode, "cbc"); if (!(_0)) { _0 = ZEPHIR_IS_STRING(mode, "ecb"); } if (_0) { paddingSize = (blockSize - (zephir_safe_mod_long_long(zephir_fast_strlen_ev(text), blockSize TSRMLS_CC))); if (paddingSize >= 256) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Block size is bigger than 256", "phalcon/crypt.zep", 142); return; } do { if (paddingType == 1) { ZEPHIR_SINIT_VAR(_1); ZVAL_LONG(&_1, 0); ZEPHIR_CALL_FUNCTION(&_2, "chr", &_3, 128, &_1); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, (paddingSize - 1)); ZEPHIR_CALL_FUNCTION(&_4, "str_repeat", &_5, 129, _2, &_1); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, paddingSize); ZEPHIR_CALL_FUNCTION(&_6, "chr", &_3, 128, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(padding); ZEPHIR_CONCAT_VV(padding, _4, _6); break; } if (paddingType == 2) { ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, paddingSize); ZEPHIR_CALL_FUNCTION(&_2, "chr", &_3, 128, &_1); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, paddingSize); ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_5, 129, _2, &_1); zephir_check_call_status(); break; } if (paddingType == 3) { ZEPHIR_INIT_NVAR(padding); ZVAL_STRING(padding, "", 1); _9 = (paddingSize - 2); _8 = 0; _7 = 0; if (_8 <= _9) { while (1) { if (_7) { _8++; if (!(_8 <= _9)) { break; } } else { _7 = 1; } i = _8; ZEPHIR_CALL_FUNCTION(&_2, "rand", &_10, 107); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_4, "chr", &_3, 128, _2); zephir_check_call_status(); zephir_concat_self(&padding, _4 TSRMLS_CC); } } ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, paddingSize); ZEPHIR_CALL_FUNCTION(&_6, "chr", &_3, 128, &_1); zephir_check_call_status(); zephir_concat_self(&padding, _6 TSRMLS_CC); break; } if (paddingType == 4) { ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, 0x80); ZEPHIR_CALL_FUNCTION(&_2, "chr", &_3, 128, &_1); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, 0); ZEPHIR_CALL_FUNCTION(&_4, "chr", &_3, 128, &_1); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, (paddingSize - 1)); ZEPHIR_CALL_FUNCTION(&_6, "str_repeat", &_5, 129, _4, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(padding); ZEPHIR_CONCAT_VV(padding, _2, _6); break; } if (paddingType == 5) { ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, 0); ZEPHIR_CALL_FUNCTION(&_2, "chr", &_3, 128, &_1); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, paddingSize); ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_5, 129, _2, &_1); zephir_check_call_status(); break; } if (paddingType == 6) { ZEPHIR_SINIT_NVAR(_1); ZVAL_STRING(&_1, " ", 0); ZEPHIR_SINIT_VAR(_11); ZVAL_LONG(&_11, paddingSize); ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_5, 129, &_1, &_11); zephir_check_call_status(); break; } paddingSize = 0; break; } while(0); } if (!(paddingSize)) { RETURN_CTOR(text); } if (paddingSize > blockSize) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Invalid padding size", "phalcon/crypt.zep", 186); return; } ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, 0); ZEPHIR_SINIT_NVAR(_11); ZVAL_LONG(&_11, paddingSize); ZEPHIR_INIT_VAR(_12); zephir_substr(_12, padding, 0 , zephir_get_intval(&_11), 0); ZEPHIR_CONCAT_VV(return_value, text, _12); RETURN_MM(); }
/** * Helper method for merge configs (forwarding nested config instance) * * @param Config config * @param Config instance = null * * @return Config merged config */ PHP_METHOD(Phalcon_Config, _merge) { zephir_fcall_cache_entry *_8 = NULL, *_9 = NULL; zend_bool _4, _5; HashTable *_2; HashPosition _1; int ZEPHIR_LAST_CALL_STATUS; zval *config, *instance = NULL, *key = NULL, *value = NULL, *number = NULL, *_0 = NULL, **_3, *_6 = NULL, *_7 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &config, &instance); if (!instance) { ZEPHIR_CPY_WRT(instance, ZEPHIR_GLOBAL(global_null)); } else { ZEPHIR_SEPARATE_PARAM(instance); } if (Z_TYPE_P(instance) != IS_OBJECT) { ZEPHIR_CPY_WRT(instance, this_ptr); } ZEPHIR_CALL_METHOD(&number, instance, "count", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_0, "get_object_vars", NULL, 23, config); zephir_check_call_status(); zephir_is_iterable(_0, &_2, &_1, 0, 0, "phalcon/config.zep", 239); for ( ; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS ; zephir_hash_move_forward_ex(_2, &_1) ) { ZEPHIR_GET_HMKEY(key, _2, _1); ZEPHIR_GET_HVALUE(value, _3); _4 = zephir_isset_property_zval(instance, key TSRMLS_CC); if (_4) { _4 = Z_TYPE_P(value) == IS_OBJECT; } _5 = _4; if (_5) { ZEPHIR_OBS_NVAR(_6); zephir_read_property_zval(&_6, instance, key, PH_NOISY_CC); _5 = Z_TYPE_P(_6) == IS_OBJECT; } if (_5) { ZEPHIR_OBS_NVAR(_7); zephir_read_property_zval(&_7, instance, key, PH_NOISY_CC); ZEPHIR_CALL_METHOD(NULL, this_ptr, "_merge", &_8, 22, value, _7); zephir_check_call_status(); } else { if (Z_TYPE_P(key) == IS_LONG) { ZEPHIR_CALL_FUNCTION(&key, "strval", &_9, 20, number); zephir_check_call_status(); ZEPHIR_SEPARATE(number); zephir_increment(number); } zephir_update_property_zval_zval(instance, key, value TSRMLS_CC); } } RETVAL_ZVAL(instance, 1, 0); RETURN_MM(); }
/** * Encrypts a text * *<code> * $encrypted = $crypt->encrypt("Ultra-secret text", "encrypt password"); *</code> */ PHP_METHOD(Phalcon_Crypt, encrypt) { zend_bool _3, _4; int ZEPHIR_LAST_CALL_STATUS, _2; zval *text_param = NULL, *key_param = NULL, *encryptKey = NULL, *ivSize = NULL, *iv = NULL, *cipher, *mode, *blockSize = NULL, *paddingType, *padded = NULL, _0, *_1 = NULL; zval *text = NULL, *key = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &text_param, &key_param); if (unlikely(Z_TYPE_P(text_param) != IS_STRING && Z_TYPE_P(text_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'text' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(text_param) == IS_STRING)) { zephir_get_strval(text, text_param); } else { ZEPHIR_INIT_VAR(text); ZVAL_EMPTY_STRING(text); } if (!key_param) { ZEPHIR_INIT_VAR(key); ZVAL_EMPTY_STRING(key); } else { if (unlikely(Z_TYPE_P(key_param) != IS_STRING && Z_TYPE_P(key_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'key' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(key_param) == IS_STRING)) { zephir_get_strval(key, key_param); } else { ZEPHIR_INIT_VAR(key); ZVAL_EMPTY_STRING(key); } } if (!((zephir_function_exists_ex(SS("mcrypt_get_iv_size") TSRMLS_CC) == SUCCESS))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "mcrypt extension is required", "phalcon/crypt.zep", 302); return; } if (ZEPHIR_IS_STRING_IDENTICAL(key, "")) { ZEPHIR_OBS_VAR(encryptKey); zephir_read_property_this(&encryptKey, this_ptr, SL("_key"), PH_NOISY_CC); } else { ZEPHIR_CPY_WRT(encryptKey, key); } if (ZEPHIR_IS_EMPTY(encryptKey)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Encryption key cannot be empty", "phalcon/crypt.zep", 312); return; } ZEPHIR_OBS_VAR(cipher); zephir_read_property_this(&cipher, this_ptr, SL("_cipher"), PH_NOISY_CC); ZEPHIR_OBS_VAR(mode); zephir_read_property_this(&mode, this_ptr, SL("_mode"), PH_NOISY_CC); ZEPHIR_CALL_FUNCTION(&ivSize, "mcrypt_get_iv_size", NULL, 131, cipher, mode); zephir_check_call_status(); if (ZEPHIR_LT_LONG(ivSize, zephir_fast_strlen_ev(encryptKey))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Size of key is too large for this algorithm", "phalcon/crypt.zep", 320); return; } ZEPHIR_SINIT_VAR(_0); ZVAL_LONG(&_0, 2); ZEPHIR_CALL_FUNCTION(&iv, "mcrypt_create_iv", NULL, 132, ivSize, &_0); zephir_check_call_status(); if (Z_TYPE_P(iv) != IS_STRING) { ZEPHIR_CALL_FUNCTION(&_1, "strval", NULL, 20, iv); zephir_check_call_status(); ZEPHIR_CPY_WRT(iv, _1); } ZEPHIR_CALL_FUNCTION(&blockSize, "mcrypt_get_block_size", NULL, 133, cipher, mode); zephir_check_call_status(); if (Z_TYPE_P(blockSize) != IS_LONG) { _2 = zephir_get_intval(blockSize); ZEPHIR_INIT_NVAR(blockSize); ZVAL_LONG(blockSize, _2); } ZEPHIR_OBS_VAR(paddingType); zephir_read_property_this(&paddingType, this_ptr, SL("_padding"), PH_NOISY_CC); _3 = !ZEPHIR_IS_LONG(paddingType, 0); if (_3) { _4 = ZEPHIR_IS_STRING(mode, "cbc"); if (!(_4)) { _4 = ZEPHIR_IS_STRING(mode, "ecb"); } _3 = _4; } if (_3) { ZEPHIR_CALL_METHOD(&padded, this_ptr, "_cryptpadtext", NULL, 0, text, mode, blockSize, paddingType); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(padded, text); } ZEPHIR_CALL_FUNCTION(&_1, "mcrypt_encrypt", NULL, 134, cipher, encryptKey, padded, mode, iv); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, iv, _1); RETURN_MM(); }
/** * We have to cast values manually because parse_ini_file() has a poor implementation. * * @param mixed ini The array casted by `parse_ini_file` */ PHP_METHOD(Phalcon_Config_Adapter_Ini, _cast) { zend_bool _5$$5, _6$$5, _8$$5, _9$$5; HashTable *_1$$3; HashPosition _0$$3; zephir_fcall_cache_entry *_4 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *ini, *key = NULL, *val = NULL, **_2$$3, *_3$$4 = NULL, *_7$$5, *_10$$5, *_11$$9, *_12$$9, _13$$9; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &ini); ZEPHIR_SEPARATE_PARAM(ini); if (Z_TYPE_P(ini) == IS_ARRAY) { zephir_is_iterable(ini, &_1$$3, &_0$$3, 1, 0, "phalcon/config/adapter/ini.zep", 152); for ( ; zephir_hash_get_current_data_ex(_1$$3, (void**) &_2$$3, &_0$$3) == SUCCESS ; zephir_hash_move_forward_ex(_1$$3, &_0$$3) ) { ZEPHIR_GET_HMKEY(key, _1$$3, _0$$3); ZEPHIR_GET_HVALUE(val, _2$$3); ZEPHIR_CALL_METHOD(&_3$$4, this_ptr, "_cast", &_4, 138, val); zephir_check_call_status(); zephir_array_update_zval(&ini, key, &_3$$4, PH_COPY | PH_SEPARATE); } zend_hash_destroy(_1$$3); FREE_HASHTABLE(_1$$3); } if (Z_TYPE_P(ini) == IS_STRING) { _5$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "true"); if (!(_5$$5)) { _5$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "yes"); } _6$$5 = _5$$5; if (!(_6$$5)) { ZEPHIR_INIT_VAR(_7$$5); zephir_fast_strtolower(_7$$5, ini); _6$$5 = ZEPHIR_IS_STRING_IDENTICAL(_7$$5, "on"); } if (_6$$5) { RETURN_MM_BOOL(1); } _8$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "false"); if (!(_8$$5)) { _8$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "no"); } _9$$5 = _8$$5; if (!(_9$$5)) { ZEPHIR_INIT_VAR(_10$$5); zephir_fast_strtolower(_10$$5, ini); _9$$5 = ZEPHIR_IS_STRING_IDENTICAL(_10$$5, "off"); } if (_9$$5) { RETURN_MM_BOOL(0); } if (ZEPHIR_IS_STRING_IDENTICAL(ini, "null")) { RETURN_MM_NULL(); } if (zephir_is_numeric(ini)) { ZEPHIR_INIT_VAR(_11$$9); ZEPHIR_INIT_VAR(_12$$9); ZEPHIR_SINIT_VAR(_13$$9); ZVAL_STRING(&_13$$9, "/[.]+/", 0); zephir_preg_match(_12$$9, &_13$$9, ini, _11$$9, 0, 0 , 0 TSRMLS_CC); if (zephir_is_true(_12$$9)) { RETURN_MM_DOUBLE(zephir_get_doubleval(ini)); } else { RETURN_MM_LONG(zephir_get_intval(ini)); } } } RETVAL_ZVAL(ini, 1, 0); RETURN_MM(); }
/** * Returns a ClassLoader for the given Composer installation. * * @param string vendorPath * @param boolean prepend [Optional] Default = true * * @return \Xpl\ClassLoader */ PHP_METHOD(Xpl_ClassLoader, composer) { HashTable *_8, *_12, *_18$$10; HashPosition _7, _11, _17$$10; zephir_fcall_cache_entry *_10 = NULL, *_14 = NULL; int ZEPHIR_LAST_CALL_STATUS; zend_bool prepend; zval *vendorPath_param = NULL, *prepend_param = NULL, *composerPath = NULL, *instances = NULL, *loader = NULL, *ns = NULL, *path = NULL, *namespaces = NULL, *psr4 = NULL, *classMap = NULL, *filesPath = NULL, *files = NULL, *_0, _1, *_2, *_3, *_4 = NULL, *_5, *_6, **_9, **_13, *_15, *_16$$10 = NULL, **_19$$10; zval *vendorPath = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &vendorPath_param, &prepend_param); if (unlikely(Z_TYPE_P(vendorPath_param) != IS_STRING && Z_TYPE_P(vendorPath_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'vendorPath' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(vendorPath_param) == IS_STRING)) { zephir_get_strval(vendorPath, vendorPath_param); } else { ZEPHIR_INIT_VAR(vendorPath); ZVAL_EMPTY_STRING(vendorPath); } if (!prepend_param) { prepend = 1; } else { prepend = zephir_get_boolval(prepend_param); } ZEPHIR_INIT_VAR(_0); ZEPHIR_SINIT_VAR(_1); ZVAL_STRING(&_1, "/\\", 0); zephir_fast_trim(_0, vendorPath, &_1, ZEPHIR_TRIM_RIGHT TSRMLS_CC); ZEPHIR_INIT_VAR(_2); ZEPHIR_CONCAT_VS(_2, _0, "/composer"); ZEPHIR_CALL_FUNCTION(&composerPath, "realpath", NULL, 47, _2); zephir_check_call_status(); if (!(zephir_is_true(composerPath))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Composer directory does not exist", "xpl/classloader.zep", 147); return; } zephir_concat_self_str(&composerPath, SL("/") TSRMLS_CC); ZEPHIR_OBS_VAR(instances); zephir_read_static_property_ce(&instances, xpl_classloader_ce, SL("composerInstances") TSRMLS_CC); if (Z_TYPE_P(instances) != IS_NULL) { ZEPHIR_OBS_VAR(loader); if (zephir_array_isset_fetch(&loader, instances, composerPath, 0 TSRMLS_CC)) { RETURN_CCTOR(loader); } } else { ZEPHIR_INIT_NVAR(instances); array_init(instances); } ZEPHIR_INIT_NVAR(loader); object_init_ex(loader, xpl_classloader_ce); if (zephir_has_constructor(loader TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, loader, "__construct", NULL, 0); zephir_check_call_status(); } ZEPHIR_INIT_VAR(_3); ZEPHIR_CONCAT_VS(_3, composerPath, "autoload_namespaces.php"); ZEPHIR_OBSERVE_OR_NULLIFY_PPZV(&_4); if (zephir_require_zval_ret(&_4, _3 TSRMLS_CC) == FAILURE) { RETURN_MM_NULL(); } ZEPHIR_CPY_WRT(namespaces, _4); ZEPHIR_INIT_VAR(_5); ZEPHIR_CONCAT_VS(_5, composerPath, "autoload_psr4.php"); ZEPHIR_OBSERVE_OR_NULLIFY_PPZV(&_4); if (zephir_require_zval_ret(&_4, _5 TSRMLS_CC) == FAILURE) { RETURN_MM_NULL(); } ZEPHIR_CPY_WRT(psr4, _4); ZEPHIR_INIT_VAR(_6); ZEPHIR_CONCAT_VS(_6, composerPath, "autoload_classmap.php"); ZEPHIR_OBSERVE_OR_NULLIFY_PPZV(&_4); if (zephir_require_zval_ret(&_4, _6 TSRMLS_CC) == FAILURE) { RETURN_MM_NULL(); } ZEPHIR_CPY_WRT(classMap, _4); ZEPHIR_INIT_VAR(filesPath); ZEPHIR_CONCAT_VS(filesPath, composerPath, "autoload_files.php"); zephir_is_iterable(namespaces, &_8, &_7, 0, 0, "xpl/classloader.zep", 171); for ( ; zephir_hash_get_current_data_ex(_8, (void**) &_9, &_7) == SUCCESS ; zephir_hash_move_forward_ex(_8, &_7) ) { ZEPHIR_GET_HMKEY(ns, _8, _7); ZEPHIR_GET_HVALUE(path, _9); ZEPHIR_CALL_METHOD(NULL, loader, "set", &_10, 48, ns, path); zephir_check_call_status(); } zephir_is_iterable(psr4, &_12, &_11, 0, 0, "xpl/classloader.zep", 175); for ( ; zephir_hash_get_current_data_ex(_12, (void**) &_13, &_11) == SUCCESS ; zephir_hash_move_forward_ex(_12, &_11) ) { ZEPHIR_GET_HMKEY(ns, _12, _11); ZEPHIR_GET_HVALUE(path, _13); ZEPHIR_CALL_METHOD(NULL, loader, "setpsr4", &_14, 49, ns, path); zephir_check_call_status(); } if (zephir_fast_count_int(classMap TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, loader, "addclassmap", NULL, 50, classMap); zephir_check_call_status(); } ZEPHIR_INIT_VAR(_15); if (prepend) { ZVAL_BOOL(_15, 1); } else { ZVAL_BOOL(_15, 0); } ZEPHIR_CALL_METHOD(NULL, loader, "register", NULL, 51, _15); zephir_check_call_status(); if ((zephir_file_exists(filesPath TSRMLS_CC) == SUCCESS)) { ZEPHIR_OBSERVE_OR_NULLIFY_PPZV(&_16$$10); if (zephir_require_zval_ret(&_16$$10, filesPath TSRMLS_CC) == FAILURE) { RETURN_MM_NULL(); } ZEPHIR_CPY_WRT(files, _16$$10); zephir_is_iterable(files, &_18$$10, &_17$$10, 0, 0, "xpl/classloader.zep", 186); for ( ; zephir_hash_get_current_data_ex(_18$$10, (void**) &_19$$10, &_17$$10) == SUCCESS ; zephir_hash_move_forward_ex(_18$$10, &_17$$10) ) { ZEPHIR_GET_HVALUE(path, _19$$10); if (zephir_require_zval(path TSRMLS_CC) == FAILURE) { RETURN_MM_NULL(); } } } ZEPHIR_CALL_METHOD(NULL, loader, "setcomposerpath", NULL, 52, composerPath); zephir_check_call_status(); zephir_array_update_zval(&instances, composerPath, &loader, PH_COPY | PH_SEPARATE); zephir_update_static_property_ce(xpl_classloader_ce, SL("composerInstances"), &instances TSRMLS_CC); RETURN_CCTOR(loader); }
/** * Phalcon\Config\Adapter\Ini constructor */ PHP_METHOD(Phalcon_Config_Adapter_Ini, __construct) { HashTable *_4, *_7$$6; HashPosition _3, _6$$6; zephir_fcall_cache_entry *_11 = NULL, *_15 = NULL, *_16 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *filePath_param = NULL, *mode = NULL, *iniConfig = NULL, *config = NULL, *section = NULL, *sections = NULL, *directives = NULL, *path = NULL, *lastValue = NULL, **_5, *_0$$4, *_1$$4, *_2$$4, **_8$$6, *_9$$7 = NULL, *_12$$8 = NULL, _13$$8 = zval_used_for_init, *_14$$9 = NULL; zval *filePath = NULL, *_10$$7 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &filePath_param, &mode); if (unlikely(Z_TYPE_P(filePath_param) != IS_STRING && Z_TYPE_P(filePath_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'filePath' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(filePath_param) == IS_STRING)) { zephir_get_strval(filePath, filePath_param); } else { ZEPHIR_INIT_VAR(filePath); ZVAL_EMPTY_STRING(filePath); } if (!mode) { ZEPHIR_CPY_WRT(mode, ZEPHIR_GLOBAL(global_null)); } else { ZEPHIR_SEPARATE_PARAM(mode); } if (Z_TYPE_P(mode) == IS_NULL) { ZEPHIR_INIT_NVAR(mode); ZVAL_LONG(mode, 1); } ZEPHIR_CALL_FUNCTION(&iniConfig, "parse_ini_file", NULL, 136, filePath, ZEPHIR_GLOBAL(global_true), mode); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(iniConfig)) { ZEPHIR_INIT_VAR(_0$$4); object_init_ex(_0$$4, phalcon_config_exception_ce); ZEPHIR_INIT_VAR(_1$$4); zephir_basename(_1$$4, filePath TSRMLS_CC); ZEPHIR_INIT_VAR(_2$$4); ZEPHIR_CONCAT_SVS(_2$$4, "Configuration file ", _1$$4, " can't be loaded"); ZEPHIR_CALL_METHOD(NULL, _0$$4, "__construct", NULL, 9, _2$$4); zephir_check_call_status(); zephir_throw_exception_debug(_0$$4, "phalcon/config/adapter/ini.zep", 85 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_INIT_VAR(config); array_init(config); zephir_is_iterable(iniConfig, &_4, &_3, 0, 0, "phalcon/config/adapter/ini.zep", 106); for ( ; zephir_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS ; zephir_hash_move_forward_ex(_4, &_3) ) { ZEPHIR_GET_HMKEY(section, _4, _3); ZEPHIR_GET_HVALUE(directives, _5); if (Z_TYPE_P(directives) == IS_ARRAY) { ZEPHIR_INIT_NVAR(sections); array_init(sections); zephir_is_iterable(directives, &_7$$6, &_6$$6, 0, 0, "phalcon/config/adapter/ini.zep", 98); for ( ; zephir_hash_get_current_data_ex(_7$$6, (void**) &_8$$6, &_6$$6) == SUCCESS ; zephir_hash_move_forward_ex(_7$$6, &_6$$6) ) { ZEPHIR_GET_HMKEY(path, _7$$6, _6$$6); ZEPHIR_GET_HVALUE(lastValue, _8$$6); zephir_get_strval(_10$$7, path); ZEPHIR_CALL_METHOD(&_9$$7, this_ptr, "_parseinistring", &_11, 0, _10$$7, lastValue); zephir_check_call_status(); zephir_array_append(§ions, _9$$7, PH_SEPARATE, "phalcon/config/adapter/ini.zep", 96); } if (zephir_fast_count_int(sections TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_12$$8); ZEPHIR_SINIT_NVAR(_13$$8); ZVAL_STRING(&_13$$8, "array_merge_recursive", 0); ZEPHIR_CALL_USER_FUNC_ARRAY(_12$$8, &_13$$8, sections); zephir_check_call_status(); zephir_array_update_zval(&config, section, &_12$$8, PH_COPY | PH_SEPARATE); } } else { ZEPHIR_CALL_METHOD(&_14$$9, this_ptr, "_cast", &_15, 0, directives); zephir_check_call_status(); zephir_array_update_zval(&config, section, &_14$$9, PH_COPY | PH_SEPARATE); } } ZEPHIR_CALL_PARENT(NULL, phalcon_config_adapter_ini_ce, this_ptr, "__construct", &_16, 19, config); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); }
/** * Registers a set of PSR-4 directories for a given namespace, either * appending or prepending to the ones previously set for this namespace. * * @param string $prefix The prefix/namespace, with trailing "\\" * @param array|string $paths The PSR-0 base directories * @param bool $prepend Whether to prepend the directories * @throws \InvalidArgumentException */ PHP_METHOD(Xpl_ClassLoader, addPsr4) { zend_bool prepend; zval *prefix, *paths = NULL, *prepend_param = NULL, *firstChar = NULL, *prefixDirs = NULL, *_4, *_0$$5, *_1$$5, *_2$$6, *_3$$6, _5$$7, _6$$7, *_7$$7, *_8$$10, *_9$$11; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 1, &prefix, &paths, &prepend_param); ZEPHIR_SEPARATE_PARAM(paths); if (!prepend_param) { prepend = 0; } else { prepend = zephir_get_boolval(prepend_param); } if (Z_TYPE_P(paths) == IS_STRING) { ZEPHIR_INIT_NVAR(paths); zephir_create_array(paths, 1, 0 TSRMLS_CC); zephir_array_fast_append(paths, paths); } if (Z_TYPE_P(prefix) != IS_STRING) { if (prepend) { ZEPHIR_INIT_VAR(_0$$5); _1$$5 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr4"), PH_NOISY_CC); zephir_fast_array_merge(_0$$5, &(paths), &(_1$$5) TSRMLS_CC); zephir_update_property_this(this_ptr, SL("fallbackDirsPsr4"), _0$$5 TSRMLS_CC); } else { ZEPHIR_INIT_VAR(_2$$6); _3$$6 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr4"), PH_NOISY_CC); zephir_fast_array_merge(_2$$6, &(_3$$6), &(paths) TSRMLS_CC); zephir_update_property_this(this_ptr, SL("fallbackDirsPsr4"), _2$$6 TSRMLS_CC); } RETURN_MM_NULL(); } ZEPHIR_OBS_VAR(prefixDirs); _4 = zephir_fetch_nproperty_this(this_ptr, SL("prefixDirsPsr4"), PH_NOISY_CC); if (!(zephir_array_isset_fetch(&prefixDirs, _4, prefix, 0 TSRMLS_CC))) { ZEPHIR_SINIT_VAR(_5$$7); ZVAL_LONG(&_5$$7, 0); ZEPHIR_SINIT_VAR(_6$$7); ZVAL_LONG(&_6$$7, 1); ZEPHIR_INIT_VAR(firstChar); zephir_substr(firstChar, prefix, 0 , 1 , 0); if (!(zephir_end_with_str(prefix, SL("\\")))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "A non-empty PSR-4 prefix must end with a namespace separator.", "xpl/classloader.zep", 310); return; } ZEPHIR_INIT_VAR(_7$$7); ZVAL_LONG(_7$$7, zephir_fast_strlen_ev(prefix)); zephir_update_property_array_multi(this_ptr, SL("prefixLengthsPsr4"), &_7$$7 TSRMLS_CC, SL("zz"), 2, firstChar, prefix); zephir_update_property_array(this_ptr, SL("prefixDirsPsr4"), prefix, paths TSRMLS_CC); } else { if (prepend) { ZEPHIR_INIT_VAR(_8$$10); zephir_fast_array_merge(_8$$10, &(paths), &(prefixDirs) TSRMLS_CC); zephir_update_property_array(this_ptr, SL("prefixDirsPsr4"), prefix, _8$$10 TSRMLS_CC); } else { ZEPHIR_INIT_VAR(_9$$11); zephir_fast_array_merge(_9$$11, &(prefixDirs), &(paths) TSRMLS_CC); zephir_update_property_array(this_ptr, SL("prefixDirsPsr4"), prefix, _9$$11 TSRMLS_CC); } } ZEPHIR_MM_RESTORE(); }
/** * This method is automatically called in \Phalcon\Db\Adapter\Pdo constructor. * * Call it when you need to restore a database connection. * *<code> * use Phalcon\Db\Adapter\Pdo\Mysql; * * // Make a connection * $connection = new Mysql([ * 'host' => 'localhost', * 'username' => 'sigma', * 'password' => 'secret', * 'dbname' => 'blog', * 'port' => 3306, * ]); * * // Reconnect * $connection->connect(); * </code> */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, connect) { HashTable *_3$$13; HashPosition _2$$13; int ZEPHIR_LAST_CALL_STATUS; zval *descriptor_param = NULL, *username = NULL, *password = NULL, *dsnParts = NULL, *dsnAttributes = NULL, *persistent = NULL, *options = NULL, *key = NULL, *value = NULL, *_6, *_7, *_8, *_9, *_0$$3, **_4$$13, *_5$$14 = NULL; zval *descriptor = NULL, *_1$$3 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &descriptor_param); if (!descriptor_param) { ZEPHIR_INIT_VAR(descriptor); array_init(descriptor); } else { zephir_get_arrval(descriptor, descriptor_param); } if (ZEPHIR_IS_EMPTY(descriptor)) { ZEPHIR_OBS_VAR(_0$$3); zephir_read_property_this(&_0$$3, this_ptr, SL("_descriptor"), PH_NOISY_CC); zephir_get_arrval(_1$$3, _0$$3); ZEPHIR_CPY_WRT(descriptor, _1$$3); } ZEPHIR_OBS_VAR(username); if (zephir_array_isset_string_fetch(&username, descriptor, SS("username"), 0 TSRMLS_CC)) { zephir_array_unset_string(&descriptor, SS("username"), PH_SEPARATE); } else { ZEPHIR_INIT_NVAR(username); ZVAL_NULL(username); } ZEPHIR_OBS_VAR(password); if (zephir_array_isset_string_fetch(&password, descriptor, SS("password"), 0 TSRMLS_CC)) { zephir_array_unset_string(&descriptor, SS("password"), PH_SEPARATE); } else { ZEPHIR_INIT_NVAR(password); ZVAL_NULL(password); } ZEPHIR_OBS_VAR(options); if (zephir_array_isset_string_fetch(&options, descriptor, SS("options"), 0 TSRMLS_CC)) { zephir_array_unset_string(&descriptor, SS("options"), PH_SEPARATE); } else { ZEPHIR_INIT_NVAR(options); array_init(options); } ZEPHIR_OBS_VAR(persistent); if (zephir_array_isset_string_fetch(&persistent, descriptor, SS("persistent"), 0 TSRMLS_CC)) { if (zephir_is_true(persistent)) { zephir_array_update_long(&options, 12, &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY); } zephir_array_unset_string(&descriptor, SS("persistent"), PH_SEPARATE); } if (zephir_array_isset_string(descriptor, SS("dialectClass"))) { zephir_array_unset_string(&descriptor, SS("dialectClass"), PH_SEPARATE); } ZEPHIR_OBS_VAR(dsnAttributes); if (!(zephir_array_isset_string_fetch(&dsnAttributes, descriptor, SS("dsn"), 0 TSRMLS_CC))) { ZEPHIR_INIT_VAR(dsnParts); array_init(dsnParts); zephir_is_iterable(descriptor, &_3$$13, &_2$$13, 0, 0, "phalcon/db/adapter/pdo.zep", 154); for ( ; zephir_hash_get_current_data_ex(_3$$13, (void**) &_4$$13, &_2$$13) == SUCCESS ; zephir_hash_move_forward_ex(_3$$13, &_2$$13) ) { ZEPHIR_GET_HMKEY(key, _3$$13, _2$$13); ZEPHIR_GET_HVALUE(value, _4$$13); ZEPHIR_INIT_LNVAR(_5$$14); ZEPHIR_CONCAT_VSV(_5$$14, key, "=", value); zephir_array_append(&dsnParts, _5$$14, PH_SEPARATE, "phalcon/db/adapter/pdo.zep", 152); } ZEPHIR_INIT_NVAR(dsnAttributes); zephir_fast_join_str(dsnAttributes, SL(";"), dsnParts TSRMLS_CC); } ZEPHIR_INIT_VAR(_6); ZVAL_LONG(_6, 2); zephir_array_update_long(&options, 3, &_6, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY); ZEPHIR_INIT_VAR(_7); object_init_ex(_7, php_pdo_get_dbh_ce()); _8 = zephir_fetch_nproperty_this(this_ptr, SL("_type"), PH_NOISY_CC); ZEPHIR_INIT_VAR(_9); ZEPHIR_CONCAT_VSV(_9, _8, ":", dsnAttributes); ZEPHIR_CALL_METHOD(NULL, _7, "__construct", NULL, 0, _9, username, password, options); zephir_check_call_status(); zephir_update_property_this(this_ptr, SL("_pdo"), _7 TSRMLS_CC); RETURN_MM_BOOL(1); }
PHP_METHOD(Xpl_ClassLoader, findFileWithExtension) { HashTable *_16, *_39, *_6$$3, *_11$$5, *_32$$12, *_35$$14; HashPosition _15, _38, _5$$3, _10$$5, _31$$12, _34$$14; int ZEPHIR_LAST_CALL_STATUS; zephir_fcall_cache_entry *_3 = NULL; zval *className_param = NULL, *ext_param = NULL, *logicalPathPsr4 = NULL, *firstChar = NULL, *prefixLengthsPsr4 = NULL, *prefix = NULL, *length = NULL, *dir = NULL, *file = NULL, *prefixesPsr0 = NULL, *logicalPathPsr0 = NULL, *nsPos = NULL, *dirs = NULL, _0 = zval_used_for_init, _1 = zval_used_for_init, *_2 = NULL, *_4, *_14, **_17, _18, *_30, *_37, **_40, *_41, **_7$$3, *_8$$5, *_9$$5, **_12$$5, *_13$$6 = NULL, _19$$10, _20$$10, *_21$$10, _22$$10, *_23$$10, _24$$10, _25$$10, *_26$$10 = NULL, _27$$11, _28$$11, *_29$$11 = NULL, **_33$$12, **_36$$14; zval *className = NULL, *ext = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &className_param, &ext_param); if (unlikely(Z_TYPE_P(className_param) != IS_STRING && Z_TYPE_P(className_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'className' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(className_param) == IS_STRING)) { zephir_get_strval(className, className_param); } else { ZEPHIR_INIT_VAR(className); ZVAL_EMPTY_STRING(className); } zephir_get_strval(ext, ext_param); ZEPHIR_SINIT_VAR(_0); ZVAL_STRING(&_0, "\\", 0); ZEPHIR_SINIT_VAR(_1); ZVAL_STRING(&_1, "/", 0); ZEPHIR_CALL_FUNCTION(&_2, "strtr", &_3, 56, className, &_0, &_1); zephir_check_call_status(); ZEPHIR_INIT_VAR(logicalPathPsr4); ZEPHIR_CONCAT_VV(logicalPathPsr4, _2, ext); ZEPHIR_SINIT_NVAR(_0); ZVAL_LONG(&_0, 0); ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, 1); ZEPHIR_INIT_VAR(firstChar); zephir_substr(firstChar, className, 0 , 1 , 0); ZEPHIR_OBS_VAR(prefixLengthsPsr4); _4 = zephir_fetch_nproperty_this(this_ptr, SL("prefixLengthsPsr4"), PH_NOISY_CC); if (zephir_array_isset_fetch(&prefixLengthsPsr4, _4, firstChar, 0 TSRMLS_CC)) { zephir_is_iterable(prefixLengthsPsr4, &_6$$3, &_5$$3, 0, 0, "xpl/classloader.zep", 505); for ( ; zephir_hash_get_current_data_ex(_6$$3, (void**) &_7$$3, &_5$$3) == SUCCESS ; zephir_hash_move_forward_ex(_6$$3, &_5$$3) ) { ZEPHIR_GET_HMKEY(prefix, _6$$3, _5$$3); ZEPHIR_GET_HVALUE(length, _7$$3); if (zephir_start_with(className, prefix, ZEPHIR_GLOBAL(global_false))) { _8$$5 = zephir_fetch_nproperty_this(this_ptr, SL("prefixDirsPsr4"), PH_NOISY_CC); zephir_array_fetch(&_9$$5, _8$$5, prefix, PH_NOISY | PH_READONLY, "xpl/classloader.zep", 495 TSRMLS_CC); zephir_is_iterable(_9$$5, &_11$$5, &_10$$5, 0, 0, "xpl/classloader.zep", 503); for ( ; zephir_hash_get_current_data_ex(_11$$5, (void**) &_12$$5, &_10$$5) == SUCCESS ; zephir_hash_move_forward_ex(_11$$5, &_10$$5) ) { ZEPHIR_GET_HVALUE(dir, _12$$5); ZEPHIR_INIT_NVAR(_13$$6); zephir_substr(_13$$6, logicalPathPsr4, zephir_get_intval(length), 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_INIT_NVAR(file); ZEPHIR_CONCAT_VSV(file, dir, "/", _13$$6); if ((zephir_file_exists(file TSRMLS_CC) == SUCCESS)) { RETURN_CCTOR(file); } } } } } _14 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr4"), PH_NOISY_CC); zephir_is_iterable(_14, &_16, &_15, 0, 0, "xpl/classloader.zep", 517); for ( ; zephir_hash_get_current_data_ex(_16, (void**) &_17, &_15) == SUCCESS ; zephir_hash_move_forward_ex(_16, &_15) ) { ZEPHIR_GET_HVALUE(dir, _17); ZEPHIR_INIT_NVAR(file); ZEPHIR_CONCAT_VSV(file, dir, "/", logicalPathPsr4); if ((zephir_file_exists(file TSRMLS_CC) == SUCCESS)) { RETURN_CCTOR(file); } } ZEPHIR_SINIT_VAR(_18); ZVAL_STRING(&_18, "\\", 0); ZEPHIR_CALL_FUNCTION(&nsPos, "strrpos", NULL, 57, className, &_18); zephir_check_call_status(); ZEPHIR_INIT_VAR(logicalPathPsr0); if (zephir_is_true(nsPos)) { ZEPHIR_SINIT_VAR(_19$$10); ZVAL_LONG(&_19$$10, 0); ZEPHIR_SINIT_VAR(_20$$10); ZVAL_LONG(&_20$$10, (zephir_get_numberval(nsPos) + 1)); ZEPHIR_INIT_VAR(_21$$10); zephir_substr(_21$$10, logicalPathPsr4, 0 , zephir_get_intval(&_20$$10), 0); ZEPHIR_SINIT_VAR(_22$$10); ZVAL_LONG(&_22$$10, (zephir_get_numberval(nsPos) + 1)); ZEPHIR_INIT_VAR(_23$$10); zephir_substr(_23$$10, logicalPathPsr4, zephir_get_intval(&_22$$10), 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_SINIT_VAR(_24$$10); ZVAL_STRING(&_24$$10, "_", 0); ZEPHIR_SINIT_VAR(_25$$10); ZVAL_STRING(&_25$$10, "/", 0); ZEPHIR_CALL_FUNCTION(&_26$$10, "strtr", &_3, 56, _23$$10, &_24$$10, &_25$$10); zephir_check_call_status(); ZEPHIR_CONCAT_VV(logicalPathPsr0, _21$$10, _26$$10); } else { ZEPHIR_SINIT_VAR(_27$$11); ZVAL_STRING(&_27$$11, "_", 0); ZEPHIR_SINIT_VAR(_28$$11); ZVAL_STRING(&_28$$11, "/", 0); ZEPHIR_CALL_FUNCTION(&_29$$11, "strtr", &_3, 56, className, &_27$$11, &_28$$11); zephir_check_call_status(); ZEPHIR_CONCAT_VV(logicalPathPsr0, _29$$11, ext); } ZEPHIR_OBS_VAR(prefixesPsr0); _30 = zephir_fetch_nproperty_this(this_ptr, SL("prefixesPsr0"), PH_NOISY_CC); if (zephir_array_isset_fetch(&prefixesPsr0, _30, firstChar, 0 TSRMLS_CC)) { zephir_is_iterable(prefixesPsr0, &_32$$12, &_31$$12, 0, 0, "xpl/classloader.zep", 546); for ( ; zephir_hash_get_current_data_ex(_32$$12, (void**) &_33$$12, &_31$$12) == SUCCESS ; zephir_hash_move_forward_ex(_32$$12, &_31$$12) ) { ZEPHIR_GET_HMKEY(prefix, _32$$12, _31$$12); ZEPHIR_GET_HVALUE(dirs, _33$$12); if (zephir_start_with(className, prefix, NULL)) { zephir_is_iterable(dirs, &_35$$14, &_34$$14, 0, 0, "xpl/classloader.zep", 544); for ( ; zephir_hash_get_current_data_ex(_35$$14, (void**) &_36$$14, &_34$$14) == SUCCESS ; zephir_hash_move_forward_ex(_35$$14, &_34$$14) ) { ZEPHIR_GET_HVALUE(dir, _36$$14); ZEPHIR_INIT_NVAR(file); ZEPHIR_CONCAT_VSV(file, dir, "/", logicalPathPsr0); if ((zephir_file_exists(file TSRMLS_CC) == SUCCESS)) { RETURN_CCTOR(file); } } } } } _37 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr0"), PH_NOISY_CC); zephir_is_iterable(_37, &_39, &_38, 0, 0, "xpl/classloader.zep", 559); for ( ; zephir_hash_get_current_data_ex(_39, (void**) &_40, &_38) == SUCCESS ; zephir_hash_move_forward_ex(_39, &_38) ) { ZEPHIR_GET_HVALUE(dir, _40); ZEPHIR_INIT_NVAR(file); ZEPHIR_CONCAT_VSV(file, dir, "/", logicalPathPsr0); if ((zephir_file_exists(file TSRMLS_CC) == SUCCESS)) { RETURN_CCTOR(file); } } _41 = zephir_fetch_nproperty_this(this_ptr, SL("useIncludePath"), PH_NOISY_CC); if (ZEPHIR_IS_TRUE_IDENTICAL(_41)) { ZEPHIR_CALL_FUNCTION(&file, "stream_resolve_include_path", NULL, 58, logicalPathPsr0); zephir_check_call_status(); if (zephir_is_true(file)) { RETURN_CCTOR(file); } } RETURN_MM_NULL(); }
/** * @param int|string id * @param bool concurrent * @return \Ouchbase\Entity|null */ PHP_METHOD(Ouchbase_Repository, find) { zval *_2; int ZEPHIR_LAST_CALL_STATUS; zend_bool concurrent; zval *id, *concurrent_param = NULL, *entity = NULL, *_0, *_1, *cas, *data = NULL, *dataWithCas = NULL, *_3, *_4, *_5, *_6 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &id, &concurrent_param); if (!concurrent_param) { concurrent = 0; } else { concurrent = zephir_get_boolval(concurrent_param); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("im"), PH_NOISY_CC); _1 = zephir_fetch_nproperty_this(this_ptr, SL("className"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&entity, _0, "getentity", NULL, _1, id); zephir_check_call_status(); if (zephir_is_true(entity)) { RETURN_CCTOR(entity); } ZEPHIR_INIT_VAR(_2); array_init_size(_2, 2); zephir_array_fast_append(_2, id); ZEPHIR_INIT_VAR(_3); ZVAL_STRING(_3, "__getWithCas", 0); ZEPHIR_CALL_METHOD(&dataWithCas, this_ptr, "executewithouttimeouts", NULL, _3, _2); zephir_check_temp_parameter(_3); zephir_check_call_status(); ZEPHIR_OBS_VAR(data); zephir_array_fetch_string(&data, dataWithCas, SL("data"), PH_NOISY TSRMLS_CC); ZEPHIR_OBS_VAR(cas); zephir_array_fetch_string(&cas, dataWithCas, SL("cas"), PH_NOISY TSRMLS_CC); if (!(zephir_is_true(data))) { RETURN_MM_NULL(); } if (!(Z_TYPE_P(data) == IS_ARRAY)) { ZEPHIR_INIT_BNVAR(_3); zephir_json_decode(_3, &(_3), data, zephir_get_intval(ZEPHIR_GLOBAL(global_true)) TSRMLS_CC); ZEPHIR_CPY_WRT(data, _3); } ZEPHIR_CALL_METHOD(&entity, this_ptr, "toobject", NULL, data); zephir_check_call_status(); _4 = zephir_fetch_nproperty_this(this_ptr, SL("im"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(NULL, _4, "register", NULL, entity, data); zephir_check_call_status(); _5 = zephir_fetch_nproperty_this(this_ptr, SL("uow"), PH_NOISY_CC); ZEPHIR_INIT_VAR(_6); if (concurrent) { ZEPHIR_CPY_WRT(_6, cas); } else { ZEPHIR_INIT_BNVAR(_6); ZVAL_NULL(_6); } ZEPHIR_CALL_METHOD(NULL, _5, "persist", NULL, entity, _6); zephir_check_call_status(); RETURN_CCTOR(entity); }