/** * Merge modules with the existing ones * * @param array $modules */ PHP_METHOD(Phalcon_CLI_Console, addModules){ zval *modules, *original_modules, *register_modules; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &modules) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(modules) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_cli_console_exception_ce, "Modules must be an Array"); return; } PHALCON_INIT_VAR(original_modules); phalcon_read_property(&original_modules, this_ptr, SL("_modules"), PH_NOISY_CC); PHALCON_INIT_VAR(register_modules); PHALCON_CALL_FUNC_PARAMS_2(register_modules, "array_merge", modules, original_modules); phalcon_update_property_zval(this_ptr, SL("_modules"), register_modules TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Pass any call to the internal adapter object * * @param string $method * @param array $arguments * @return mixed */ PHP_METHOD(Phalcon_Logger, __call){ zval *method = NULL, *arguments = NULL; zval *a0 = NULL, *a1 = NULL; zval *r0 = NULL; zval *t0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &method, &arguments) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!arguments) { PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(arguments, a0); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_INIT_VAR(a1); array_init(a1); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_adapter", sizeof("_adapter")-1, PHALCON_NOISY TSRMLS_CC); phalcon_array_append(&a1, t0, PHALCON_SEPARATE_PLZ TSRMLS_CC); phalcon_array_append(&a1, method, PHALCON_SEPARATE_PLZ TSRMLS_CC); PHALCON_CALL_FUNC_PARAMS_2(r0, "call_user_func_array", a1, arguments, 0x013); PHALCON_RETURN_DZVAL(r0); }
/** * Opens the internal file handler after unserialization * */ PHP_METHOD(Phalcon_Logger_Adapter_File, __wakeup){ zval *path = NULL, *options = NULL, *mode = NULL, *file_handler = NULL; int eval_int; PHALCON_MM_GROW(); PHALCON_INIT_VAR(path); phalcon_read_property(&path, this_ptr, SL("_path"), PH_NOISY_CC); PHALCON_INIT_VAR(options); phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC); eval_int = phalcon_array_isset_string(options, SL("mode")+1); if (eval_int) { PHALCON_INIT_VAR(mode); phalcon_array_fetch_string(&mode, options, SL("mode"), PH_NOISY_CC); } else { PHALCON_INIT_VAR(mode); ZVAL_STRING(mode, "ab", 1); } PHALCON_INIT_VAR(file_handler); PHALCON_CALL_FUNC_PARAMS_2(file_handler, "fopen", path, mode); phalcon_update_property_zval(this_ptr, SL("_fileHandler"), file_handler TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Register classes and their locations * * @param array $classes * @param boolean $merge * @return Phalcon\Loader */ PHP_METHOD(Phalcon_Loader, registerClasses){ zval *classes, *merge = NULL, *current_classes, *merged_classes; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &classes, &merge) == FAILURE) { RETURN_MM_NULL(); } if (!merge) { PHALCON_INIT_VAR(merge); ZVAL_BOOL(merge, 0); } if (Z_TYPE_P(classes) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_loader_exception_ce, "Parameter $classes must be an Array"); return; } if (zend_is_true(merge)) { PHALCON_OBS_VAR(current_classes); phalcon_read_property(¤t_classes, this_ptr, SL("_classes"), PH_NOISY_CC); PHALCON_INIT_VAR(merged_classes); PHALCON_CALL_FUNC_PARAMS_2(merged_classes, "array_merge", current_classes, classes); phalcon_update_property_zval(this_ptr, SL("_classes"), merged_classes TSRMLS_CC); } else { phalcon_update_property_zval(this_ptr, SL("_classes"), classes TSRMLS_CC); } RETURN_THIS(); }
/** * Checks whether request has been made using SOAP * * @return boolean */ PHP_METHOD(Phalcon_Request, isSoapRequested){ zval *g0 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL; zval *c0 = NULL; zval *t0 = NULL; int eval_int; PHALCON_MM_GROW(); phalcon_get_global(&g0, "_SERVER", sizeof("_SERVER") TSRMLS_CC); eval_int = phalcon_array_isset_string(g0, "HTTP_SOAPACTION", strlen("HTTP_SOAPACTION")+1); if (eval_int) { PHALCON_MM_RESTORE(); RETURN_TRUE; } else { eval_int = phalcon_array_isset_string(g0, "CONTENT_TYPE", strlen("CONTENT_TYPE")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_string(&r1, g0, "CONTENT_TYPE", strlen("CONTENT_TYPE"), PHALCON_NOISY TSRMLS_CC); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "application/soap+xml", 1); PHALCON_CALL_FUNC_PARAMS_2(r0, "strpos", r1, c0, 0x00E); PHALCON_INIT_VAR(t0); ZVAL_BOOL(t0, 0); PHALCON_INIT_VAR(r2); is_not_identical_function(r2, t0, r0 TSRMLS_CC); PHALCON_RETURN_NCTOR(r2); } } PHALCON_MM_RESTORE(); RETURN_FALSE; }
/** * Adds a route applying the common attributes * * @param string $patten * @param array $paths * @param array $httpMethods * @return Phalcon\Mvc\Router\Route */ PHP_METHOD(Phalcon_Mvc_Router_Group, _addRoute){ zval *pattern, *paths = NULL, *http_methods = NULL, *prefix, *prefix_pattern; zval *default_paths, *merged_paths = NULL, *route; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|zz", &pattern, &paths, &http_methods) == FAILURE) { RETURN_MM_NULL(); } if (!paths) { PHALCON_INIT_VAR(paths); } if (!http_methods) { PHALCON_INIT_VAR(http_methods); } PHALCON_OBS_VAR(prefix); phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); /** * Add the prefix to the pattern */ PHALCON_INIT_VAR(prefix_pattern); PHALCON_CONCAT_VV(prefix_pattern, prefix, pattern); PHALCON_OBS_VAR(default_paths); phalcon_read_property(&default_paths, this_ptr, SL("_paths"), PH_NOISY_CC); /** * Check if the paths need to be merged with current paths */ if (Z_TYPE_P(default_paths) == IS_ARRAY) { if (Z_TYPE_P(paths) == IS_ARRAY) { /** * Merge the paths with the default paths */ PHALCON_INIT_VAR(merged_paths); PHALCON_CALL_FUNC_PARAMS_2(merged_paths, "array_merge", default_paths, paths); } else { PHALCON_CPY_WRT(merged_paths, default_paths); } } else { PHALCON_CPY_WRT(merged_paths, paths); } /** * Every route is internally stored as a Phalcon\Mvc\Router\Route */ PHALCON_INIT_VAR(route); object_init_ex(route, phalcon_mvc_router_route_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(route, "__construct", prefix_pattern, merged_paths, http_methods); phalcon_update_property_array_append(this_ptr, SL("_routes"), route TSRMLS_CC); RETURN_CTOR(route); }
/** * Uncamelize strings which are camelized * *<code> * echo Phalcon\Text::camelize('CocoBongo'); //coco_bongo *</code> * * @param string $str * @return string */ PHP_METHOD(Phalcon_Text, uncamelize){ zval *str = NULL, *patterns = NULL, *replacement = NULL, *pattern = NULL, *match_pattern = NULL; zval *pattern_replace = NULL, *lower_pattern = NULL, *lower_str = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &str) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(patterns); array_init(patterns); add_assoc_stringl_ex(patterns, SL("/(?<=(?:[A-Z]))([A-Z]+)([A-Z][A-z])/")+1, SL("\\1_\\2"), 1); add_assoc_stringl_ex(patterns, SL("/(?<=(?:[a-z]))([A-Z])/")+1, SL("_\\1"), 1); if (!phalcon_valid_foreach(patterns TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(patterns); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_f8ee_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_f8ee_0; } PHALCON_INIT_VAR(pattern); PHALCON_GET_FOREACH_KEY(pattern, ah0, hp0); PHALCON_INIT_VAR(replacement); ZVAL_ZVAL(replacement, *hd, 1, 0); PHALCON_INIT_VAR(match_pattern); PHALCON_CALL_FUNC_PARAMS_2(match_pattern, "preg_match", pattern, str); if (zend_is_true(match_pattern)) { PHALCON_INIT_VAR(pattern_replace); PHALCON_CALL_FUNC_PARAMS_3(pattern_replace, "preg_replace", pattern, replacement, str); PHALCON_INIT_VAR(lower_pattern); PHALCON_CALL_FUNC_PARAMS_1(lower_pattern, "strtolower", pattern_replace); RETURN_CTOR(lower_pattern); } zend_hash_move_forward_ex(ah0, &hp0); goto fes_f8ee_0; fee_f8ee_0: PHALCON_INIT_VAR(lower_str); PHALCON_CALL_FUNC_PARAMS_1(lower_str, "strtolower", str); RETURN_CTOR(lower_str); }
/** * Sends/Writes messages to the file log * * @param string $message * @param int $type */ PHP_METHOD(Phalcon_Logger_Adapter_File, log){ zval *message = NULL, *type = NULL, *msg = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL; zval *c0 = NULL; zval *i0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &message, &type) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_fileHandler", sizeof("_fileHandler")-1, PHALCON_NOISY TSRMLS_CC); if (!zend_is_true(t0)) { PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "Cannot send message to the log because it is invalid"); return; } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_FUNC_PARAMS_1(r0, "is_scalar", message, 0x045); if (zend_is_true(r0)) { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_INIT_VAR(c0); ZVAL_BOOL(c0, 1); PHALCON_CALL_FUNC_PARAMS_2(r1, "print_r", message, c0, 0x008); PHALCON_CPY_WRT(msg, r1); } PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_transaction", sizeof("_transaction")-1, PHALCON_NOISY TSRMLS_CC); if (zend_is_true(t1)) { PHALCON_ALLOC_ZVAL_MM(i0); object_init_ex(i0, phalcon_logger_item_ce); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CALL_FUNC(r2, "time", 0x018); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(i0, "__construct", message, type, r2, PHALCON_CHECK); PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, "_quenue", sizeof("_quenue")-1, PHALCON_NOISY TSRMLS_CC); phalcon_array_append(&t2, i0, PHALCON_NO_SEPARATE_THX TSRMLS_CC); phalcon_update_property_zval(this_ptr, "_quenue", strlen("_quenue"), t2 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(t3); phalcon_read_property(&t3, this_ptr, "_fileHandler", sizeof("_fileHandler")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CALL_METHOD_PARAMS_2(r4, this_ptr, "_applyformat", message, type, PHALCON_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(t4); zend_get_constant("PHP_EOL", strlen("PHP_EOL"), t4 TSRMLS_CC); PHALCON_CONCAT_VV(r3, r4, t4); PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fputs", t3, r3, 0x04F); } PHALCON_MM_RESTORE(); }
/** * Appends an array of messages to the group * *<code> * $messages->appendMessages($messagesArray); *</code> * * @param Phalcon\Validation\MessageInterface[] $messages */ PHP_METHOD(Phalcon_Validation_Message_Group, appendMessages){ zval *messages, *current_messages, *final_messages = NULL; zval *message = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &messages) == FAILURE) { RETURN_MM_NULL(); } if (Z_TYPE_P(messages) != IS_ARRAY) { if (Z_TYPE_P(messages) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "The messages must be array or object"); return; } } PHALCON_OBS_VAR(current_messages); phalcon_read_property(¤t_messages, this_ptr, SL("_messages"), PH_NOISY_CC); if (Z_TYPE_P(messages) == IS_ARRAY) { /** * An array of messages is simply merged into the current one */ if (Z_TYPE_P(current_messages) == IS_ARRAY) { PHALCON_INIT_VAR(final_messages); PHALCON_CALL_FUNC_PARAMS_2(final_messages, "array_merge", current_messages, messages); } else { PHALCON_CPY_WRT(final_messages, messages); } phalcon_update_property_zval(this_ptr, SL("_messages"), final_messages TSRMLS_CC); } else { /** * A group of messages is iterated and appended one-by-one to the current list */ PHALCON_CALL_METHOD_NORETURN(messages, "rewind"); while (1) { PHALCON_INIT_NVAR(r0); PHALCON_CALL_METHOD(r0, messages, "valid"); if (PHALCON_IS_NOT_FALSE(r0)) { } else { break; } PHALCON_INIT_NVAR(message); PHALCON_CALL_METHOD(message, messages, "current"); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "appendmessage", message); PHALCON_CALL_METHOD_NORETURN(messages, "next"); } } PHALCON_MM_RESTORE(); }
/** * Applies the internal format to the message * * @param string $message * @param int $type * @param int $time * @return string */ PHP_METHOD(Phalcon_Logger_Adapter_File, _applyFormat){ zval *message = NULL, *type = NULL, *time = NULL, *format = NULL, *date_format = NULL; zval *date = NULL, *new_format = NULL, *type_string = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &message, &type, &time) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!time) { PHALCON_ALLOC_ZVAL_MM(time); ZVAL_LONG(time, 0); } else { PHALCON_SEPARATE_PARAM(time); } if (!zend_is_true(time)) { PHALCON_INIT_VAR(time); PHALCON_CALL_FUNC(time, "time"); } PHALCON_INIT_VAR(format); phalcon_read_property(&format, this_ptr, SL("_format"), PH_NOISY_CC); PHALCON_INIT_VAR(date_format); phalcon_read_property(&date_format, this_ptr, SL("_dateFormat"), PH_NOISY_CC); PHALCON_INIT_VAR(date); PHALCON_CALL_FUNC_PARAMS_2(date, "date", date_format, time); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "%date%", 1); PHALCON_INIT_VAR(new_format); phalcon_fast_str_replace(new_format, c0, date, format TSRMLS_CC); PHALCON_INIT_VAR(type_string); PHALCON_CALL_METHOD_PARAMS_1(type_string, this_ptr, "gettypestring", type, PH_NO_CHECK); PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "%type%", 1); PHALCON_INIT_VAR(format); phalcon_fast_str_replace(format, c1, type_string, new_format TSRMLS_CC); PHALCON_INIT_VAR(c2); ZVAL_STRING(c2, "%message%", 1); PHALCON_INIT_VAR(new_format); phalcon_fast_str_replace(new_format, c2, message, format TSRMLS_CC); RETURN_CTOR(new_format); }
/** * Phalcon_Logger_Adapter_File constructor * * @param string $name * @param array $options */ PHP_METHOD(Phalcon_Logger_Adapter_File, __construct){ zval *name = NULL, *options = NULL, *mode = NULL; zval *a0 = NULL, *a1 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL; zval *t0 = NULL; zval *i0 = NULL; int eval_int; PHALCON_MM_GROW(); PHALCON_INIT_VAR(a0); array_init(a0); zend_update_property(phalcon_logger_adapter_file_ce, this_ptr, "_quenue", strlen("_quenue"), a0 TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &name, &options) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!options) { PHALCON_INIT_VAR(a1); array_init(a1); PHALCON_CPY_WRT(options, a1); } eval_int = phalcon_array_isset_string(options, "mode", strlen("mode")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_string(&r0, options, "mode", strlen("mode"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(mode, r0); } else { PHALCON_INIT_VAR(mode); ZVAL_STRING(mode, "ab", 1); } PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_FUNC_PARAMS_2(r1, "fopen", name, mode, 0x025); phalcon_update_property_zval(this_ptr, "_fileHandler", strlen("_fileHandler"), r1 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_fileHandler", sizeof("_fileHandler")-1, PHALCON_NOISY TSRMLS_CC); if (!zend_is_true(t0)) { PHALCON_ALLOC_ZVAL_MM(i0); object_init_ex(i0, phalcon_logger_exception_ce); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CONCAT_SVS(r2, "Can't open log file at '", name, "'"); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r2, PHALCON_CHECK); phalcon_throw_exception(i0 TSRMLS_CC); return; } PHALCON_MM_RESTORE(); }
/** * Sends SQL statements to the MySQL database server returning success state. * When the SQL sent have returned any row, the result is a PHP resource. * * * $resultset = $connection->query("SELECT * FROM robots WHERE type=?", array("mechanical")); * * @param string $sqlStatement * @return Phalcon_Db_Result_Mysql|boolean */ PHP_METHOD(Phalcon_Db_Adapter_Mysql, query){ zval *sql_statement = NULL, *id_connection = NULL, *result = NULL; zval *number_error = NULL, *error_message = NULL; zval *t0 = NULL; zval *i0 = NULL, *i1 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &sql_statement) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "_beforequery", sql_statement, PHALCON_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_idConnection"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(id_connection, t0); PHALCON_INIT_VAR(result); PHALCON_CALL_FUNC_PARAMS_2(result, "mysqli_query", id_connection, sql_statement); if (zend_is_true(result)) { PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "_afterquery", sql_statement, PHALCON_NO_CHECK); if (Z_TYPE_P(result) == IS_OBJECT) { PHALCON_ALLOC_ZVAL_MM(i0); object_init_ex(i0, phalcon_db_result_mysql_ce); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", result, PHALCON_CHECK); RETURN_CTOR(i0); } RETURN_CHECK_CTOR(result); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD(r0, this_ptr, "noerror", PHALCON_NO_CHECK); PHALCON_CPY_WRT(number_error, r0); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CONCAT_SVS(r2, " when executing \"", sql_statement, "\""); PHALCON_CALL_METHOD_PARAMS_1(r1, this_ptr, "error", r2, PHALCON_NO_CHECK); PHALCON_CPY_WRT(error_message, r1); PHALCON_ALLOC_ZVAL_MM(i1); object_init_ex(i1, phalcon_db_exception_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(i1, "__construct", error_message, number_error, PHALCON_CHECK); phalcon_throw_exception(i1 TSRMLS_CC); return; }
/** * Executes validator * * @return boolean */ PHP_METHOD(Phalcon_Model_Validator_Exclusionin, validate) { zval *domain = NULL, *field_name = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL, *c3 = NULL; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD(r0, this_ptr, "isrequired", PHALCON_NO_CHECK); if (zend_is_true(r0)) { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "domain", 1); PHALCON_CALL_METHOD_PARAMS_1(r1, this_ptr, "issetoption", c0, PHALCON_NO_CHECK); if (zend_is_true(r1)) { PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "domain", 1); PHALCON_CALL_METHOD_PARAMS_1(r2, this_ptr, "getoption", c1, PHALCON_NO_CHECK); PHALCON_CPY_WRT(domain, r2); PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CALL_METHOD(r4, this_ptr, "getvalue", PHALCON_NO_CHECK); PHALCON_CALL_FUNC_PARAMS_2(r3, "in_array", r4, domain, 0x03E); if (zend_is_true(r3)) { PHALCON_ALLOC_ZVAL_MM(r5); PHALCON_CALL_METHOD(r5, this_ptr, "getfieldname", PHALCON_NO_CHECK); PHALCON_CPY_WRT(field_name, r5); PHALCON_ALLOC_ZVAL_MM(r6); PHALCON_INIT_VAR(c2); ZVAL_STRING(c2, ", ", 1); PHALCON_ALLOC_ZVAL_MM(r7); phalcon_fast_join(r7, c2, domain TSRMLS_CC); PHALCON_CONCAT_SVSV(r6, "Value of field '", field_name, "' must not be part of list: ", r7); PHALCON_INIT_VAR(c3); ZVAL_STRING(c3, "exclusion", 1); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r6, field_name, c3, PHALCON_NO_CHECK); PHALCON_MM_RESTORE(); RETURN_FALSE; } } } PHALCON_MM_RESTORE(); RETURN_TRUE; }
/** * Returns the numeric active version * * @return int */ PHP_METHOD(Phalcon_Version, getId){ zval *version = NULL, *major, *medium, *minor, *special, *special_number; zval *format, *real_medium, *real_minor; PHALCON_MM_GROW(); PHALCON_INIT_VAR(version); PHALCON_CALL_SELF(version, this_ptr, "_getversion"); PHALCON_INIT_VAR(major); phalcon_array_fetch_long(&major, version, 0, PH_NOISY_CC); PHALCON_INIT_VAR(medium); phalcon_array_fetch_long(&medium, version, 1, PH_NOISY_CC); PHALCON_INIT_VAR(minor); phalcon_array_fetch_long(&minor, version, 2, PH_NOISY_CC); PHALCON_INIT_VAR(special); phalcon_array_fetch_long(&special, version, 3, PH_NOISY_CC); PHALCON_INIT_VAR(special_number); phalcon_array_fetch_long(&special_number, version, 4, PH_NOISY_CC); PHALCON_INIT_VAR(format); ZVAL_STRING(format, "%02s", 1); PHALCON_INIT_VAR(real_medium); PHALCON_CALL_FUNC_PARAMS_2(real_medium, "sprintf", format, medium); PHALCON_INIT_VAR(real_minor); PHALCON_CALL_FUNC_PARAMS_2(real_minor, "sprintf", format, minor); PHALCON_INIT_NVAR(version); PHALCON_CONCAT_VVVVV(version, major, real_medium, real_minor, special, special_number); RETURN_CCTOR(version); }
/** * Phalcon\Logger\Adapter\File constructor * * @param string $name * @param array $options */ PHP_METHOD(Phalcon_Logger_Adapter_File, __construct){ zval *name = NULL, *options = NULL, *mode = NULL, *handler = NULL, *exception_message = NULL; zval *exception = NULL; zval *a0 = NULL; int eval_int; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(a0); array_init(a0); zend_update_property(phalcon_logger_adapter_file_ce, this_ptr, SL("_quenue"), a0 TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &name, &options) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!options) { PHALCON_INIT_VAR(options); array_init(options); } eval_int = phalcon_array_isset_string(options, SL("mode")+1); if (eval_int) { PHALCON_INIT_VAR(mode); phalcon_array_fetch_string(&mode, options, SL("mode"), PH_NOISY_CC); } else { PHALCON_INIT_VAR(mode); ZVAL_STRING(mode, "ab", 1); } PHALCON_INIT_VAR(handler); PHALCON_CALL_FUNC_PARAMS_2(handler, "fopen", name, mode); if (!zend_is_true(handler)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Can't open log file at '", name, "'"); PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_logger_exception_ce); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(exception, "__construct", exception_message, PH_CHECK); phalcon_throw_exception(exception TSRMLS_CC); return; } phalcon_update_property_zval(this_ptr, SL("_path"), name TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_options"), options TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_fileHandler"), handler TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Phalcon\Logger\Adapter\File constructor * * @param string $name * @param array $options */ PHP_METHOD(Phalcon_Logger_Adapter_File, __construct){ zval *name, *options = NULL, *mode = NULL, *handler, *exception_message; zval *a0 = NULL; int eval_int; PHALCON_MM_GROW(); PHALCON_INIT_VAR(a0); array_init(a0); zend_update_property(phalcon_logger_adapter_file_ce, this_ptr, SL("_quenue"), a0 TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &name, &options) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!options) { PHALCON_INIT_NVAR(options); array_init(options); } eval_int = phalcon_array_isset_string(options, SS("mode")); if (eval_int) { PHALCON_INIT_VAR(mode); phalcon_array_fetch_string(&mode, options, SL("mode"), PH_NOISY_CC); } else { PHALCON_INIT_NVAR(mode); ZVAL_STRING(mode, "ab", 1); } if (phalcon_memnstr_str(mode, SL("r") TSRMLS_CC)) { PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "Logger must be opened in append or write mode"); return; } PHALCON_INIT_VAR(handler); PHALCON_CALL_FUNC_PARAMS_2(handler, "fopen", name, mode); if (!zend_is_true(handler)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Can't open log file at '", name, "'"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_logger_exception_ce, exception_message); return; } phalcon_update_property_zval(this_ptr, SL("_path"), name TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_options"), options TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_fileHandler"), handler TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Opens the internal file handler after unserialization * */ PHP_METHOD(Phalcon_Logger_Adapter_File, __wakeup){ zval *t0 = NULL; zval *c0 = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_path"), PH_NOISY_CC); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "ab", 1); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_FUNC_PARAMS_2(r0, "fopen", t0, c0); phalcon_update_property_zval(this_ptr, SL("_fileHandler"), r0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Opens the internal file handler after unserialization * */ PHP_METHOD(Phalcon_Logger_Adapter_File, __wakeup){ zval *path = NULL, *file_handler = NULL; zval *c0 = NULL; PHALCON_MM_GROW(); PHALCON_INIT_VAR(path); phalcon_read_property(&path, this_ptr, SL("_path"), PH_NOISY_CC); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "ab", 1); PHALCON_INIT_VAR(file_handler); PHALCON_CALL_FUNC_PARAMS_2(file_handler, "fopen", path, c0); phalcon_update_property_zval(this_ptr, SL("_fileHandler"), file_handler TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Escapes a value to avoid SQL injections * * @param string $str * @return string */ PHP_METHOD(Phalcon_Db_Adapter_Mysql, escapeString){ zval *str = NULL; zval *t0 = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &str) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_idConnection"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_FUNC_PARAMS_2(r0, "mysqli_real_escape_string", t0, str); RETURN_DZVAL(r0); }
/** * Writes parsed annotations to files * * @param string $key * @param array $data */ PHP_METHOD(Phalcon_Annotations_Adapter_Files, write){ zval *key, *data, *annotations_dir, *separator; zval *virtual_key, *path, *to_string, *export, *php_export; zval *status; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &key, &data) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(annotations_dir); phalcon_read_property_this(&annotations_dir, this_ptr, SL("_annotationsDir"), PH_NOISY_CC); PHALCON_INIT_VAR(separator); ZVAL_STRING(separator, "_", 1); PHALCON_INIT_VAR(virtual_key); phalcon_prepare_virtual_path(virtual_key, key, separator TSRMLS_CC); PHALCON_INIT_VAR(path); PHALCON_CONCAT_VVS(path, annotations_dir, virtual_key, ".php"); PHALCON_INIT_VAR(to_string); ZVAL_BOOL(to_string, 1); PHALCON_INIT_VAR(export); PHALCON_CALL_FUNC_PARAMS_2(export, "var_export", data, to_string); PHALCON_INIT_VAR(php_export); PHALCON_CONCAT_SVS(php_export, "<?php return ", export, "; "); PHALCON_INIT_VAR(status); PHALCON_CALL_FUNC_PARAMS_2(status, "file_put_contents", path, php_export); if (PHALCON_IS_FALSE(status)) { PHALCON_THROW_EXCEPTION_STR(phalcon_annotations_exception_ce, "Annotations directory cannot be written"); return; } PHALCON_MM_RESTORE(); }
/** * Gets hasOne relations defined on a model * * @param Phalcon\Mvc\Model $model * @return array */ PHP_METHOD(Phalcon_Mvc_Model_Manager, getHasOneAndHasMany){ zval *model = NULL, *has_one = NULL, *has_many = NULL, *merge = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &model) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(has_one); PHALCON_CALL_METHOD_PARAMS_1(has_one, this_ptr, "gethasone", model, PH_NO_CHECK); PHALCON_INIT_VAR(has_many); PHALCON_CALL_METHOD_PARAMS_1(has_many, this_ptr, "gethasmany", model, PH_NO_CHECK); PHALCON_INIT_VAR(merge); PHALCON_CALL_FUNC_PARAMS_2(merge, "array_merge", has_one, has_many); RETURN_CCTOR(merge); }
/** * Helper method to query records based on a relation definition * * @param array $relation * @param string $method * @param Phalcon\Mvc\Model $record * @param array $parameters * @return Phalcon\Mvc\Model\Resultset\Simple */ PHP_METHOD(Phalcon_Mvc_Model_Manager, _getRelationRecords){ zval *relation = NULL, *method = NULL, *record = NULL, *parameters = NULL, *placeholders = NULL; zval *pre_conditions = NULL, *conditions = NULL, *fields = NULL, *field = NULL; zval *value = NULL, *referenced_field = NULL, *condition = NULL, *i = NULL; zval *referenced_fields = NULL, *join_conditions = NULL; zval *find_params = NULL, *find_arguments = NULL, *arguments = NULL; zval *reference_table = NULL, *referenced_entity = NULL; zval *connection_service = NULL, *call_object = NULL, *records = NULL; zval *c0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; zend_class_entry *ce0; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &relation, &method, &record, ¶meters) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!parameters) { PHALCON_ALLOC_ZVAL_MM(parameters); ZVAL_NULL(parameters); } else { PHALCON_SEPARATE_PARAM(parameters); } if (Z_TYPE_P(parameters) == IS_ARRAY) { eval_int = phalcon_array_isset_string(parameters, SL("bind")+1); if (eval_int) { PHALCON_INIT_VAR(placeholders); phalcon_array_fetch_string(&placeholders, parameters, SL("bind"), PH_NOISY_CC); PHALCON_SEPARATE_PARAM(parameters); phalcon_array_unset_string(parameters, SL("bind")+1); } else { PHALCON_INIT_VAR(placeholders); array_init(placeholders); } } else { PHALCON_INIT_VAR(placeholders); array_init(placeholders); } PHALCON_INIT_VAR(pre_conditions); ZVAL_NULL(pre_conditions); if (Z_TYPE_P(parameters) == IS_ARRAY) { eval_int = phalcon_array_isset_long(parameters, 0); if (eval_int) { PHALCON_INIT_VAR(pre_conditions); phalcon_array_fetch_long(&pre_conditions, parameters, 0, PH_NOISY_CC); PHALCON_SEPARATE_PARAM(parameters); phalcon_array_unset_long(parameters, 0); } else { eval_int = phalcon_array_isset_string(parameters, SL("conditions")+1); if (eval_int) { PHALCON_INIT_VAR(pre_conditions); phalcon_array_fetch_string(&pre_conditions, parameters, SL("conditions"), PH_NOISY_CC); PHALCON_SEPARATE_PARAM(parameters); phalcon_array_unset_string(parameters, SL("conditions")+1); } } } else { if (Z_TYPE_P(parameters) == IS_STRING) { PHALCON_CPY_WRT(pre_conditions, parameters); } } if (Z_TYPE_P(pre_conditions) != IS_NULL) { PHALCON_INIT_VAR(conditions); array_init(conditions); phalcon_array_append(&conditions, pre_conditions, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(conditions); array_init(conditions); } PHALCON_INIT_VAR(fields); phalcon_array_fetch_string(&fields, relation, SL("fi"), PH_NOISY_CC); if (Z_TYPE_P(fields) != IS_ARRAY) { PHALCON_CPY_WRT(field, fields); PHALCON_INIT_VAR(value); PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK); PHALCON_INIT_VAR(referenced_field); phalcon_array_fetch_string(&referenced_field, relation, SL("rf"), PH_NOISY_CC); PHALCON_INIT_VAR(condition); PHALCON_CONCAT_VS(condition, referenced_field, " = ?0"); phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(i); ZVAL_LONG(i, 0); PHALCON_INIT_VAR(referenced_fields); phalcon_array_fetch_string(&referenced_fields, relation, SL("rf"), PH_NOISY_CC); if (!phalcon_valid_foreach(fields TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(fields); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_74b5_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_74b5_0; } PHALCON_INIT_VAR(field); ZVAL_ZVAL(field, *hd, 1, 0); PHALCON_INIT_VAR(value); PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK); PHALCON_INIT_VAR(referenced_field); phalcon_array_fetch(&referenced_field, referenced_fields, i, PH_NOISY_CC); PHALCON_INIT_VAR(condition); PHALCON_CONCAT_VSV(condition, referenced_field, " = ?", i); phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC); PHALCON_SEPARATE(i); increment_function(i); zend_hash_move_forward_ex(ah0, &hp0); goto fes_74b5_0; fee_74b5_0: if(0){} } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, " AND ", 1); PHALCON_INIT_VAR(join_conditions); phalcon_fast_join(join_conditions, c0, conditions TSRMLS_CC); PHALCON_INIT_VAR(find_params); array_init(find_params); phalcon_array_append(&find_params, join_conditions, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&find_params, SL("bind"), &placeholders, PH_COPY | PH_SEPARATE TSRMLS_CC); if (Z_TYPE_P(parameters) == IS_ARRAY) { PHALCON_INIT_VAR(find_arguments); PHALCON_CALL_FUNC_PARAMS_2(find_arguments, "array_merge", find_params, parameters); } else { PHALCON_CPY_WRT(find_arguments, find_params); } PHALCON_INIT_VAR(arguments); array_init(arguments); phalcon_array_append(&arguments, find_arguments, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(reference_table); phalcon_array_fetch_string(&reference_table, relation, SL("rt"), PH_NOISY_CC); ce0 = phalcon_fetch_class(reference_table TSRMLS_CC); PHALCON_INIT_VAR(referenced_entity); object_init_ex(referenced_entity, ce0); PHALCON_CALL_METHOD_NORETURN(referenced_entity, "__construct", PH_CHECK); PHALCON_INIT_VAR(connection_service); PHALCON_CALL_METHOD(connection_service, record, "getconnectionservice", PH_NO_CHECK); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(referenced_entity, "setconnectionservice", connection_service, PH_NO_CHECK); PHALCON_INIT_VAR(call_object); array_init(call_object); phalcon_array_append(&call_object, referenced_entity, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&call_object, method, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(records); PHALCON_CALL_FUNC_PARAMS_2(records, "call_user_func_array", call_object, arguments); RETURN_CCTOR(records); }
/** * Helper method to query records based on a relation definition * * @param array $relation * @param string $method * @param Phalcon\Mvc\Model $record */ PHP_METHOD(Phalcon_Mvc_Model_Manager, _getRelationRecords){ zval *relation = NULL, *method = NULL, *record = NULL, *conditions = NULL, *placeholders = NULL; zval *field = NULL, *value = NULL, *referenced_field = NULL, *condition = NULL; zval *i = NULL, *fields = NULL, *number_args = NULL, *function_arguments = NULL; zval *key = NULL, *join_conditions = NULL, *find_params = NULL, *arguments = NULL; zval *reference_table = NULL, *referenced_entity = NULL; zval *call_object = NULL, *records = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL; zval *c0 = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; zend_class_entry *ce0; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &relation, &method, &record) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(conditions); array_init(conditions); PHALCON_INIT_VAR(placeholders); array_init(placeholders); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_string(&r0, relation, SL("fi"), PH_NOISY_CC); if (Z_TYPE_P(r0) != IS_ARRAY) { PHALCON_INIT_VAR(field); phalcon_array_fetch_string(&field, relation, SL("fi"), PH_NOISY_CC); PHALCON_INIT_VAR(value); PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK); PHALCON_INIT_VAR(referenced_field); phalcon_array_fetch_string(&referenced_field, relation, SL("rf"), PH_NOISY_CC); PHALCON_INIT_VAR(condition); PHALCON_CONCAT_VS(condition, referenced_field, " = ?0"); phalcon_array_update_long(&conditions, 0, &condition, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(i); ZVAL_LONG(i, 0); PHALCON_INIT_VAR(fields); phalcon_array_fetch_string(&fields, relation, SL("fi"), PH_NOISY_CC); if (!phalcon_valid_foreach(fields TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(fields); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_74b5_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_74b5_0; } PHALCON_INIT_VAR(field); ZVAL_ZVAL(field, *hd, 1, 0); PHALCON_INIT_VAR(value); PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK); PHALCON_INIT_VAR(r1); phalcon_array_fetch_string(&r1, relation, SL("rf"), PH_NOISY_CC); PHALCON_INIT_VAR(referenced_field); phalcon_array_fetch(&referenced_field, r1, i, PH_NOISY_CC); PHALCON_INIT_VAR(condition); PHALCON_CONCAT_VSV(condition, referenced_field, " = ?", i); phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC); PHALCON_SEPARATE(i); increment_function(i); zend_hash_move_forward_ex(ah0, &hp0); goto fes_74b5_0; fee_74b5_0: if(0){} } PHALCON_INIT_VAR(number_args); PHALCON_CALL_FUNC(number_args, "func_num_args"); PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, 4); PHALCON_ALLOC_ZVAL_MM(r2); is_smaller_function(r2, t0, number_args TSRMLS_CC); if (zend_is_true(r2)) { PHALCON_INIT_VAR(function_arguments); PHALCON_CALL_FUNC(function_arguments, "func_get_args"); if (!phalcon_valid_foreach(function_arguments TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(function_arguments); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_74b5_1: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_74b5_1; } PHALCON_INIT_VAR(key); PHALCON_GET_FOREACH_KEY(key, ah1, hp1); PHALCON_INIT_VAR(value); ZVAL_ZVAL(value, *hd, 1, 0); PHALCON_INIT_VAR(t1); ZVAL_LONG(t1, 0); PHALCON_INIT_VAR(r3); is_equal_function(r3, key, t1 TSRMLS_CC); PHALCON_INIT_VAR(t2); ZVAL_STRING(t2, "conditions", 1); PHALCON_INIT_VAR(r4); is_equal_function(r4, key, t2 TSRMLS_CC); PHALCON_INIT_VAR(r5); ZVAL_BOOL(r5, zend_is_true(r3) || zend_is_true(r4)); if (zend_is_true(r5)) { phalcon_array_append(&conditions, value, PH_SEPARATE TSRMLS_CC); } zend_hash_move_forward_ex(ah1, &hp1); goto fes_74b5_1; fee_74b5_1: if(0){} } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, " AND ", 1); PHALCON_INIT_VAR(join_conditions); phalcon_fast_join(join_conditions, c0, conditions TSRMLS_CC); PHALCON_INIT_VAR(find_params); array_init(find_params); phalcon_array_append(&find_params, join_conditions, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&find_params, SL("bind"), &placeholders, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(arguments); array_init(arguments); phalcon_array_append(&arguments, find_params, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(reference_table); phalcon_array_fetch_string(&reference_table, relation, SL("rt"), PH_NOISY_CC); ce0 = phalcon_fetch_class(reference_table TSRMLS_CC); PHALCON_INIT_VAR(referenced_entity); object_init_ex(referenced_entity, ce0); PHALCON_CALL_METHOD_NORETURN(referenced_entity, "__construct", PH_CHECK); PHALCON_ALLOC_ZVAL_MM(r6); PHALCON_CALL_METHOD(r6, record, "getconnectionservice", PH_NO_CHECK); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(referenced_entity, "setconnectionservice", r6, PH_NO_CHECK); PHALCON_INIT_VAR(call_object); array_init(call_object); phalcon_array_append(&call_object, referenced_entity, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&call_object, method, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(records); PHALCON_CALL_FUNC_PARAMS_2(records, "call_user_func_array", call_object, arguments); RETURN_CCTOR(records); }
/** * Applies a format to a message before sent it to the internal log * * @param string $message * @param int $type * @param int $timestamp */ PHP_METHOD(Phalcon_Logger_Formatter_Line, format) { zval *message, *type, *timestamp, *format = NULL, *date_format; zval *date, *date_wildcard, *new_format = NULL, *type_string; zval *type_wildcard, *message_wildcard, *eol = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &message, &type, ×tamp) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(format); phalcon_read_property(&format, this_ptr, SL("_format"), PH_NOISY_CC); /** * Check if the format has the %date% placeholder */ if (phalcon_memnstr_str(format, SL("%date%") TSRMLS_CC)) { PHALCON_OBS_VAR(date_format); phalcon_read_property(&date_format, this_ptr, SL("_dateFormat"), PH_NOISY_CC); PHALCON_INIT_VAR(date); PHALCON_CALL_FUNC_PARAMS_2(date, "date", date_format, timestamp); PHALCON_INIT_VAR(date_wildcard); ZVAL_STRING(date_wildcard, "%date%", 1); PHALCON_INIT_VAR(new_format); phalcon_fast_str_replace(new_format, date_wildcard, date, format TSRMLS_CC); } else { PHALCON_CPY_WRT(new_format, format); } /** * Check if the format has the %type% placeholder */ if (phalcon_memnstr_str(format, SL("%type%") TSRMLS_CC)) { PHALCON_INIT_VAR(type_string); PHALCON_CALL_METHOD_PARAMS_1(type_string, this_ptr, "gettypestring", type); PHALCON_INIT_VAR(type_wildcard); ZVAL_STRING(type_wildcard, "%type%", 1); PHALCON_INIT_NVAR(format); phalcon_fast_str_replace(format, type_wildcard, type_string, new_format TSRMLS_CC); } else { PHALCON_CPY_WRT(format, new_format); } PHALCON_INIT_VAR(message_wildcard); ZVAL_STRING(message_wildcard, "%message%", 1); PHALCON_INIT_NVAR(new_format); phalcon_fast_str_replace(new_format, message_wildcard, message, format TSRMLS_CC); PHALCON_INIT_VAR(eol); PHALCON_INIT_NVAR(eol); ZVAL_STRING(eol, PHP_EOL, 1); PHALCON_INIT_NVAR(format); PHALCON_CONCAT_VV(format, new_format, eol); RETURN_CCTOR(format); }
/** * Handles routing information received from the rewrite engine * * @param string $uri */ PHP_METHOD(Phalcon_Mvc_Router, handle){ zval *uri = NULL, *real_uri = NULL, *request = NULL, *route_found = NULL, *parts = NULL; zval *params = NULL, *matches = NULL, *routes = NULL, *reversed_routes = NULL; zval *route = NULL, *methods = NULL, *dependency_injector = NULL; zval *match_method = NULL, *pattern = NULL, *paths = NULL, *position = NULL; zval *part = NULL, *match_position = NULL, *module = NULL, *default_module = NULL; zval *controller = NULL, *default_controller = NULL, *action = NULL; zval *default_action = NULL, *params_str = NULL, *str_params = NULL; zval *params_merge = NULL, *default_params = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!uri) { PHALCON_ALLOC_ZVAL_MM(uri); ZVAL_NULL(uri); } if (!zend_is_true(uri)) { PHALCON_INIT_VAR(real_uri); PHALCON_CALL_METHOD(real_uri, this_ptr, "_getrewriteuri", PH_NO_CHECK); } else { PHALCON_CPY_WRT(real_uri, uri); } PHALCON_INIT_VAR(request); ZVAL_NULL(request); PHALCON_INIT_VAR(route_found); ZVAL_BOOL(route_found, 0); PHALCON_INIT_VAR(parts); array_init(parts); PHALCON_INIT_VAR(params); array_init(params); PHALCON_INIT_VAR(matches); array_init(matches); phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC); PHALCON_INIT_VAR(routes); phalcon_read_property(&routes, this_ptr, SL("_routes"), PH_NOISY_CC); PHALCON_INIT_VAR(reversed_routes); PHALCON_CALL_FUNC_PARAMS_1(reversed_routes, "array_reverse", routes); if (!phalcon_valid_foreach(reversed_routes TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(reversed_routes); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_c9ff_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_c9ff_0; } PHALCON_INIT_VAR(route); ZVAL_ZVAL(route, *hd, 1, 0); PHALCON_INIT_VAR(methods); PHALCON_CALL_METHOD(methods, route, "gethttpmethods", PH_NO_CHECK); if (Z_TYPE_P(methods) != IS_NULL) { if (Z_TYPE_P(request) == IS_NULL) { PHALCON_INIT_VAR(dependency_injector); phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_dispatcher_exception_ce, "A dependency injection container is required to access the 'request' service"); return; } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "request", 1); PHALCON_INIT_VAR(request); PHALCON_CALL_METHOD_PARAMS_1(request, dependency_injector, "getshared", c0, PH_NO_CHECK); } PHALCON_INIT_VAR(match_method); PHALCON_CALL_METHOD_PARAMS_1(match_method, request, "ismethod", methods, PH_NO_CHECK); if (!zend_is_true(match_method)) { zend_hash_move_forward_ex(ah0, &hp0); goto fes_c9ff_0; } } PHALCON_INIT_VAR(pattern); PHALCON_CALL_METHOD(pattern, route, "getcompiledpattern", PH_NO_CHECK); Z_SET_ISREF_P(matches); PHALCON_INIT_VAR(route_found); PHALCON_CALL_FUNC_PARAMS_3(route_found, "preg_match", pattern, real_uri, matches); Z_UNSET_ISREF_P(matches); if (zend_is_true(route_found)) { PHALCON_INIT_VAR(paths); PHALCON_CALL_METHOD(paths, route, "getpaths", PH_NO_CHECK); PHALCON_CPY_WRT(parts, paths); if (!phalcon_valid_foreach(paths TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(paths); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_c9ff_1: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_c9ff_1; } PHALCON_INIT_VAR(part); PHALCON_GET_FOREACH_KEY(part, ah1, hp1); PHALCON_INIT_VAR(position); ZVAL_ZVAL(position, *hd, 1, 0); eval_int = phalcon_array_isset(matches, position); if (eval_int) { PHALCON_INIT_VAR(match_position); phalcon_array_fetch(&match_position, matches, position, PH_NOISY_CC); phalcon_array_update_zval(&parts, part, &match_position, PH_COPY | PH_SEPARATE TSRMLS_CC); } zend_hash_move_forward_ex(ah1, &hp1); goto fes_c9ff_1; fee_c9ff_1: phalcon_update_property_zval(this_ptr, SL("_matches"), matches TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_matchedRoute"), route TSRMLS_CC); goto fee_c9ff_0; } zend_hash_move_forward_ex(ah0, &hp0); goto fes_c9ff_0; fee_c9ff_0: if (zend_is_true(route_found)) { eval_int = phalcon_array_isset_string(parts, SL("module")+1); if (eval_int) { PHALCON_INIT_VAR(module); phalcon_array_fetch_string(&module, parts, SL("module"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_module"), module TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("module")+1); } else { PHALCON_INIT_VAR(default_module); phalcon_read_property(&default_module, this_ptr, SL("_defaultModule"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_module"), default_module TSRMLS_CC); } eval_int = phalcon_array_isset_string(parts, SL("controller")+1); if (eval_int) { PHALCON_INIT_VAR(controller); phalcon_array_fetch_string(&controller, parts, SL("controller"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_controller"), controller TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("controller")+1); } else { PHALCON_INIT_VAR(default_controller); phalcon_read_property(&default_controller, this_ptr, SL("_defaultController"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_controller"), default_controller TSRMLS_CC); } eval_int = phalcon_array_isset_string(parts, SL("action")+1); if (eval_int) { PHALCON_INIT_VAR(action); phalcon_array_fetch_string(&action, parts, SL("action"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_action"), action TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("action")+1); } else { PHALCON_INIT_VAR(default_action); phalcon_read_property(&default_action, this_ptr, SL("_defaultAction"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_action"), default_action TSRMLS_CC); } eval_int = phalcon_array_isset_string(parts, SL("params")+1); if (eval_int) { PHALCON_INIT_VAR(params_str); phalcon_array_fetch_string(¶ms_str, parts, SL("params"), PH_NOISY_CC); PHALCON_INIT_VAR(c1); ZVAL_LONG(c1, 1); PHALCON_INIT_VAR(str_params); PHALCON_CALL_FUNC_PARAMS_2(str_params, "substr", params_str, c1); if (zend_is_true(str_params)) { PHALCON_INIT_VAR(c2); ZVAL_STRING(c2, "/", 1); PHALCON_INIT_VAR(params); phalcon_fast_explode(params, c2, str_params TSRMLS_CC); } PHALCON_SEPARATE(parts); phalcon_array_unset_string(parts, SL("params")+1); } PHALCON_INIT_VAR(params_merge); PHALCON_CALL_FUNC_PARAMS_2(params_merge, "array_merge", params, parts); phalcon_update_property_zval(this_ptr, SL("_params"), params_merge TSRMLS_CC); phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 1 TSRMLS_CC); } else { PHALCON_INIT_VAR(default_module); phalcon_read_property(&default_module, this_ptr, SL("_defaultModule"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_module"), default_module TSRMLS_CC); PHALCON_INIT_VAR(default_controller); phalcon_read_property(&default_controller, this_ptr, SL("_defaultController"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_controller"), default_controller TSRMLS_CC); PHALCON_INIT_VAR(default_action); phalcon_read_property(&default_action, this_ptr, SL("_defaultAction"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_action"), default_action TSRMLS_CC); PHALCON_INIT_VAR(default_params); phalcon_read_property(&default_params, this_ptr, SL("_defaultParams"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_params"), default_params TSRMLS_CC); phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC); } PHALCON_MM_RESTORE(); }
/** * Get the conditions of query * * @return string $query */ PHP_METHOD(Phalcon_Model_Query, getConditions){ zval *controller_front = NULL, *model_manager = NULL, *model_name = NULL; zval *entity = NULL, *meta_data = NULL, *attributes = NULL, *numeric_types = NULL; zval *i = NULL, *parameters = NULL, *conditions = NULL, *value = NULL, *param = NULL; zval *condition = NULL, *index = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL; zval *t7 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL; zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL; zval *i0 = NULL; zval *a0 = NULL, *a1 = NULL; zval *c0 = NULL; HashTable *ah0, *ah1, *ah2; HashPosition hp0, hp1, hp2; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY TSRMLS_CC); if (!zend_is_true(t0)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_STATIC(r0, "phalcon_controller_front", "getinstance"); PHALCON_CPY_WRT(controller_front, r0); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_METHOD(r1, controller_front, "getmodelcomponent", PHALCON_NO_CHECK); PHALCON_CPY_WRT(model_manager, r1); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "setmanager", model_manager, PHALCON_NO_CHECK); } else { PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(model_manager, t1); } PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, "_models", sizeof("_models")-1, PHALCON_NOISY TSRMLS_CC); if (phalcon_valid_foreach(t2 TSRMLS_CC)) { ah0 = Z_ARRVAL_P(t2); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_a355_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_a355_0; } PHALCON_INIT_VAR(model_name); ZVAL_ZVAL(model_name, *hd, 1, 0); PHALCON_INIT_VAR(r2); PHALCON_CALL_METHOD_PARAMS_1(r2, model_manager, "getmodel", model_name, PHALCON_NO_CHECK); PHALCON_CPY_WRT(entity, r2); if (!zend_is_true(entity)) { PHALCON_INIT_VAR(i0); object_init_ex(i0, phalcon_model_exception_ce); PHALCON_INIT_VAR(r3); PHALCON_CONCAT_BOTH(r3, "The model ", model_name, " does not exist"); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r3, PHALCON_CHECK); phalcon_throw_exception(i0 TSRMLS_CC); return; } PHALCON_INIT_VAR(r4); PHALCON_CALL_METHOD(r4, model_manager, "getmetadata", PHALCON_NO_CHECK); PHALCON_CPY_WRT(meta_data, r4); PHALCON_INIT_VAR(r5); PHALCON_CALL_METHOD_PARAMS_1(r5, meta_data, "getattributes", entity, PHALCON_NO_CHECK); PHALCON_CPY_WRT(attributes, r5); PHALCON_INIT_VAR(r6); PHALCON_CALL_METHOD_PARAMS_1(r6, meta_data, "getdatatypesnumeric", entity, PHALCON_NO_CHECK); PHALCON_CPY_WRT(numeric_types, r6); PHALCON_INIT_VAR(t3); phalcon_read_property(&t3, this_ptr, "_data", sizeof("_data")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_INIT_VAR(r7); phalcon_fast_count(r7, t3 TSRMLS_CC); if (zend_is_true(r7)) { PHALCON_INIT_VAR(i); ZVAL_LONG(i, 0); PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(parameters, a0); PHALCON_INIT_VAR(a1); array_init(a1); PHALCON_CPY_WRT(conditions, a1); PHALCON_INIT_VAR(t4); phalcon_read_property(&t4, this_ptr, "_data", sizeof("_data")-1, PHALCON_NOISY TSRMLS_CC); if (phalcon_valid_foreach(t4 TSRMLS_CC)) { ah1 = Z_ARRVAL_P(t4); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_a355_1: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_a355_1; } else { PHALCON_INIT_VAR(param); PHALCON_GET_FOREACH_KEY(param, ah1, hp1); } PHALCON_INIT_VAR(value); ZVAL_ZVAL(value, *hd, 1, 0); PHALCON_INIT_VAR(r8); PHALCON_CALL_FUNC_PARAMS_2(r8, "in_array", param, attributes, 0x03E); if (zend_is_true(r8)) { PHALCON_INIT_VAR(t5); ZVAL_STRING(t5, "", 1); PHALCON_INIT_VAR(r9); is_not_identical_function(r9, t5, value TSRMLS_CC); PHALCON_INIT_VAR(r11); PHALCON_CALL_FUNC_PARAMS_1(r11, "is_null", value, 0x041); PHALCON_INIT_VAR(r10); boolean_not_function(r10, r11 TSRMLS_CC); PHALCON_INIT_VAR(r12); phalcon_and_function(r12, r9, r10); if (zend_is_true(r12)) { if (!PHALCON_COMPARE_STRING(value, "@")) { eval_int = phalcon_array_isset(numeric_types, param); if (eval_int) { PHALCON_INIT_VAR(r13); PHALCON_CONCAT_VBOTH(r13, param, " = ?", i); PHALCON_CPY_WRT(condition, r13); phalcon_array_update(¶meters, i, &value, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); } else { PHALCON_INIT_VAR(r14); PHALCON_CONCAT_VBOTH(r14, param, " LIKE ?", i); PHALCON_CPY_WRT(condition, r14); PHALCON_INIT_VAR(r15); PHALCON_CONCAT_BOTH(r15, "%", value, "%"); phalcon_array_update(¶meters, i, &r15, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); } phalcon_array_append(&conditions, condition, PHALCON_SEPARATE_PLZ TSRMLS_CC); } } } PHALCON_SEPARATE(i); increment_function(i); zend_hash_move_forward_ex(ah1, &hp1); goto fes_a355_1; fee_a355_1: if(0){} } else { return; } } else { PHALCON_INIT_VAR(t6); phalcon_read_property(&t6, this_ptr, "_parameters", sizeof("_parameters")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(parameters, t6); PHALCON_INIT_VAR(t7); phalcon_read_property(&t7, this_ptr, "_conditions", sizeof("_conditions")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(conditions, t7); } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, " AND ", 1); PHALCON_INIT_VAR(r16); phalcon_fast_join(r16, c0, conditions TSRMLS_CC); PHALCON_CPY_WRT(conditions, r16); if (phalcon_valid_foreach(parameters TSRMLS_CC)) { ah2 = Z_ARRVAL_P(parameters); zend_hash_internal_pointer_reset_ex(ah2, &hp2); fes_a355_2: if(zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) != SUCCESS){ goto fee_a355_2; } else { PHALCON_INIT_VAR(index); PHALCON_GET_FOREACH_KEY(index, ah2, hp2); } PHALCON_INIT_VAR(value); ZVAL_ZVAL(value, *hd, 1, 0); PHALCON_INIT_VAR(r17); PHALCON_INIT_VAR(r18); PHALCON_CONCAT_LEFT(r18, "?", index); PHALCON_CALL_FUNC_PARAMS_3(r17, "str_replace", r18, value, conditions, 0x003); PHALCON_CPY_WRT(conditions, r17); zend_hash_move_forward_ex(ah2, &hp2); goto fes_a355_2; fee_a355_2: if(0){} } else { return; } if (PHALCON_COMPARE_STRING(conditions, "")) { PHALCON_INIT_VAR(conditions); ZVAL_STRING(conditions, "1=1", 1); } PHALCON_RETURN_CHECK_CTOR(conditions); zend_hash_move_forward_ex(ah0, &hp0); goto fes_a355_0; fee_a355_0: if(0){} } else { return; } PHALCON_MM_RESTORE(); }
/** * Dispatches a controller action taking into account the routing parameters * * @param Phalcon_Request $request * @param Phalcon_Response $response * @param Phalcon_View $view * @param Phalcon_Model_Manager $model * @return Phalcon_Controller */ PHP_METHOD(Phalcon_Dispatcher, dispatch){ zval *request = NULL, *response = NULL, *view = NULL, *model = NULL, *controllers_dir = NULL; zval *value = NULL, *controller = NULL, *number_dispatches = NULL; zval *controller_name = NULL, *controllers = NULL, *controller_class = NULL; zval *controller_path = NULL, *params = NULL, *action_name = NULL; zval *action_method = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL; zval *t7 = NULL, *t8 = NULL, *t9 = NULL, *t10 = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL; zval *i0 = NULL; zval *a0 = NULL, *a1 = NULL; zval *p0[] = { NULL, NULL, NULL, NULL, NULL }; int eval_int; zend_class_entry *ce0; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|zz", &request, &response, &view, &model) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!view) { PHALCON_INIT_VAR(view); ZVAL_NULL(view); } if (!model) { PHALCON_INIT_VAR(model); ZVAL_NULL(model); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_basePath"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, SL("_controllersDir"), PHALCON_NOISY TSRMLS_CC); PHALCON_CONCAT_VV(r0, t0, t1); PHALCON_CPY_WRT(controllers_dir, r0); PHALCON_INIT_VAR(value); ZVAL_NULL(value); PHALCON_INIT_VAR(controller); ZVAL_NULL(controller); PHALCON_INIT_VAR(number_dispatches); ZVAL_LONG(number_dispatches, 0); phalcon_update_property_bool(this_ptr, SL("_finished"), 0 TSRMLS_CC); ws_e10f_0: PHALCON_INIT_VAR(t2); phalcon_read_property(&t2, this_ptr, SL("_finished"), PHALCON_NOISY TSRMLS_CC); if (zend_is_true(t2)) { goto we_e10f_0; } phalcon_update_property_bool(this_ptr, SL("_finished"), 1 TSRMLS_CC); PHALCON_INIT_VAR(t3); phalcon_read_property(&t3, this_ptr, SL("_controllerName"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(controller_name, t3); if (!zend_is_true(controller_name)) { PHALCON_INIT_VAR(t4); phalcon_read_property(&t4, this_ptr, SL("_defaultController"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(controller_name, t4); phalcon_update_property_zval(this_ptr, SL("_controllerName"), controller_name TSRMLS_CC); } PHALCON_INIT_VAR(t5); phalcon_read_property(&t5, this_ptr, SL("_controllers"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(controllers, t5); PHALCON_INIT_VAR(r1); PHALCON_INIT_VAR(r2); PHALCON_CALL_STATIC_PARAMS_1(r2, "phalcon_text", "camelize", controller_name); PHALCON_CONCAT_VS(r1, r2, "Controller"); PHALCON_CPY_WRT(controller_class, r1); eval_int = phalcon_array_isset(controllers, controller_class); if (!eval_int) { PHALCON_INIT_VAR(c0); ZVAL_BOOL(c0, 0); PHALCON_INIT_VAR(r3); PHALCON_CALL_FUNC_PARAMS_2(r3, "class_exists", controller_class, c0); if (!zend_is_true(r3)) { PHALCON_INIT_VAR(r4); PHALCON_CONCAT_VVS(r4, controllers_dir, controller_class, ".php"); PHALCON_CPY_WRT(controller_path, r4); if (phalcon_file_exists(controller_path TSRMLS_CC) == SUCCESS) { if (phalcon_require(controller_path TSRMLS_CC) == FAILURE) { return; } } else { PHALCON_INIT_VAR(r5); PHALCON_CONCAT_SVS(r5, "File for controller class ", controller_class, " doesn't exist"); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r5, PHALCON_NO_CHECK); } PHALCON_INIT_VAR(c1); ZVAL_BOOL(c1, 0); PHALCON_INIT_VAR(r6); PHALCON_CALL_FUNC_PARAMS_2(r6, "class_exists", controller_class, c1); if (!zend_is_true(r6)) { PHALCON_INIT_VAR(r7); PHALCON_CONCAT_SVS(r7, "Class ", controller_class, " was not found on controller file"); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r7, PHALCON_NO_CHECK); } } ce0 = phalcon_fetch_class(controller_class TSRMLS_CC); PHALCON_INIT_VAR(i0); object_init_ex(i0, ce0); p0[0] = this_ptr; p0[1] = request; p0[2] = response; p0[3] = view; p0[4] = model; PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 5, p0, PHALCON_CHECK); PHALCON_CPY_WRT(controller, i0); if (phalcon_method_exists_ex(controller, SL("initialize") TSRMLS_CC) == SUCCESS) { PHALCON_CALL_METHOD_NORETURN(controller, "initialize", PHALCON_NO_CHECK); } PHALCON_INIT_VAR(t6); phalcon_read_property(&t6, this_ptr, SL("_controllers"), PHALCON_NOISY TSRMLS_CC); phalcon_array_update(&t6, controller_class, &controller, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_controllers"), t6 TSRMLS_CC); } else { PHALCON_INIT_VAR(r8); phalcon_array_fetch(&r8, controllers, controller_class, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(controller, r8); } PHALCON_INIT_VAR(t7); phalcon_read_property(&t7, this_ptr, SL("_params"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(params, t7); PHALCON_INIT_VAR(t8); phalcon_read_property(&t8, this_ptr, SL("_actionName"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(action_name, t8); if (!zend_is_true(action_name)) { PHALCON_INIT_VAR(t9); phalcon_read_property(&t9, this_ptr, SL("_defaultAction"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(action_name, t9); phalcon_update_property_zval(this_ptr, SL("_actionName"), action_name TSRMLS_CC); } if (phalcon_method_exists_ex(controller, SL("beforedispatch") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(r9); PHALCON_CALL_METHOD_PARAMS_3(r9, controller, "beforedispatch", controller_name, action_name, params, PHALCON_NO_CHECK); if (Z_TYPE_P(r9) == IS_BOOL && !Z_BVAL_P(r9)) { PHALCON_INIT_VAR(value); ZVAL_BOOL(value, 0); goto we_e10f_0; } } PHALCON_INIT_VAR(r10); PHALCON_CONCAT_VS(r10, action_name, "Action"); PHALCON_CPY_WRT(action_method, r10); if (phalcon_method_exists(controller, action_method TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(a0); array_init(a0); phalcon_array_append(&a0, controller, PHALCON_SEPARATE_PLZ TSRMLS_CC); phalcon_array_append(&a0, action_method, PHALCON_SEPARATE_PLZ TSRMLS_CC); PHALCON_INIT_VAR(value); PHALCON_CALL_FUNC_PARAMS_2(value, "call_user_func_array", a0, params); } else { if (phalcon_method_exists_ex(controller, SL("notfoundaction") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(a1); array_init(a1); phalcon_array_append(&a1, controller, PHALCON_SEPARATE_PLZ TSRMLS_CC); add_next_index_stringl(a1, SL("notFoundAction"), 1); PHALCON_INIT_VAR(value); PHALCON_CALL_FUNC_PARAMS_2(value, "call_user_func_array", a1, params); } else { PHALCON_INIT_VAR(r11); PHALCON_CONCAT_SVSVS(r11, "Action '", action_name, "' was not found on controller '", controller_name, "'"); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r11, PHALCON_NO_CHECK); } } if (phalcon_method_exists_ex(controller, SL("afterdispatch") TSRMLS_CC) == SUCCESS) { PHALCON_CALL_METHOD_PARAMS_3_NORETURN(controller, "afterdispatch", controller_name, action_name, params, PHALCON_NO_CHECK); } PHALCON_SEPARATE(number_dispatches); increment_function(number_dispatches); PHALCON_INIT_VAR(t10); ZVAL_LONG(t10, 256); PHALCON_INIT_VAR(r12); is_smaller_function(r12, t10, number_dispatches TSRMLS_CC); if (zend_is_true(r12)) { PHALCON_INIT_VAR(c2); ZVAL_STRING(c2, "Dispatcher has detected a cyclic routing causing stability problems", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, c2, PHALCON_NO_CHECK); } goto ws_e10f_0; we_e10f_0: phalcon_update_property_zval(this_ptr, SL("_returnedValue"), value TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_lastController"), controller TSRMLS_CC); RETURN_CHECK_CTOR(controller); }
/** * Internal sanizite wrapper to filter_var * * @param mixed $value * @param string $filter * @return mixed */ PHP_METHOD(Phalcon_Filter, _sanitize){ zval *value, *filter, *filters, *filter_object; zval *arguments, *filtered = NULL, *type = NULL, *quote, *empty_str; zval *escaped, *allow_fraction, *options, *exception_message; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &value, &filter) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(filters); phalcon_read_property(&filters, this_ptr, SL("_filters"), PH_NOISY_CC); eval_int = phalcon_array_isset(filters, filter); if (eval_int) { PHALCON_INIT_VAR(filter_object); phalcon_array_fetch(&filter_object, filters, filter, PH_NOISY_CC); /** * If the filter is a closure we call it in the PHP userland */ if (phalcon_is_instance_of(filter_object, SL("Closure") TSRMLS_CC)) { PHALCON_INIT_VAR(arguments); array_init(arguments); phalcon_array_append(&arguments, value, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(filtered); PHALCON_CALL_USER_FUNC_ARRAY(filtered, filter_object, arguments); } else { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_METHOD_PARAMS_1(filtered, filter_object, "filter", value, PH_NO_CHECK); } RETURN_CCTOR(filtered); } PHALCON_INIT_NVAR(filtered); if (PHALCON_COMPARE_STRING(filter, "email")) { /** * The 'email' filter uses the filter extension */ PHALCON_INIT_VAR(type); ZVAL_LONG(type, 517); PHALCON_INIT_VAR(quote); ZVAL_STRING(quote, "'", 1); PHALCON_INIT_VAR(empty_str); ZVAL_STRING(empty_str, "", 1); PHALCON_INIT_VAR(escaped); phalcon_fast_str_replace(escaped, quote, empty_str, value TSRMLS_CC); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", escaped, type); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "int")) { /** * 'int' filter sanitizes a numeric input */ PHALCON_INIT_NVAR(type); ZVAL_LONG(type, 519); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", value, type); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "string")) { PHALCON_INIT_NVAR(type); ZVAL_LONG(type, 513); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", value, type); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "float")) { /** * The 'float' filter uses the filter extension */ PHALCON_INIT_VAR(allow_fraction); ZVAL_LONG(allow_fraction, 4096); PHALCON_INIT_VAR(options); array_init(options); phalcon_array_update_string(&options, SL("flags"), &allow_fraction, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(type); ZVAL_LONG(type, 520); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_3(filtered, "filter_var", value, type, options); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "alphanum")) { PHALCON_INIT_NVAR(filtered); phalcon_filter_alphanum(filtered, value); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "trim")) { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "trim", value); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "striptags")) { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "strip_tags", value); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "lower")) { if (phalcon_function_exists_ex(SS("mb_strtolower") TSRMLS_CC) == SUCCESS) { /** * 'lower' checks for the mbstring extension to make a correct lowercase * transformation */ PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "mb_strtolower", value); } else { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "strtolower", value); } goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "upper")) { if (phalcon_function_exists_ex(SS("mb_strtoupper") TSRMLS_CC) == SUCCESS) { /** * 'upper' checks for the mbstring extension to make a correct lowercase * transformation */ PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "mb_strtoupper", value); } else { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "strtoupper", value); } goto ph_end_0; } PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Sanitize filter ", filter, " is not supported"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_filter_exception_ce, exception_message); return; ph_end_0: RETURN_CCTOR(filtered); }
/** * Bind params to SQL select * * @param string $sqlSelect * @param array $params */ PHP_METHOD(Phalcon_Db_Adapter_Mysql, bindParams){ zval *sql_select = NULL, *params = NULL, *select = NULL, *id_connection = NULL; zval *bind_value = NULL, *index = NULL, *value = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL; zval *t0 = NULL; zval *c0 = NULL, *c1 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &sql_select, ¶ms) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(r0); phalcon_fast_count(r0, params TSRMLS_CC); if (zend_is_true(r0)) { PHALCON_CPY_WRT(select, sql_select); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_idConnection"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(id_connection, t0); if (phalcon_valid_foreach(params TSRMLS_CC)) { ah0 = Z_ARRVAL_P(params); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_321f_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_321f_0; } else { PHALCON_INIT_VAR(index); PHALCON_GET_FOREACH_KEY(index, ah0, hp0); } PHALCON_INIT_VAR(bind_value); ZVAL_ZVAL(bind_value, *hd, 1, 0); PHALCON_INIT_VAR(r1); PHALCON_CALL_FUNC_PARAMS_1(r1, "is_numeric", bind_value); if (zend_is_true(r1)) { PHALCON_CPY_WRT(value, bind_value); } else { PHALCON_INIT_VAR(r2); PHALCON_INIT_VAR(value); PHALCON_CALL_FUNC_PARAMS_2(value, "mysqli_real_escape_string", id_connection, bind_value); PHALCON_CONCAT_SVS(r2, "!¡", value, "!¡"); PHALCON_CPY_WRT(value, r2); } if (Z_TYPE_P(index) == IS_LONG) { PHALCON_INIT_VAR(r3); PHALCON_CONCAT_SV(r3, "?", index); PHALCON_INIT_VAR(r4); phalcon_fast_str_replace(r4, r3, value, select TSRMLS_CC); PHALCON_CPY_WRT(select, r4); } else { if (Z_TYPE_P(index) == IS_STRING) { PHALCON_INIT_VAR(r5); PHALCON_CONCAT_SVS(r5, ":", index, ":"); PHALCON_INIT_VAR(r6); phalcon_fast_str_replace(r6, r5, value, select TSRMLS_CC); PHALCON_CPY_WRT(select, r6); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter"); return; } } zend_hash_move_forward_ex(ah0, &hp0); goto fes_321f_0; fee_321f_0: if(0){} } else { return; } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "!¡", 1); PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "'", 1); PHALCON_ALLOC_ZVAL_MM(r7); phalcon_fast_str_replace(r7, c0, c1, select TSRMLS_CC); RETURN_DZVAL(r7); } RETURN_CHECK_CTOR(sql_select); }
/** * Executes the validator * * @return boolean */ PHP_METHOD(Phalcon_Model_Validator_Uniqueness, validate){ zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL; zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL, *r19 = NULL, *r20 = NULL; zval *r21 = NULL, *r22 = NULL, *r23 = NULL; zval *v0 = NULL, *v1 = NULL, *v2 = NULL, *v3 = NULL, *v4 = NULL, *v5 = NULL, *v6 = NULL; zval *v7 = NULL, *v8 = NULL, *v9 = NULL; zval *i0 = NULL; zval *a0 = NULL; zval *c0 = NULL; zval *t0 = NULL; zval *p4[] = { NULL }, *p9[] = { NULL }, *p11[] = { NULL }, *p13[] = { NULL }, *p15[] = { NULL, NULL, NULL }, *p16[] = { NULL, NULL, NULL }; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; int eval_int; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD(r0, this_ptr, "isrequired", PHALCON_CALL_DEFAULT); if (zend_is_true(r0)) { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_METHOD(r1, this_ptr, "getrecord", PHALCON_CALL_DEFAULT); PHALCON_ALLOC_ZVAL_MM(i0); phalcon_clone(i0, r1 TSRMLS_CC); PHALCON_CPY_WRT(v0, i0); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CALL_METHOD(r2, this_ptr, "getfieldname", PHALCON_CALL_DEFAULT); PHALCON_CPY_WRT(v1, r2); PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(v2, a0); if (Z_TYPE_P(v1) == IS_ARRAY) { if (Z_TYPE_P(v1) != IS_ARRAY) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument supplied for foreach()"); } else { ah0 = Z_ARRVAL_P(v1); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_d73d_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_d73d_0; } PHALCON_INIT_VAR(v3); ZVAL_ZVAL(v3, *hd, 1, 0); PHALCON_INIT_VAR(r3); PHALCON_INIT_VAR(r4); Z_ADDREF_P(v3); p4[0] = v3; PHALCON_CALL_METHOD_PARAMS(r4, v0, "readattribute", 1, p4, PHALCON_CALL_DEFAULT); Z_DELREF_P(p4[0]); Z_ADDREF_P(r4); PHALCON_CALL_FUNC_PARAMS_1(r3, "addslashes", r4, 0x01F); Z_DELREF_P(r4); PHALCON_CPY_WRT(v4, r3); PHALCON_INIT_VAR(r5); PHALCON_CONCAT_VBOTH(r5, v3, "='", v4); PHALCON_INIT_VAR(r6); PHALCON_CONCAT_RIGHT(r6, r5, "'"); Z_ADDREF_P(r6); PHALCON_SEPARATE_ARRAY(v2); phalcon_array_append(v2, r6 TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_d73d_0; fee_d73d_0: if(0){ }; } } else { PHALCON_ALLOC_ZVAL_MM(r7); PHALCON_ALLOC_ZVAL_MM(r8); PHALCON_CALL_METHOD(r8, this_ptr, "getvalue", PHALCON_CALL_DEFAULT); Z_ADDREF_P(r8); PHALCON_CALL_FUNC_PARAMS_1(r7, "addslashes", r8, 0x01F); Z_DELREF_P(r8); PHALCON_CPY_WRT(v4, r7); PHALCON_ALLOC_ZVAL_MM(r9); PHALCON_CONCAT_VBOTH(r9, v1, "='", v4); PHALCON_ALLOC_ZVAL_MM(r10); PHALCON_CONCAT_RIGHT(r10, r9, "'"); Z_ADDREF_P(r10); PHALCON_SEPARATE_ARRAY(v2); phalcon_array_append(v2, r10 TSRMLS_CC); } PHALCON_ALLOC_ZVAL_MM(r11); PHALCON_CALL_METHOD(r11, v0, "getmanager", PHALCON_CALL_DEFAULT); PHALCON_CPY_WRT(v5, r11); PHALCON_ALLOC_ZVAL_MM(r12); PHALCON_CALL_METHOD(r12, v5, "getmetadata", PHALCON_CALL_DEFAULT); PHALCON_CPY_WRT(v6, r12); PHALCON_ALLOC_ZVAL_MM(r13); Z_ADDREF_P(v0); p9[0] = v0; PHALCON_CALL_METHOD_PARAMS(r13, v6, "getprimarykeyattributes", 1, p9, PHALCON_CALL_DEFAULT); Z_DELREF_P(p9[0]); PHALCON_CPY_WRT(v7, r13); if (Z_TYPE_P(v7) != IS_ARRAY) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument supplied for foreach()"); } else { ah1 = Z_ARRVAL_P(v7); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_d73d_1: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_d73d_1; } PHALCON_INIT_VAR(v8); ZVAL_ZVAL(v8, *hd, 1, 0); PHALCON_INIT_VAR(r15); PHALCON_INIT_VAR(r16); Z_ADDREF_P(v8); p11[0] = v8; PHALCON_CALL_METHOD_PARAMS(r16, v0, "readattribute", 1, p11, PHALCON_CALL_DEFAULT); Z_DELREF_P(p11[0]); Z_ADDREF_P(r16); PHALCON_CALL_FUNC_PARAMS_1(r15, "addslashes", r16, 0x01F); Z_DELREF_P(r16); PHALCON_INIT_VAR(r14); PHALCON_CONCAT_VBOTH(r14, v8, "<>'", r15); PHALCON_INIT_VAR(r17); PHALCON_CONCAT_RIGHT(r17, r14, "'"); Z_ADDREF_P(r17); PHALCON_SEPARATE_ARRAY(v2); phalcon_array_append(v2, r17 TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); goto fes_d73d_1; fee_d73d_1: if(0){ }; } PHALCON_ALLOC_ZVAL_MM(r18); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, " AND ", 1); PHALCON_CALL_FUNC_PARAMS_2(r18, "join", c0, v2, 0x00F); PHALCON_CPY_WRT(v2, r18); PHALCON_ALLOC_ZVAL_MM(r19); Z_ADDREF_P(v2); p13[0] = v2; PHALCON_CALL_STATIC_ZVAL_PARAMS(r19, v0, "count", 1, p13); Z_DELREF_P(p13[0]); PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, 0); PHALCON_INIT_VAR(r20); is_smaller_function(r20, t0, r19 TSRMLS_CC); if (zend_is_true(r20)) { PHALCON_ALLOC_ZVAL_MM(r21); PHALCON_CALL_METHOD(r21, this_ptr, "getoptions", PHALCON_CALL_DEFAULT); PHALCON_CPY_WRT(v9, r21); eval_int = phalcon_array_isset_string(v9, "message", strlen("message")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r22); phalcon_array_fetch_string(&r22, v9, "message", strlen("message"), PHALCON_NOISY_FETCH TSRMLS_CC); Z_ADDREF_P(r22); p15[0] = r22; Z_ADDREF_P(v1); p15[1] = v1; PHALCON_INIT_VAR(p15[2]); ZVAL_STRING(p15[2], "unique", 1); PHALCON_CALL_METHOD_PARAMS_NORETURN(this_ptr, "appendmessage", 3, p15, PHALCON_CALL_DEFAULT); Z_DELREF_P(p15[0]); Z_DELREF_P(p15[1]); } else { PHALCON_ALLOC_ZVAL_MM(r23); PHALCON_CONCAT_BOTH(r23, "Value of field '", v1, "' is already present in another record"); Z_ADDREF_P(r23); p16[0] = r23; Z_ADDREF_P(v1); p16[1] = v1; PHALCON_INIT_VAR(p16[2]); ZVAL_STRING(p16[2], "unique", 1); PHALCON_CALL_METHOD_PARAMS_NORETURN(this_ptr, "appendmessage", 3, p16, PHALCON_CALL_DEFAULT); Z_DELREF_P(p16[0]); Z_DELREF_P(p16[1]); } PHALCON_MM_RESTORE(); RETURN_FALSE; } } PHALCON_MM_RESTORE(); RETURN_TRUE; }