PHP_METHOD(Phalcon_Flash, _showMessage){
zval *message = NULL, *classes = NULL, *css_classes = NULL, *msg = NULL;
zval *c0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
zval *t0 = NULL, *t1 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &message, &classes) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(classes) == IS_ARRAY) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " ", 1);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_join(r0, c0, classes TSRMLS_CC);
PHALCON_CPY_WRT(css_classes, r0);
} else {
PHALCON_CPY_WRT(css_classes, classes);
}
if (Z_TYPE_P(message) == IS_ARRAY) {
if (phalcon_valid_foreach(message TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(message);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_3b3c_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_3b3c_0;
}
PHALCON_INIT_VAR(msg);
ZVAL_ZVAL(msg, *hd, 1, 0);
PHALCON_INIT_VAR(r1);
PHALCON_INIT_VAR(t0);
zend_get_constant("PHP_EOL", strlen("PHP_EOL"), t0 TSRMLS_CC);
PHALCON_CONCAT_SVSVSV(r1, "<div class=\"", css_classes, "\">", msg, "</div>", t0);
zend_print_zval(r1, 1);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_3b3c_0;
fee_3b3c_0:
if(0){}
} else {
return;
}
} else {
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_ALLOC_ZVAL_MM(t1);
zend_get_constant("PHP_EOL", strlen("PHP_EOL"), t1 TSRMLS_CC);
PHALCON_CONCAT_SVSVSV(r2, "<div class=\"", css_classes, "\">", message, "</div>", t1);
zend_print_zval(r2, 1);
}
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Http\Request\File constructor
*
* @param array $file
*/
PHP_METHOD(Phalcon_Http_Request_File, __construct){
zval *file, *name, *temp_name, *size, *type, *error, *key = NULL;
zval *constant, *extension = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &file, &key);
if (Z_TYPE_P(file) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_http_request_exception_ce, "Phalcon\\Http\\Request\\File requires a valid uploaded file");
return;
}
if (phalcon_array_isset_string(file, SS("name"))) {
PHALCON_OBS_VAR(name);
phalcon_array_fetch_string(&name, file, SL("name"), PH_NOISY);
phalcon_update_property_this(this_ptr, SL("_name"), name TSRMLS_CC);
PHALCON_INIT_VAR(constant);
if (zend_get_constant(SL("PATHINFO_EXTENSION"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(&extension, "pathinfo", name, constant);
phalcon_update_property_this(this_ptr, SL("_extension"), extension TSRMLS_CC);
}
}
if (phalcon_array_isset_string(file, SS("tmp_name"))) {
PHALCON_OBS_VAR(temp_name);
phalcon_array_fetch_string(&temp_name, file, SL("tmp_name"), PH_NOISY);
phalcon_update_property_this(this_ptr, SL("_tmp"), temp_name TSRMLS_CC);
} else {
PHALCON_INIT_VAR(temp_name);
ZVAL_NULL(temp_name);
}
if (phalcon_array_isset_string(file, SS("size"))) {
PHALCON_OBS_VAR(size);
phalcon_array_fetch_string(&size, file, SL("size"), PH_NOISY);
phalcon_update_property_this(this_ptr, SL("_size"), size TSRMLS_CC);
}
if (phalcon_array_isset_string(file, SS("type"))) {
PHALCON_OBS_VAR(type);
phalcon_array_fetch_string(&type, file, SL("type"), PH_NOISY);
phalcon_update_property_this(this_ptr, SL("_type"), type TSRMLS_CC);
}
if (phalcon_array_isset_string(file, SS("error"))) {
PHALCON_OBS_VAR(error);
phalcon_array_fetch_string(&error, file, SL("error"), PH_NOISY);
phalcon_update_property_this(this_ptr, SL("_error"), error TSRMLS_CC);
}
if (key) {
phalcon_update_property_this(this_ptr, SL("_key"), key TSRMLS_CC);
}
PHALCON_CALL_PARENT(NULL, phalcon_http_request_file_ce, this_ptr, "__construct", temp_name);
PHALCON_MM_RESTORE();
}
/**
* Gets the real mime type of the upload file using finfo
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Request_File, getRealType){
zval *constant, *finfo = NULL, *temp_file, *mime;
PHALCON_MM_GROW();
mime = phalcon_fetch_nproperty_this(this_ptr, SL("_real_type"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(mime) == IS_STRING) {
RETURN_CTOR(mime);
}
PHALCON_INIT_VAR(constant);
if (!zend_get_constant(SL("FILEINFO_MIME_TYPE"), constant TSRMLS_CC)) {
RETURN_MM_NULL();
}
PHALCON_CALL_FUNCTION(&finfo, "finfo_open", constant);
if (Z_TYPE_P(finfo) != IS_RESOURCE) {
RETURN_MM_NULL();
}
temp_file = phalcon_fetch_nproperty_this(this_ptr, SL("_tmp"), PH_NOISY TSRMLS_CC);
PHALCON_RETURN_CALL_FUNCTION("finfo_file", finfo, temp_file);
PHALCON_CALL_FUNCTION(NULL, "finfo_close", finfo);
PHALCON_MM_RESTORE();
}
/**
* 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();
}
/**
* Commits the internal transaction
*
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, commit){
zval *message = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_transaction"), PH_NOISY_CC);
if (!zend_is_true(t0)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "There is no active transaction");
return;
}
phalcon_update_property_bool(this_ptr, SL("_transaction"), 0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_quenue"), PH_NOISY_CC);
if (!phalcon_valid_foreach(t1 TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(t1);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_654f_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_654f_1;
}
PHALCON_INIT_VAR(message);
ZVAL_ZVAL(message, *hd, 1, 0);
PHALCON_INIT_VAR(t2);
phalcon_read_property(&t2, this_ptr, SL("_fileHandler"), PH_NOISY_CC);
PHALCON_INIT_VAR(r0);
PHALCON_CALL_METHOD(r0, message, "getmessage", PH_NO_CHECK);
PHALCON_INIT_VAR(r1);
PHALCON_CALL_METHOD(r1, message, "gettype", PH_NO_CHECK);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_METHOD(r2, message, "gettime", PH_NO_CHECK);
PHALCON_INIT_VAR(r3);
PHALCON_CALL_METHOD_PARAMS_3(r3, this_ptr, "_applyformat", r0, r1, r2, PH_NO_CHECK);
PHALCON_INIT_VAR(t3);
zend_get_constant(SL("PHP_EOL"), t3 TSRMLS_CC);
PHALCON_INIT_VAR(r4);
PHALCON_CONCAT_VV(r4, r3, t3);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fputs", t2, r4);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_654f_1;
fee_654f_1:
if(0){}
PHALCON_MM_RESTORE();
}
/**
* Get the document type declaration of content
*
* @return string
*/
PHP_METHOD(Phalcon_Tag, getDocType){
zval *doctype = NULL, *declaration, *eol, *doctype_html;
PHALCON_MM_GROW();
PHALCON_OBSERVE_VAR(doctype);
phalcon_read_static_property(&doctype, SL("phalcon\\tag"), SL("_documentType") TSRMLS_CC);
PHALCON_INIT_VAR(eol);
zend_get_constant(SL("PHP_EOL"), eol TSRMLS_CC);
PHALCON_INIT_VAR(declaration);
if (phalcon_compare_strict_long(doctype, 1 TSRMLS_CC)) {
ZVAL_STRING(declaration, " PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\"", 1);
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 2 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD HTML 4.01//EN\"", eol, "\t\"http://www.w3.org/TR/html4/strict.dtd\"");
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 3 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"", eol, "\t\"http://www.w3.org/TR/html4/loose.dtd\"");
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 4 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\"", eol, "\t\"http://www.w3.org/TR/html4/frameset.dtd\"");
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 6 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"", eol, "\t\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\"");
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 7 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"", eol, "\t\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"");
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 8 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD XHTML 1.0 Frameset//EN\"", eol, "\t\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd\"");
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 9 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD XHTML 1.1//EN\"", eol, "\t\"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\"");
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 10 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD XHTML 2.0//EN\"", eol, "\t\"http://www.w3.org/MarkUp/DTD/xhtml2.dtd\"");
goto ph_end_0;
}
ph_end_0:
PHALCON_INIT_VAR(doctype_html);
PHALCON_CONCAT_SVSV(doctype_html, "<!DOCTYPE html", declaration, ">", eol);
RETURN_CTOR(doctype_html);
}
/**
* Sends/Writes messages to the file log
*
* @param string $message
* @param int $type
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, log){
zval *message, *type = NULL, *file_handler, *transaction;
zval *time, *quenue_item, *applied_format, *eol;
zval *applied_eol;
zval *t0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &message, &type) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!type) {
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 7);
}
PHALCON_INIT_VAR(file_handler);
phalcon_read_property(&file_handler, this_ptr, SL("_fileHandler"), PH_NOISY_CC);
if (!zend_is_true(file_handler)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "Cannot send message to the log because it is invalid");
return;
}
PHALCON_INIT_VAR(transaction);
phalcon_read_property(&transaction, this_ptr, SL("_transaction"), PH_NOISY_CC);
if (zend_is_true(transaction)) {
PHALCON_INIT_VAR(time);
PHALCON_CALL_FUNC(time, "time");
PHALCON_INIT_VAR(quenue_item);
object_init_ex(quenue_item, phalcon_logger_item_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(quenue_item, "__construct", message, type, time, PH_CHECK);
PHALCON_INIT_VAR(t0);
phalcon_read_property(&t0, this_ptr, SL("_quenue"), PH_NOISY_CC);
phalcon_array_append(&t0, quenue_item, 0 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_quenue"), t0 TSRMLS_CC);
} else {
PHALCON_INIT_VAR(applied_format);
PHALCON_CALL_METHOD_PARAMS_2(applied_format, this_ptr, "_applyformat", message, type, PH_NO_CHECK);
PHALCON_INIT_VAR(eol);
zend_get_constant(SL("PHP_EOL"), eol TSRMLS_CC);
PHALCON_INIT_VAR(applied_eol);
PHALCON_CONCAT_VV(applied_eol, applied_format, eol);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fwrite", file_handler, applied_eol);
}
PHALCON_MM_RESTORE();
}
long
get_constant_long(char *key)
{
zval zkey;
zval zvalue;
ZVAL_STRING(&zkey, key, 0);
if (!zend_get_constant(Z_STRVAL(zkey), Z_STRLEN(zkey), &zvalue TSRMLS_CC)) {
zend_error(E_ERROR, "get_constant_long(): Cannot find symbol %s, is this function called inside an initialized Phorum environment?", key);
}
convert_to_long(&zvalue);
return Z_LVAL(zvalue);
}
/**
* Get the title of view content
*
* @return string
*/
PHP_METHOD(Phalcon_Tag, getTitle){
zval *document_title = NULL, *eol = NULL, *title_html = NULL;
PHALCON_MM_GROW();
PHALCON_OBSERVE_VAR(document_title);
phalcon_read_static_property(&document_title, SL("phalcon\\tag"), SL("_documentTitle") TSRMLS_CC);
PHALCON_INIT_VAR(eol);
zend_get_constant(SL("PHP_EOL"), eol TSRMLS_CC);
PHALCON_INIT_VAR(title_html);
PHALCON_CONCAT_SVSV(title_html, "<title>", document_title, "</title>", eol);
RETURN_CTOR(title_html);
}
/**
* Create internal connection to memcached
*/
PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, _connect){
zval *options, *memcache, *servers, *client = NULL, *res = NULL;
zend_string *str_key;
ulong idx;
zend_class_entry *ce0;
PHALCON_MM_GROW();
options = phalcon_read_property(getThis(), SL("_options"), PH_NOISY);
ce0 = zend_fetch_class(SSL("Memcached"), ZEND_FETCH_CLASS_AUTO);
PHALCON_INIT_VAR(memcache);
object_init_ex(memcache, ce0);
if (phalcon_has_constructor(memcache)) {
PHALCON_CALL_METHOD(NULL, memcache, "__construct");
}
if (!phalcon_array_isset_str_fetch(&servers, options, SL("servers")) || Z_TYPE_P(servers) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Servers must be an array");
return;
}
phalcon_array_isset_str_fetch(&client, options, SL("client"));
PHALCON_RETURN_CALL_METHOD(memcache, "addservers", servers);
if (!zend_is_true(return_value)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Cannot connect to Memcached server");
return;
}
if (client && Z_TYPE_P(client) == IS_ARRAY) {
zval *value;
ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(client), idx, str_key, value) {
zval option;
if (str_key) {
if ((res = zend_get_constant(str_key)) != NULL) {
PHALCON_CALL_METHOD(NULL, memcache, "setoption", res, value);
}
} else {
ZVAL_LONG(&option, idx);
PHALCON_CALL_METHOD(NULL, memcache, "setoption", &option, value);
}
} ZEND_HASH_FOREACH_END();
/**
* Render the image and return the binary string.
*
* @param string $ext image type to return: png, jpg, gif, etc
* @param int $quality quality of image: 1-100
* @return Phalcon\Image\Adapter
*/
PHP_METHOD(Phalcon_Image_Adapter, render) {
zval *ext = NULL, *quality = NULL, *constant, *file;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 2, &ext, &quality);
if (!ext) {
file = phalcon_fetch_nproperty_this(this_ptr, SL("_file"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(constant);
if (!zend_get_constant(SL("PATHINFO_EXTENSION"), constant TSRMLS_CC)) {
RETURN_MM();
}
ext = NULL;
PHALCON_CALL_FUNCTION(&ext, "pathinfo", file, constant);
if (!PHALCON_IS_NOT_EMPTY(ext)) {
ZVAL_STRING(ext, "png", 1);
}
}
if (!quality) {
PHALCON_INIT_VAR(quality);
ZVAL_LONG(quality, 100);
} else {
if (Z_TYPE_P(quality) != IS_LONG) {
PHALCON_SEPARATE_PARAM(quality);
convert_to_long(quality);
}
}
PHALCON_RETURN_CALL_METHOD(this_ptr, "_render", ext, quality);
RETURN_MM();
}
/**
* Outputs a message formatting it with HTML
*
* @param string $type
* @param string $message
*/
PHP_METHOD(Phalcon_Flash, outputMessage){
zval *type = NULL, *message = NULL, *automatic_html = NULL, *classes = NULL;
zval *type_classes = NULL, *space = NULL, *joined_classes = NULL;
zval *css_classes = NULL, *eol = NULL, *implicit_flush = NULL, *content = NULL;
zval *msg = NULL, *html_message = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &type, &message) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(automatic_html);
phalcon_read_property(&automatic_html, this_ptr, SL("_automaticHtml"), PH_NOISY_CC);
if (PHALCON_IS_TRUE(automatic_html)) {
PHALCON_INIT_VAR(classes);
phalcon_read_property(&classes, this_ptr, SL("_cssClasses"), PH_NOISY_CC);
eval_int = phalcon_array_isset(classes, type);
if (eval_int) {
PHALCON_INIT_VAR(type_classes);
phalcon_array_fetch(&type_classes, classes, type, PH_NOISY_CC);
if (Z_TYPE_P(type_classes) == IS_ARRAY) {
PHALCON_INIT_VAR(space);
ZVAL_STRING(space, " ", 1);
PHALCON_INIT_VAR(joined_classes);
phalcon_fast_join(joined_classes, space, type_classes TSRMLS_CC);
PHALCON_INIT_VAR(css_classes);
PHALCON_CONCAT_SVS(css_classes, " class=\"", joined_classes, "\"");
} else {
PHALCON_INIT_VAR(css_classes);
PHALCON_CONCAT_SVS(css_classes, " class=\"", type_classes, "\"");
}
} else {
PHALCON_INIT_VAR(css_classes);
ZVAL_STRING(css_classes, "", 1);
}
PHALCON_INIT_VAR(eol);
zend_get_constant(SL("PHP_EOL"), eol TSRMLS_CC);
}
PHALCON_INIT_VAR(implicit_flush);
phalcon_read_property(&implicit_flush, this_ptr, SL("_implicitFlush"), PH_NOISY_CC);
if (Z_TYPE_P(message) == IS_ARRAY) {
if (PHALCON_IS_FALSE(implicit_flush)) {
PHALCON_INIT_VAR(content);
ZVAL_STRING(content, "", 1);
}
if (!phalcon_valid_foreach(message TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(message);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_3b3c_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_3b3c_0;
}
PHALCON_INIT_VAR(msg);
ZVAL_ZVAL(msg, *hd, 1, 0);
if (PHALCON_IS_TRUE(automatic_html)) {
PHALCON_INIT_VAR(html_message);
PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", msg, "</div>", eol);
} else {
PHALCON_CPY_WRT(html_message, msg);
}
if (PHALCON_IS_TRUE(implicit_flush)) {
zend_print_zval(html_message, 1);
} else {
phalcon_concat_self(&content, html_message TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_3b3c_0;
fee_3b3c_0:
if (PHALCON_IS_FALSE(implicit_flush)) {
RETURN_CTOR(content);
}
} else {
if (PHALCON_IS_TRUE(automatic_html)) {
PHALCON_INIT_VAR(html_message);
PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", message, "</div>", eol);
} else {
PHALCON_CPY_WRT(html_message, message);
}
if (PHALCON_IS_TRUE(implicit_flush)) {
zend_print_zval(html_message, 1);
} else {
RETURN_CCTOR(html_message);
}
}
PHALCON_MM_RESTORE();
}
ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope, zend_ulong flags)
{
zend_constant *c;
const char *colon;
zend_class_entry *ce = NULL;
zend_string *class_name;
const char *name = cname->val;
size_t name_len = cname->len;
/* Skip leading \\ */
if (name[0] == '\\') {
name += 1;
name_len -= 1;
cname = NULL;
}
if ((colon = zend_memrchr(name, ':', name_len)) &&
colon > name && (*(colon - 1) == ':')) {
int class_name_len = colon - name - 1;
size_t const_name_len = name_len - class_name_len - 2;
zend_string *constant_name = zend_string_init(colon + 1, const_name_len, 0);
char *lcname;
zval *ret_constant = NULL;
ALLOCA_FLAG(use_heap)
class_name = zend_string_init(name, class_name_len, 0);
lcname = do_alloca(class_name_len + 1, use_heap);
zend_str_tolower_copy(lcname, name, class_name_len);
if (!scope) {
if (EG(current_execute_data)) {
scope = EG(scope);
} else {
scope = CG(active_class_entry);
}
}
if (class_name_len == sizeof("self")-1 &&
!memcmp(lcname, "self", sizeof("self")-1)) {
if (UNEXPECTED(!scope)) {
zend_error(E_EXCEPTION | E_ERROR, "Cannot access self:: when no class scope is active");
return NULL;
}
ce = scope;
} else if (class_name_len == sizeof("parent")-1 &&
!memcmp(lcname, "parent", sizeof("parent")-1)) {
if (UNEXPECTED(!scope)) {
zend_error(E_EXCEPTION | E_ERROR, "Cannot access parent:: when no class scope is active");
return NULL;
} else if (UNEXPECTED(!scope->parent)) {
zend_error(E_EXCEPTION | E_ERROR, "Cannot access parent:: when current class scope has no parent");
return NULL;
} else {
ce = scope->parent;
}
} else if (class_name_len == sizeof("static")-1 &&
!memcmp(lcname, "static", sizeof("static")-1)) {
ce = zend_get_called_scope(EG(current_execute_data));
if (UNEXPECTED(!ce)) {
zend_error(E_EXCEPTION | E_ERROR, "Cannot access static:: when no class scope is active");
return NULL;
}
} else {
ce = zend_fetch_class(class_name, flags);
}
free_alloca(lcname, use_heap);
if (ce) {
ret_constant = zend_hash_find(&ce->constants_table, constant_name);
if (ret_constant == NULL) {
if ((flags & ZEND_FETCH_CLASS_SILENT) == 0) {
zend_error(E_EXCEPTION | E_ERROR, "Undefined class constant '%s::%s'", class_name->val, constant_name->val);
zend_string_release(class_name);
zend_string_free(constant_name);
return NULL;
}
} else if (Z_ISREF_P(ret_constant)) {
ret_constant = Z_REFVAL_P(ret_constant);
}
}
zend_string_release(class_name);
zend_string_free(constant_name);
if (ret_constant && Z_CONSTANT_P(ret_constant)) {
if (UNEXPECTED(zval_update_constant_ex(ret_constant, 1, ce) != SUCCESS)) {
return NULL;
}
}
return ret_constant;
}
/* non-class constant */
if ((colon = zend_memrchr(name, '\\', name_len)) != NULL) {
/* compound constant name */
int prefix_len = colon - name;
size_t const_name_len = name_len - prefix_len - 1;
const char *constant_name = colon + 1;
char *lcname;
size_t lcname_len;
ALLOCA_FLAG(use_heap)
lcname_len = prefix_len + 1 + const_name_len;
lcname = do_alloca(lcname_len + 1, use_heap);
zend_str_tolower_copy(lcname, name, prefix_len);
/* Check for namespace constant */
lcname[prefix_len] = '\\';
memcpy(lcname + prefix_len + 1, constant_name, const_name_len + 1);
if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, lcname_len)) == NULL) {
/* try lowercase */
zend_str_tolower(lcname + prefix_len + 1, const_name_len);
if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, lcname_len)) != NULL) {
if ((c->flags & CONST_CS) != 0) {
c = NULL;
}
}
}
free_alloca(lcname, use_heap);
if (c) {
return &c->value;
}
/* name requires runtime resolution, need to check non-namespaced name */
if ((flags & IS_CONSTANT_UNQUALIFIED) != 0) {
return zend_get_constant_str(constant_name, const_name_len);
}
return NULL;
}
if (cname) {
return zend_get_constant(cname);
} else {
return zend_get_constant_str(name, name_len);
}
}
/**
* Makes the work of autoload registered classes
*
* @param string $className
* @return boolean
*/
PHP_METHOD(Phalcon_Loader, autoLoad){
zval *class_name, *events_manager, *event_name = NULL;
zval *classes, *file_path = NULL, *extensions, *ds, *namespace_separator;
zval *empty_str, *zero, *namespaces, *directory = NULL;
zval *prefix = NULL, *prefix_namespace = NULL, *file_name = NULL;
zval *fixed_directory = NULL, *extension = NULL, *complete_path = NULL;
zval *pseudo_separator, *prefixes, *no_prefix_class = NULL;
zval *ds_class_name, *ns_class_name, *directories;
HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5;
HashPosition hp0, hp1, hp2, hp3, hp4, hp5;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &class_name) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_OBS_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "loader:beforeCheckClass", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, class_name);
}
/**
* First we check for static paths for classes
*/
PHALCON_OBS_VAR(classes);
phalcon_read_property(&classes, this_ptr, SL("_classes"), PH_NOISY_CC);
if (Z_TYPE_P(classes) == IS_ARRAY) {
if (phalcon_array_isset(classes, class_name)) {
PHALCON_OBS_VAR(file_path);
phalcon_array_fetch(&file_path, classes, class_name, PH_NOISY_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
if (phalcon_require(file_path TSRMLS_CC) == FAILURE) {
return;
}
RETURN_MM_TRUE;
}
}
PHALCON_OBS_VAR(extensions);
phalcon_read_property(&extensions, this_ptr, SL("_extensions"), PH_NOISY_CC);
PHALCON_INIT_VAR(ds);
zend_get_constant(SL("DIRECTORY_SEPARATOR"), ds TSRMLS_CC);
PHALCON_INIT_VAR(namespace_separator);
ZVAL_STRING(namespace_separator, "\\", 1);
PHALCON_INIT_VAR(empty_str);
ZVAL_STRING(empty_str, "", 1);
PHALCON_INIT_VAR(zero);
ZVAL_LONG(zero, 0);
/**
* Checking in namespaces
*/
PHALCON_OBS_VAR(namespaces);
phalcon_read_property(&namespaces, this_ptr, SL("_namespaces"), PH_NOISY_CC);
if (Z_TYPE_P(namespaces) == IS_ARRAY) {
if (!phalcon_is_iterable(namespaces, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(prefix, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(directory);
/**
* The class name must start with the current namespace
*/
if (phalcon_start_with(class_name, prefix, NULL)) {
/**
* Append the namespace separator to the prefix
*/
PHALCON_INIT_NVAR(prefix_namespace);
PHALCON_CONCAT_VV(prefix_namespace, prefix, namespace_separator);
PHALCON_INIT_NVAR(file_name);
phalcon_fast_str_replace(file_name, prefix_namespace, empty_str, class_name TSRMLS_CC);
if (zend_is_true(file_name)) {
/**
* Add a trailing directory separator if the user forgot to do that
*/
PHALCON_INIT_NVAR(fixed_directory);
phalcon_fix_path(&fixed_directory, directory, ds TSRMLS_CC);
if (!phalcon_is_iterable(extensions, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(extension);
PHALCON_INIT_NVAR(complete_path);
PHALCON_CONCAT_VVSV(complete_path, fixed_directory, file_name, ".", extension);
PHALCON_INIT_NVAR(file_path);
phalcon_fast_str_replace(file_path, namespace_separator, ds, complete_path TSRMLS_CC);
/**
* Check if a events manager is available
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_checkedPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:beforeCheckPath", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr);
}
/**
* This is probably a good path, let's check if the file exist
*/
if (phalcon_file_exists(file_path TSRMLS_CC) == SUCCESS) {
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
/**
* Simulate a require
*/
if (phalcon_require(file_path TSRMLS_CC) == FAILURE) {
return;
}
/**
* Return true mean success
*/
RETURN_MM_TRUE;
}
zend_hash_move_forward_ex(ah1, &hp1);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
PHALCON_INIT_VAR(pseudo_separator);
ZVAL_STRING(pseudo_separator, "_", 1);
/**
* Checking in prefixes
*/
PHALCON_OBS_VAR(prefixes);
phalcon_read_property(&prefixes, this_ptr, SL("_prefixes"), PH_NOISY_CC);
if (Z_TYPE_P(prefixes) == IS_ARRAY) {
if (!phalcon_is_iterable(prefixes, &ah2, &hp2, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(prefix, ah2, hp2);
PHALCON_GET_FOREACH_VALUE(directory);
/**
* The class name starts with the prefix?
*/
if (phalcon_start_with(class_name, prefix, NULL)) {
/**
* Remove the prefix from the class
*/
PHALCON_INIT_NVAR(no_prefix_class);
phalcon_fast_str_replace(no_prefix_class, prefix, empty_str, class_name TSRMLS_CC);
/**
* Change the pseudo-separator '_' by the directory separator
*/
PHALCON_INIT_NVAR(file_name);
phalcon_fast_str_replace(file_name, pseudo_separator, ds, no_prefix_class TSRMLS_CC);
if (zend_is_true(file_name)) {
/**
* Add a trailing directory separator if the user forgot to do that
*/
PHALCON_INIT_NVAR(fixed_directory);
phalcon_fix_path(&fixed_directory, directory, ds TSRMLS_CC);
if (!phalcon_is_iterable(extensions, &ah3, &hp3, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(extension);
PHALCON_INIT_NVAR(complete_path);
PHALCON_CONCAT_VVSV(complete_path, fixed_directory, file_name, ".", extension);
PHALCON_INIT_NVAR(file_path);
phalcon_fast_str_replace(file_path, namespace_separator, ds, complete_path TSRMLS_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_checkedPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:beforeCheckPath", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
if (phalcon_file_exists(file_path TSRMLS_CC) == SUCCESS) {
/**
* Call 'pathFound' event
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
if (phalcon_require(file_path TSRMLS_CC) == FAILURE) {
return;
}
RETURN_MM_TRUE;
}
zend_hash_move_forward_ex(ah3, &hp3);
}
}
}
zend_hash_move_forward_ex(ah2, &hp2);
}
}
/**
* Change the pseudo-separator by the directory separator in the class name
*/
PHALCON_INIT_VAR(ds_class_name);
phalcon_fast_str_replace(ds_class_name, pseudo_separator, ds, class_name TSRMLS_CC);
/**
* And change the namespace separator by directory separator too
*/
PHALCON_INIT_VAR(ns_class_name);
phalcon_fast_str_replace(ns_class_name, namespace_separator, ds, ds_class_name TSRMLS_CC);
/**
* Checking in directories
*/
PHALCON_OBS_VAR(directories);
phalcon_read_property(&directories, this_ptr, SL("_directories"), PH_NOISY_CC);
if (Z_TYPE_P(directories) == IS_ARRAY) {
if (!phalcon_is_iterable(directories, &ah4, &hp4, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(directory);
/**
* Add a trailing directory separator if the user forgot to do that
*/
PHALCON_INIT_NVAR(fixed_directory);
phalcon_fix_path(&fixed_directory, directory, ds TSRMLS_CC);
if (!phalcon_is_iterable(extensions, &ah5, &hp5, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(extension);
/**
* Create a possible path for the file
*/
PHALCON_INIT_NVAR(file_path);
PHALCON_CONCAT_VVSV(file_path, fixed_directory, ns_class_name, ".", extension);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_checkedPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:beforeCheckPath", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
/**
* Check in every directory if the class exists here
*/
if (phalcon_file_exists(file_path TSRMLS_CC) == SUCCESS) {
/**
* Call 'pathFound' event
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
/**
* Simulate a require
*/
if (phalcon_require(file_path TSRMLS_CC) == FAILURE) {
return;
}
/**
* Return true meaning success
*/
RETURN_MM_TRUE;
}
zend_hash_move_forward_ex(ah5, &hp5);
}
zend_hash_move_forward_ex(ah4, &hp4);
}
}
/**
* Call 'afterCheckClass' event
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:afterCheckClass", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, class_name);
}
/**
* Cannot find the class return false
*/
RETURN_MM_FALSE;
}
/** {{{ public ZeStatus::getBrief()
*/
PHP_METHOD(ze_status, getBrief) {
zval * self = NULL;
zval * brief = NULL;
zval * name_z = NULL;
char * name = NULL;
int name_len = 0;
zval ** msg_pp = NULL;
zval * msg_p = NULL;
zval * msg = NULL;
zval * is_debug = NULL;
char * debug_msg = NULL;
int len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s"
, &name, &name_len
) == FAILURE) {
WRONG_PARAM_COUNT;
}
self = getThis();
brief = zend_read_property(ze_status_ce, self, ZEND_STRL(ZE_BRIEF), 1 TSRMLS_CC);
if (!brief) {
RETURN_NULL();
}
do {
if (Z_TYPE_P(brief) == IS_ARRAY && name_len) {
if (zend_hash_find(Z_ARRVAL_P(brief), name, name_len + 1, (void **) &msg_pp) == SUCCESS) {
ALLOC_INIT_ZVAL(msg);
*msg = **msg_pp;
break;
}
} else if (Z_TYPE_P(brief) == IS_OBJECT && name_len) {
msg_p = zend_read_property(Z_OBJCE_P(brief), brief, name, name_len , 1 TSRMLS_CC);
ALLOC_INIT_ZVAL(msg);
*msg = *msg_p;
break;
} else if (Z_TYPE_P(brief) == IS_STRING) {
ALLOC_INIT_ZVAL(msg);
*msg = *brief;
break;
}
} while(0);
if (!msg) {
RETURN_NULL();
}
zval_copy_ctor(msg);
ALLOC_INIT_ZVAL(is_debug);
if (zend_get_constant(ZEND_STRL(ZE_DEBUG), is_debug TSRMLS_CC)) {
convert_to_boolean(is_debug);
name_z = zend_read_property(ze_status_ce, self, ZEND_STRL(ZE_NAME), 0 TSRMLS_CC);
if (Z_BVAL_P(is_debug) && Z_TYPE_P(name_z) == IS_STRING) {
len = spprintf(&debug_msg, len, "[%s]%s", Z_STRVAL_P(name_z), Z_STRVAL_P(msg));
zval_dtor(msg);
FREE_ZVAL(msg);
ALLOC_INIT_ZVAL(msg);
ZVAL_STRINGL(msg, debug_msg, len, 1);
efree(debug_msg);
}
}
FREE_ZVAL(is_debug);
RETURN_ZVAL(msg, 1, 1);
}
ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope, uint32_t flags)
{
zend_constant *c;
const char *colon;
zend_class_entry *ce = NULL;
const char *name = ZSTR_VAL(cname);
size_t name_len = ZSTR_LEN(cname);
/* Skip leading \\ */
if (name[0] == '\\') {
name += 1;
name_len -= 1;
cname = NULL;
}
if ((colon = zend_memrchr(name, ':', name_len)) &&
colon > name && (*(colon - 1) == ':')) {
int class_name_len = colon - name - 1;
size_t const_name_len = name_len - class_name_len - 2;
zend_string *constant_name = zend_string_init(colon + 1, const_name_len, 0);
zend_string *class_name = zend_string_init(name, class_name_len, 0);
zval *ret_constant = NULL;
if (zend_string_equals_literal_ci(class_name, "self")) {
if (UNEXPECTED(!scope)) {
zend_throw_error(NULL, "Cannot access self:: when no class scope is active");
goto failure;
}
ce = scope;
} else if (zend_string_equals_literal_ci(class_name, "parent")) {
if (UNEXPECTED(!scope)) {
zend_throw_error(NULL, "Cannot access parent:: when no class scope is active");
goto failure;
} else if (UNEXPECTED(!scope->parent)) {
zend_throw_error(NULL, "Cannot access parent:: when current class scope has no parent");
goto failure;
} else {
ce = scope->parent;
}
} else if (zend_string_equals_literal_ci(class_name, "static")) {
ce = zend_get_called_scope(EG(current_execute_data));
if (UNEXPECTED(!ce)) {
zend_throw_error(NULL, "Cannot access static:: when no class scope is active");
goto failure;
}
} else {
ce = zend_fetch_class(class_name, flags);
}
if (ce) {
zend_class_constant *c = zend_hash_find_ptr(&ce->constants_table, constant_name);
if (c == NULL) {
if ((flags & ZEND_FETCH_CLASS_SILENT) == 0) {
zend_throw_error(NULL, "Undefined class constant '%s::%s'", ZSTR_VAL(class_name), ZSTR_VAL(constant_name));
goto failure;
}
ret_constant = NULL;
} else {
if (!zend_verify_const_access(c, scope)) {
zend_throw_error(NULL, "Cannot access %s const %s::%s", zend_visibility_string(Z_ACCESS_FLAGS(c->value)), ZSTR_VAL(class_name), ZSTR_VAL(constant_name));
goto failure;
}
ret_constant = &c->value;
}
}
if (ret_constant && Z_CONSTANT_P(ret_constant)) {
if (Z_TYPE_P(ret_constant) == IS_CONSTANT_AST) {
if (IS_CONSTANT_VISITED(ret_constant)) {
zend_throw_error(NULL, "Cannot declare self-referencing constant '%s::%s'", ZSTR_VAL(class_name), ZSTR_VAL(constant_name));
ret_constant = NULL;
goto failure;
}
MARK_CONSTANT_VISITED(ret_constant);
}
if (UNEXPECTED(zval_update_constant_ex(ret_constant, ce) != SUCCESS)) {
RESET_CONSTANT_VISITED(ret_constant);
ret_constant = NULL;
goto failure;
}
RESET_CONSTANT_VISITED(ret_constant);
}
failure:
zend_string_release(class_name);
zend_string_free(constant_name);
return ret_constant;
}
/* non-class constant */
if ((colon = zend_memrchr(name, '\\', name_len)) != NULL) {
/* compound constant name */
int prefix_len = colon - name;
size_t const_name_len = name_len - prefix_len - 1;
const char *constant_name = colon + 1;
char *lcname;
size_t lcname_len;
ALLOCA_FLAG(use_heap)
lcname_len = prefix_len + 1 + const_name_len;
lcname = do_alloca(lcname_len + 1, use_heap);
zend_str_tolower_copy(lcname, name, prefix_len);
/* Check for namespace constant */
lcname[prefix_len] = '\\';
memcpy(lcname + prefix_len + 1, constant_name, const_name_len + 1);
if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, lcname_len)) == NULL) {
/* try lowercase */
zend_str_tolower(lcname + prefix_len + 1, const_name_len);
if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, lcname_len)) != NULL) {
if ((c->flags & CONST_CS) != 0) {
c = NULL;
}
}
}
free_alloca(lcname, use_heap);
if (c) {
return &c->value;
}
/* name requires runtime resolution, need to check non-namespaced name */
if ((flags & IS_CONSTANT_UNQUALIFIED) != 0) {
return zend_get_constant_str(constant_name, const_name_len);
}
return NULL;
}
if (cname) {
return zend_get_constant(cname);
} else {
return zend_get_constant_str(name, name_len);
}
}
/* Given a type-library, merge it into the current engine state */
PHP_COM_DOTNET_API int php_com_import_typelib(ITypeLib *TL, int mode, int codepage TSRMLS_DC)
{
int i, j, interfaces;
TYPEKIND pTKind;
ITypeInfo *TypeInfo;
VARDESC *pVarDesc;
UINT NameCount;
BSTR bstr_ids;
zend_constant c;
zval *exists, results, value;
char *const_name;
int len;
if (TL == NULL) {
return FAILURE;
}
interfaces = ITypeLib_GetTypeInfoCount(TL);
for (i = 0; i < interfaces; i++) {
ITypeLib_GetTypeInfoType(TL, i, &pTKind);
if (pTKind == TKIND_ENUM) {
ITypeLib_GetTypeInfo(TL, i, &TypeInfo);
for (j = 0; ; j++) {
if (FAILED(ITypeInfo_GetVarDesc(TypeInfo, j, &pVarDesc))) {
break;
}
ITypeInfo_GetNames(TypeInfo, pVarDesc->memid, &bstr_ids, 1, &NameCount);
if (NameCount != 1) {
ITypeInfo_ReleaseVarDesc(TypeInfo, pVarDesc);
continue;
}
const_name = php_com_olestring_to_string(bstr_ids, &len, codepage TSRMLS_CC);
c.name = STR_INIT(const_name, len, 1);
// TODO: avoid reallocation???
efree(const_name);
if(c.name == NULL) {
ITypeInfo_ReleaseVarDesc(TypeInfo, pVarDesc);
continue;
}
//??? c.name_len++; /* include NUL */
SysFreeString(bstr_ids);
/* sanity check for the case where the constant is already defined */
if ((exists = zend_get_constant(c.name TSRMLS_CC)) != NULL) {
if (COMG(autoreg_verbose) && !compare_function(&results, &c.value, exists TSRMLS_CC)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type library constant %s is already defined", c.name);
}
STR_RELEASE(c.name);
ITypeInfo_ReleaseVarDesc(TypeInfo, pVarDesc);
continue;
}
/* register the constant */
php_com_zval_from_variant(&value, pVarDesc->lpvarValue, codepage TSRMLS_CC);
if (Z_TYPE(value) == IS_INT) {
c.flags = mode;
ZVAL_INT(&c.value, Z_IVAL(value));
c.module_number = 0;
zend_register_constant(&c TSRMLS_CC);
}
ITypeInfo_ReleaseVarDesc(TypeInfo, pVarDesc);
}
ITypeInfo_Release(TypeInfo);
}
}
return SUCCESS;
}
/**
* Generates a SELECT tag
*
* @param array $parameters
* @param array $data
*/
PHP_METHOD(Phalcon_Tag_Select, selectField){
zval *parameters, *data = NULL, *params = NULL, *eol, *id = NULL, *name, *value = NULL;
zval *use_empty = NULL, *empty_value = NULL, *empty_text = NULL, *code;
zval *avalue = NULL, *key = NULL, *close_option, *options = NULL, *using;
zval *resultset_options, *array_options;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", ¶meters, &data) == FAILURE) {
RETURN_MM_NULL();
}
if (!data) {
PHALCON_INIT_VAR(data);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init_size(params, 2);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(¶ms, data, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
PHALCON_INIT_VAR(eol);
zend_get_constant(SL("PHP_EOL"), eol TSRMLS_CC);
if (!phalcon_array_isset_long(params, 0)) {
PHALCON_OBS_VAR(id);
phalcon_array_fetch_string(&id, params, SL("id"), PH_NOISY_CC);
phalcon_array_update_long(¶ms, 0, &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_OBS_NVAR(id);
phalcon_array_fetch_long(&id, params, 0, PH_NOISY_CC);
if (!phalcon_array_isset_string(params, SS("name"))) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_OBS_VAR(name);
phalcon_array_fetch_string(&name, params, SL("name"), PH_NOISY_CC);
if (!zend_is_true(name)) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
if (!phalcon_array_isset_string(params, SS("id"))) {
phalcon_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
if (!phalcon_array_isset_string(params, SS("value"))) {
PHALCON_INIT_VAR(value);
PHALCON_CALL_STATIC_PARAMS_2(value, "phalcon\\tag", "getvalue", id, params);
} else {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch_string(&value, params, SL("value"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SS("value"));
}
PHALCON_INIT_VAR(use_empty);
ZVAL_BOOL(use_empty, 0);
if (phalcon_array_isset_string(params, SS("useEmpty"))) {
if (!phalcon_array_isset_string(params, SS("emptyValue"))) {
PHALCON_INIT_VAR(empty_value);
ZVAL_STRING(empty_value, "", 1);
} else {
PHALCON_OBS_NVAR(empty_value);
phalcon_array_fetch_string(&empty_value, params, SL("emptyValue"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SS("emptyValue"));
}
if (!phalcon_array_isset_string(params, SS("emptyText"))) {
PHALCON_INIT_VAR(empty_text);
ZVAL_STRING(empty_text, "Choose...", 1);
} else {
PHALCON_OBS_NVAR(empty_text);
phalcon_array_fetch_string(&empty_text, params, SL("emptyText"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SS("emptyText"));
}
PHALCON_OBS_NVAR(use_empty);
phalcon_array_fetch_string(&use_empty, params, SL("useEmpty"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SS("useEmpty"));
}
PHALCON_INIT_VAR(code);
ZVAL_STRING(code, "<select", 1);
if (Z_TYPE_P(params) == IS_ARRAY) {
if (!phalcon_is_iterable(params, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(avalue);
if (Z_TYPE_P(key) != IS_LONG) {
if (Z_TYPE_P(avalue) != IS_ARRAY) {
PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", avalue, "\"");
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
PHALCON_SCONCAT_SV(code, ">", eol);
PHALCON_INIT_VAR(close_option);
PHALCON_CONCAT_SV(close_option, "</option>", eol);
if (zend_is_true(use_empty)) {
/**
* Create an empty value
*/
PHALCON_SCONCAT_SVSVV(code, "\t<option value=\"", empty_value, "\">", empty_text, close_option);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SS("useEmpty"));
}
if (phalcon_array_isset_long(params, 1)) {
PHALCON_OBS_VAR(options);
phalcon_array_fetch_long(&options, params, 1, PH_NOISY_CC);
} else {
PHALCON_CPY_WRT(options, data);
}
if (Z_TYPE_P(options) == IS_OBJECT) {
/**
* The options is a resultset
*/
if (!phalcon_array_isset_string(params, SS("using"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter is required");
return;
} else {
PHALCON_OBS_VAR(using);
phalcon_array_fetch_string(&using, params, SL("using"), PH_NOISY_CC);
if (Z_TYPE_P(using) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter should be an Array");
return;
}
}
/**
* Create the SELECT's option from a resultset
*/
PHALCON_INIT_VAR(resultset_options);
PHALCON_CALL_SELF_PARAMS_4(resultset_options, this_ptr, "_optionsfromresultset", options, using, value, close_option);
phalcon_concat_self(&code, resultset_options TSRMLS_CC);
} else {
if (Z_TYPE_P(options) == IS_ARRAY) {
/**
* Makes the work of autoload registered classes
*
* @param string $className
* @return boolean
*/
PHP_METHOD(Phalcon_Loader, autoLoad){
zval *class_name = NULL, *file_name = NULL, *directory = NULL, *preffix = NULL;
zval *path = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = 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;
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", &class_name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_classes"), PHALCON_NOISY TSRMLS_CC);
eval_int = phalcon_array_isset(t0, class_name);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_classes"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch(&r0, t1, class_name, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(file_name, r0);
if (phalcon_require(file_name TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, SL("_namespaces"), 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_0c08_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_0c08_0;
} else {
PHALCON_INIT_VAR(preffix);
PHALCON_GET_FOREACH_KEY(preffix, ah0, hp0);
}
PHALCON_INIT_VAR(directory);
ZVAL_ZVAL(directory, *hd, 1, 0);
PHALCON_INIT_VAR(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "strlen", class_name);
PHALCON_INIT_VAR(r2);
is_smaller_function(r2, preffix, r1 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_INIT_VAR(c0);
ZVAL_LONG(c0, 0);
PHALCON_INIT_VAR(r3);
PHALCON_CALL_FUNC_PARAMS_1(r3, "strlen", preffix);
PHALCON_INIT_VAR(r4);
PHALCON_CALL_FUNC_PARAMS_3(r4, "substr", class_name, c0, r3);
PHALCON_INIT_VAR(r5);
is_equal_function(r5, r4, preffix TSRMLS_CC);
if (zend_is_true(r5)) {
PHALCON_INIT_VAR(r6);
PHALCON_CONCAT_VS(r6, preffix, "\\");
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "", 1);
PHALCON_INIT_VAR(r7);
phalcon_fast_str_replace(r7, r6, c1, class_name TSRMLS_CC);
PHALCON_CPY_WRT(file_name, r7);
if (zend_is_true(file_name)) {
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "\\", 1);
PHALCON_INIT_VAR(t3);
zend_get_constant("DIRECTORY_SEPARATOR", strlen("DIRECTORY_SEPARATOR"), t3 TSRMLS_CC);
PHALCON_INIT_VAR(r8);
PHALCON_CONCAT_VVS(r8, directory, file_name, ".php");
PHALCON_INIT_VAR(r9);
phalcon_fast_str_replace(r9, c2, t3, r8 TSRMLS_CC);
PHALCON_CPY_WRT(path, r9);
if (phalcon_file_exists(path TSRMLS_CC) == SUCCESS) {
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_0c08_0;
fee_0c08_0:
if(0){}
} else {
return;
}
PHALCON_ALLOC_ZVAL_MM(t4);
phalcon_read_property(&t4, this_ptr, SL("_directories"), 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_0c08_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_0c08_1;
}
PHALCON_INIT_VAR(directory);
ZVAL_ZVAL(directory, *hd, 1, 0);
PHALCON_INIT_VAR(r10);
PHALCON_CONCAT_VVS(r10, directory, class_name, ".php");
PHALCON_CPY_WRT(path, r10);
if (phalcon_file_exists(path TSRMLS_CC) == SUCCESS) {
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_0c08_1;
fee_0c08_1:
if(0){}
} else {
return;
}
PHALCON_MM_RESTORE();
}
PHP_METHOD(Phalcon_Http_Client_Adapter_Curl, sendInternal){
zval *uri = NULL, *url = NULL, *method, *useragent, *data, *type, *files, *timeout, *curl, *username, *password, *authtype;
zval *file = NULL, *body, *uniqid = NULL, *boundary, *key = NULL, *value = NULL;
zval *path_parts = NULL, *filename, *basename, *filedata = NULL;
zval *constant, *header, *headers = NULL;
zval *content = NULL, *errorno = NULL, *error = NULL, *headersize = NULL, *httpcode = NULL, *headerstr, *bodystr, *response, *tmp = NULL;
zend_class_entry *curlfile_ce;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
PHALCON_CALL_SELF(&uri, "geturi");
PHALCON_CALL_METHOD(&url, uri, "build");
method = phalcon_fetch_nproperty_this(this_ptr, SL("_method"), PH_NOISY TSRMLS_CC);
useragent = phalcon_fetch_nproperty_this(this_ptr, SL("_useragent"), PH_NOISY TSRMLS_CC);
data = phalcon_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY TSRMLS_CC);
type = phalcon_fetch_nproperty_this(this_ptr, SL("_type"), PH_NOISY TSRMLS_CC);
files = phalcon_fetch_nproperty_this(this_ptr, SL("_files"), PH_NOISY TSRMLS_CC);
timeout = phalcon_fetch_nproperty_this(this_ptr, SL("_timeout"), PH_NOISY TSRMLS_CC);
curl = phalcon_fetch_nproperty_this(this_ptr, SL("_curl"), PH_NOISY TSRMLS_CC);
username = phalcon_fetch_nproperty_this(this_ptr, SL("_username"), PH_NOISY TSRMLS_CC);
password = phalcon_fetch_nproperty_this(this_ptr, SL("_password"), PH_NOISY TSRMLS_CC);
authtype = phalcon_fetch_nproperty_this(this_ptr, SL("_authtype"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(constant);
if (!zend_get_constant(SL("CURLOPT_URL"), constant TSRMLS_CC)) {
RETURN_MM_FALSE;
}
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, url);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_CONNECTTIMEOUT"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, timeout);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_TIMEOUT"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, timeout);
}
PHALCON_INIT_NVAR(constant);
if (PHALCON_IS_NOT_EMPTY(method) && zend_get_constant(SL("CURLOPT_CUSTOMREQUEST"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, method);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERAGENT"), constant TSRMLS_CC) && PHALCON_IS_NOT_EMPTY(useragent)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, useragent);
}
header = phalcon_fetch_nproperty_this(this_ptr, SL("_header"), PH_NOISY TSRMLS_CC);
if (PHALCON_IS_NOT_EMPTY(username)) {
if (PHALCON_IS_STRING(authtype, "any")) {
PHALCON_INIT_NVAR(constant);
PHALCON_INIT_NVAR(tmp);
if (zend_get_constant(SL("CURLOPT_HTTPAUTH"), constant TSRMLS_CC) && zend_get_constant(SL("CURLAUTH_ANY"), tmp TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERPWD"), constant TSRMLS_CC)) {
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSV(tmp, username, ":", password);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
}
}
} else if (PHALCON_IS_STRING(authtype, "basic")) {
PHALCON_INIT_NVAR(constant);
PHALCON_INIT_NVAR(tmp);
if (zend_get_constant(SL("CURLOPT_HTTPAUTH"), constant TSRMLS_CC) && zend_get_constant(SL("CURLAUTH_BASIC"), tmp TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERPWD"), constant TSRMLS_CC)) {
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSV(tmp, username, ":", password);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
}
}
} else if (PHALCON_IS_STRING(authtype, "digest")) {
PHALCON_INIT_NVAR(constant);
PHALCON_INIT_NVAR(tmp);
if (zend_get_constant(SL("CURLOPT_HTTPAUTH"), constant TSRMLS_CC) && zend_get_constant(SL("CURLAUTH_DIGEST"), tmp TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERPWD"), constant TSRMLS_CC)) {
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSV(tmp, username, ":", password);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
}
}
}
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_SAFE_UPLOAD"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, PHALCON_GLOBAL(z_true));
}
if (Z_TYPE_P(data) == IS_STRING && PHALCON_IS_NOT_EMPTY(data)) {
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Type", 1);
if (PHALCON_IS_EMPTY(type)) {
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "application/x-www-form-urlencoded", 1);
}
PHALCON_CALL_METHOD(NULL, header, "set", key, type);
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_POSTFIELDS"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, data);
} else if (phalcon_class_exists(SL("CURLFile"), 0 TSRMLS_CC)) {
if (Z_TYPE_P(data) != IS_ARRAY) {
PHALCON_INIT_NVAR(data);
array_init(data);
}
if (Z_TYPE_P(files) == IS_ARRAY) {
phalcon_is_iterable(files, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(file);
if (PHALCON_IS_NOT_EMPTY(file)) {
curlfile_ce = zend_fetch_class(SL("CURLFile"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_NVAR(tmp);
object_init_ex(tmp, curlfile_ce);
PHALCON_CALL_METHOD(NULL, tmp, "__construct", file);
phalcon_array_append(&data, tmp, PH_COPY);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_POSTFIELDS"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, data);
} else {
PHALCON_CALL_FUNCTION(&uniqid, "uniqid");
PHALCON_INIT_VAR(boundary);
PHALCON_CONCAT_SV(boundary, "--------------", uniqid);
PHALCON_INIT_VAR(body);
if (Z_TYPE_P(data) == IS_ARRAY) {
phalcon_is_iterable(data, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(key, ah0, hp0);
PHALCON_GET_HVALUE(value);
PHALCON_SCONCAT_SVS(body, "--", boundary, "\r\n");
PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", key, "\"\r\n\r\n", value, "\r\n");
zend_hash_move_forward_ex(ah0, &hp0);
}
}
if (Z_TYPE_P(files) == IS_ARRAY) {
phalcon_is_iterable(files, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(file);
if (PHALCON_IS_NOT_EMPTY(file)) {
PHALCON_CALL_FUNCTION(&path_parts, "pathinfo", file);
if (phalcon_array_isset_string_fetch(&filename, path_parts, SS("filename")) && phalcon_array_isset_string_fetch(&basename, path_parts, SS("basename"))) {
PHALCON_CALL_FUNCTION(&filedata, "file_get_contents", file);
PHALCON_SCONCAT_SVS(body, "--", boundary, "\r\n");
PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", filename, "\"; filename=\"", basename, "\"\r\n");
PHALCON_SCONCAT_SVS(body, "Content-Type: application/octet-stream\r\n\r\n", filedata, "\r\n");
}
}
zend_hash_move_forward_ex(ah1, &hp1);
}
}
if (!PHALCON_IS_EMPTY(body)) {
PHALCON_SCONCAT_SVS(body, "--", boundary, "--\r\n");
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Type", 1);
PHALCON_INIT_NVAR(value);
PHALCON_CONCAT_SV(value, "multipart/form-data; boundary=", boundary);
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Length", 1);
PHALCON_INIT_NVAR(value);
ZVAL_LONG(value, Z_STRLEN_P(body));
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_CALL_METHOD(&headers, header, "build");
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_POSTFIELDS"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, body);
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_HTTPHEADER"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, headers);
}
}
PHALCON_CALL_FUNCTION(&content, "curl_exec", curl);
PHALCON_CALL_FUNCTION(&errorno, "curl_errno", curl);
if (PHALCON_IS_TRUE(errorno)) {
PHALCON_CALL_FUNCTION(&error, "curl_error", curl);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_http_client_exception_ce, error);
return;
}
PHALCON_INIT_VAR(response);
object_init_ex(response, phalcon_http_client_response_ce);
PHALCON_CALL_METHOD(NULL, response, "__construct");
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLINFO_HTTP_CODE"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(&httpcode, "curl_getinfo", curl, constant);
PHALCON_CALL_METHOD(NULL, response, "setstatuscode", httpcode);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLINFO_HEADER_SIZE"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(&headersize, "curl_getinfo", curl, constant);
PHALCON_INIT_VAR(headerstr);
phalcon_substr(headerstr, content, 0 , Z_LVAL_P(headersize));
PHALCON_INIT_VAR(bodystr);
phalcon_substr(bodystr, content, Z_LVAL_P(headersize) , Z_STRLEN_P(content));
PHALCON_CALL_METHOD(NULL, response, "setheader", headerstr);
PHALCON_CALL_METHOD(NULL, response, "setbody", bodystr);
}
RETURN_CTOR(response);
}
PHP_METHOD(Phalcon_Flash, _showMessage){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL, *v3 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *c0 = NULL;
zval *t0 = NULL, *t1 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &v0, &v1) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(v1) == IS_ARRAY) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " ", 1);
PHALCON_CALL_FUNC_PARAMS_2(r0, "join", c0, v1, 0x00F);
PHALCON_CPY_WRT(v2, r0);
} else {
PHALCON_CPY_WRT(v2, v1);
}
if (Z_TYPE_P(v0) == IS_ARRAY) {
if (Z_TYPE_P(v0) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument supplied for foreach()");
} else {
ah0 = Z_ARRVAL_P(v0);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_3b3c_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_3b3c_0;
}
PHALCON_INIT_VAR(v3);
ZVAL_ZVAL(v3, *hd, 1, 0);
PHALCON_INIT_VAR(r3);
PHALCON_CONCAT_LEFT(r3, "<div class=\"", v2);
PHALCON_INIT_VAR(r2);
PHALCON_CONCAT_VBOTH(r2, r3, "\">", v3);
PHALCON_INIT_VAR(t0);
zend_get_constant("PHP_EOL", strlen("PHP_EOL"), t0 TSRMLS_CC);
PHALCON_INIT_VAR(r1);
PHALCON_CONCAT_VBOTH(r1, r2, "</div>", t0);
zend_print_zval(r1, 0);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_3b3c_0;
fee_3b3c_0:
if(0){ };
}
} else {
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_CONCAT_LEFT(r6, "<div class=\"", v2);
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CONCAT_VBOTH(r5, r6, "\">", v0);
PHALCON_ALLOC_ZVAL_MM(t1);
zend_get_constant("PHP_EOL", strlen("PHP_EOL"), t1 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CONCAT_VBOTH(r4, r5, "</div>", t1);
zend_print_zval(r4, 0);
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Makes the work of autoload registered classes
*
* @param string $className
* @return boolean
*/
PHP_METHOD(Phalcon_Loader, autoLoad){
zval *class_name = NULL, *events_manager = NULL, *classes = NULL;
zval *file_path = NULL, *extensions = NULL, *namespaces = NULL, *ds = NULL;
zval *directory = NULL, *preffix = NULL, *file_name = NULL, *extension = NULL;
zval *path = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL, *c3 = NULL, *c4 = NULL, *c5 = NULL, *c6 = NULL;
zval *c7 = NULL, *c8 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL;
zval *t0 = NULL;
HashTable *ah0, *ah1, *ah2, *ah3;
HashPosition hp0, hp1, hp2, hp3;
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", &class_name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (zend_is_true(events_manager)) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "loader:beforeCheckClass", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c0, this_ptr, PH_NO_CHECK);
}
PHALCON_INIT_VAR(classes);
phalcon_read_property(&classes, this_ptr, SL("_classes"), PH_NOISY_CC);
eval_int = phalcon_array_isset(classes, class_name);
if (eval_int) {
PHALCON_INIT_VAR(file_path);
phalcon_array_fetch(&file_path, classes, class_name, PH_NOISY_CC);
if (zend_is_true(events_manager)) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c1, this_ptr, PH_NO_CHECK);
}
if (phalcon_require(file_path TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
PHALCON_INIT_VAR(extensions);
phalcon_read_property(&extensions, this_ptr, SL("_extensions"), PH_NOISY_CC);
PHALCON_INIT_VAR(namespaces);
phalcon_read_property(&namespaces, this_ptr, SL("_namespaces"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_count(r0, namespaces TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_INIT_VAR(ds);
zend_get_constant(SL("DIRECTORY_SEPARATOR"), ds TSRMLS_CC);
if (!phalcon_valid_foreach(namespaces TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(namespaces);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_0c08_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_0c08_0;
}
PHALCON_INIT_VAR(preffix);
PHALCON_GET_FOREACH_KEY(preffix, ah0, hp0);
PHALCON_INIT_VAR(directory);
ZVAL_ZVAL(directory, *hd, 1, 0);
PHALCON_INIT_VAR(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "strlen", class_name);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_FUNC_PARAMS_1(r2, "strlen", preffix);
PHALCON_INIT_VAR(r3);
is_smaller_function(r3, r2, r1 TSRMLS_CC);
if (zend_is_true(r3)) {
PHALCON_INIT_VAR(c2);
ZVAL_LONG(c2, 0);
PHALCON_INIT_VAR(r4);
PHALCON_CALL_FUNC_PARAMS_1(r4, "strlen", preffix);
PHALCON_INIT_VAR(r5);
PHALCON_CALL_FUNC_PARAMS_3(r5, "substr", class_name, c2, r4);
PHALCON_INIT_VAR(r6);
is_equal_function(r6, r5, preffix TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_INIT_VAR(r7);
PHALCON_CONCAT_VS(r7, preffix, "\\");
PHALCON_INIT_VAR(c3);
ZVAL_STRING(c3, "", 1);
PHALCON_INIT_VAR(file_name);
phalcon_fast_str_replace(file_name, r7, c3, class_name TSRMLS_CC);
if (zend_is_true(file_name)) {
if (!phalcon_valid_foreach(extensions TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(extensions);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_0c08_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_0c08_1;
}
PHALCON_INIT_VAR(extension);
ZVAL_ZVAL(extension, *hd, 1, 0);
PHALCON_INIT_VAR(c4);
ZVAL_STRING(c4, "\\", 1);
PHALCON_INIT_VAR(r8);
PHALCON_CONCAT_VVSV(r8, directory, file_name, ".", extension);
PHALCON_INIT_VAR(path);
phalcon_fast_str_replace(path, c4, ds, r8 TSRMLS_CC);
if (zend_is_true(events_manager)) {
phalcon_update_property_zval(this_ptr, SL("_checkedPath"), path TSRMLS_CC);
PHALCON_INIT_VAR(c5);
ZVAL_STRING(c5, "loader:beforeCheckPath", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c5, this_ptr, PH_NO_CHECK);
}
if (phalcon_file_exists(path TSRMLS_CC) == SUCCESS) {
if (zend_is_true(events_manager)) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_VAR(c6);
ZVAL_STRING(c6, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c6, this_ptr, PH_NO_CHECK);
}
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_0c08_1;
fee_0c08_1:
if(0){}
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_0c08_0;
fee_0c08_0:
if(0){}
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_directories"), PH_NOISY_CC);
if (!phalcon_valid_foreach(t0 TSRMLS_CC)) {
return;
}
ah2 = Z_ARRVAL_P(t0);
zend_hash_internal_pointer_reset_ex(ah2, &hp2);
fes_0c08_2:
if(zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) != SUCCESS){
goto fee_0c08_2;
}
PHALCON_INIT_VAR(directory);
ZVAL_ZVAL(directory, *hd, 1, 0);
if (!phalcon_valid_foreach(extensions TSRMLS_CC)) {
return;
}
ah3 = Z_ARRVAL_P(extensions);
zend_hash_internal_pointer_reset_ex(ah3, &hp3);
fes_0c08_3:
if(zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) != SUCCESS){
goto fee_0c08_3;
}
PHALCON_INIT_VAR(extension);
ZVAL_ZVAL(extension, *hd, 1, 0);
PHALCON_INIT_VAR(path);
PHALCON_CONCAT_VVSV(path, directory, class_name, ".", extension);
if (zend_is_true(events_manager)) {
phalcon_update_property_zval(this_ptr, SL("_checkedPath"), path TSRMLS_CC);
PHALCON_INIT_VAR(c7);
ZVAL_STRING(c7, "loader:beforeCheckPath", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c7, this_ptr, PH_NO_CHECK);
}
if (phalcon_file_exists(path TSRMLS_CC) == SUCCESS) {
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
zend_hash_move_forward_ex(ah3, &hp3);
goto fes_0c08_3;
fee_0c08_3:
if(0){}
zend_hash_move_forward_ex(ah2, &hp2);
goto fes_0c08_2;
fee_0c08_2:
if(0){}
if (zend_is_true(events_manager)) {
PHALCON_INIT_VAR(c8);
ZVAL_STRING(c8, "loader:afterCheckClass", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c8, this_ptr, PH_NO_CHECK);
}
RETURN_CCTOR(this_ptr);
}
PHP_METHOD(Phalcon_Http_Client_Adapter_Curl, __construct){
zval *uri = NULL, *method = NULL, *upper_method, *header, *curl = NULL, *options, *constant;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 2, &uri, &method);
if (uri) {
PHALCON_CALL_SELF(NULL, "setbaseuri", uri);
}
if (method) {
PHALCON_INIT_VAR(upper_method);
phalcon_fast_strtoupper(upper_method, method);
phalcon_update_property_this(this_ptr, SL("_method"), upper_method TSRMLS_CC);
}
PHALCON_INIT_VAR(header);
object_init_ex(header, phalcon_http_client_header_ce);
PHALCON_CALL_METHOD(NULL, header, "__construct");
phalcon_update_property_this(this_ptr, SL("_header"), header TSRMLS_CC);
PHALCON_CALL_FUNCTION(&curl, "curl_init");
PHALCON_INIT_VAR(options);
array_init(options);
PHALCON_INIT_VAR(constant);
if (zend_get_constant(SL("CURLOPT_RETURNTRANSFER"), constant TSRMLS_CC)) {
phalcon_array_update_zval_bool(&options, constant, 1, PH_COPY);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_AUTOREFERER"), constant TSRMLS_CC)) {
phalcon_array_update_zval_bool(&options, constant, 1, PH_COPY);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_FOLLOWLOCATION"), constant TSRMLS_CC)) {
phalcon_array_update_zval_bool(&options, constant, 1, PH_COPY);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_MAXREDIRS"), constant TSRMLS_CC)) {
phalcon_array_update_zval_long(&options, constant, 20, PH_COPY);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_HEADER"), constant TSRMLS_CC)) {
phalcon_array_update_zval_bool(&options, constant, 1, PH_COPY);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERAGENT"), constant TSRMLS_CC)) {
phalcon_array_update_zval_string(&options, constant, SL("Phalcon HTTP Client(Curl)"), PH_COPY);
}
PHALCON_CALL_FUNCTION(NULL, "curl_setopt_array", curl, options);
phalcon_update_property_this(this_ptr, SL("_curl"), curl TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Commits the internal transaction
*
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, commit){
zval *transaction = NULL, *file_handler = NULL, *quenue = NULL, *message = NULL;
zval *message_str = NULL, *type = NULL, *time = NULL, *applied_format = NULL;
zval *applied_eol = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(transaction);
phalcon_read_property(&transaction, this_ptr, SL("_transaction"), PH_NOISY_CC);
if (!zend_is_true(transaction)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "There is no active transaction");
return;
}
phalcon_update_property_bool(this_ptr, SL("_transaction"), 0 TSRMLS_CC);
PHALCON_INIT_VAR(file_handler);
phalcon_read_property(&file_handler, this_ptr, SL("_fileHandler"), PH_NOISY_CC);
PHALCON_INIT_VAR(quenue);
phalcon_read_property(&quenue, this_ptr, SL("_quenue"), PH_NOISY_CC);
if (!phalcon_valid_foreach(quenue TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(quenue);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_654f_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_654f_1;
}
PHALCON_INIT_VAR(message);
ZVAL_ZVAL(message, *hd, 1, 0);
PHALCON_INIT_VAR(message_str);
PHALCON_CALL_METHOD(message_str, message, "getmessage", PH_NO_CHECK);
PHALCON_INIT_VAR(type);
PHALCON_CALL_METHOD(type, message, "gettype", PH_NO_CHECK);
PHALCON_INIT_VAR(time);
PHALCON_CALL_METHOD(time, message, "gettime", PH_NO_CHECK);
PHALCON_INIT_VAR(applied_format);
PHALCON_CALL_METHOD_PARAMS_3(applied_format, this_ptr, "_applyformat", message_str, type, time, PH_NO_CHECK);
PHALCON_INIT_VAR(t0);
zend_get_constant(SL("PHP_EOL"), t0 TSRMLS_CC);
PHALCON_INIT_VAR(applied_eol);
PHALCON_CONCAT_VV(applied_eol, applied_format, t0);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fputs", file_handler, applied_eol);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_654f_1;
fee_654f_1:
if(0){}
PHALCON_MM_RESTORE();
}
/**
* Save the image. If the filename is omitted, the original image will
* be overwritten.
*
* @param string $file new image path
* @param int $quality quality of image: 1-100
* @return boolean
*/
PHP_METHOD(Phalcon_Image_Adapter, save) {
zval **fname = NULL, **q = NULL;
zval *file, *quality;
zval *ret = NULL, *dir, *constant;
phalcon_fetch_params_ex(0, 2, &fname, &q);
PHALCON_MM_GROW();
if (!fname) {
PHALCON_OBS_VAR(file);
phalcon_read_property_this(&file, this_ptr, SL("_realpath"), PH_NOISY TSRMLS_CC);
convert_to_string_ex(&file);
}
else {
PHALCON_ENSURE_IS_STRING(fname);
file = *fname;
}
PHALCON_INIT_VAR(quality);
if (!q || Z_TYPE_PP(q) != IS_LONG) {
ZVAL_LONG(quality, 100);
} else if (Z_LVAL_PP(q) > 100) {
ZVAL_LONG(quality, 100);
} else if (Z_LVAL_PP(q) < 1) {
ZVAL_LONG(quality, 1);
} else {
ZVAL_LONG(quality, Z_LVAL_PP(q));
}
PHALCON_CALL_FUNCTION(&ret, "is_file", file);
if (zend_is_true(ret)) {
PHALCON_CALL_FUNCTION(&ret, "is_writable", file);
if (!zend_is_true(ret)) {
zend_throw_exception_ex(phalcon_image_exception_ce, 0 TSRMLS_CC, "File must be writable: '%s'", Z_STRVAL_P(file));
RETURN_MM();
}
} else {
PHALCON_INIT_VAR(constant);
if (!zend_get_constant(SL("PATHINFO_DIRNAME"), constant TSRMLS_CC)) {
RETURN_MM();
}
PHALCON_CALL_FUNCTION(&ret, "pathinfo", file, constant);
PHALCON_INIT_VAR(dir);
phalcon_realpath(dir, ret TSRMLS_CC);
convert_to_string(dir);
PHALCON_INIT_NVAR(ret);
phalcon_is_dir(ret, dir TSRMLS_CC);
if (!zend_is_true(ret)) {
zend_throw_exception_ex(phalcon_image_exception_ce, 0 TSRMLS_CC, "Directory must be writable: '%s'", Z_STRVAL_P(dir));
RETURN_MM();
}
PHALCON_CALL_FUNCTION(&ret, "is_writable", dir);
if (!zend_is_true(ret)) {
zend_throw_exception_ex(phalcon_image_exception_ce, 0 TSRMLS_CC, "Directory must be writable: '%s'", Z_STRVAL_P(dir));
RETURN_MM();
}
}
PHALCON_RETURN_CALL_METHOD(this_ptr, "_save", file, quality);
RETURN_MM();
}
PHP_METHOD(Phalcon_Tag_Select, select){
zval *parameters = NULL, *data = NULL, *params = NULL, *eol = NULL, *id = NULL, *value = NULL, *dummy_value = NULL;
zval *dummy_text = NULL, *code = NULL, *avalue = NULL, *key = NULL, *close_option = NULL;
zval *options = NULL, *using = NULL;
zval *a0 = NULL;
zval *t0 = NULL, *t1 = 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 *p1[] = { NULL, NULL, NULL, NULL };
HashTable *ah0;
HashPosition hp0;
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|z", ¶meters, &data) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!data) {
PHALCON_INIT_VAR(data);
ZVAL_NULL(data);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(a0);
array_init(a0);
phalcon_array_append(&a0, parameters, PHALCON_SEPARATE_PLZ TSRMLS_CC);
phalcon_array_append(&a0, data, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_CPY_WRT(params, a0);
} else {
PHALCON_CPY_WRT(params, parameters);
}
PHALCON_ALLOC_ZVAL_MM(t0);
zend_get_constant("PHP_EOL", strlen("PHP_EOL"), t0 TSRMLS_CC);
PHALCON_CPY_WRT(eol, t0);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_long(&r0, params, 0, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(id, r0);
eval_int = phalcon_array_isset_string(params, "value", strlen("value")+1);
if (!eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_STATIC_PARAMS_1(r1, "phalcon_tag", "getvalue", id);
PHALCON_CPY_WRT(value, r1);
} else {
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_string(&r2, params, "value", strlen("value"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(value, r2);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, "value", strlen("value")+1);
}
eval_int = phalcon_array_isset_string(params, "dummyValue", strlen("dummyValue")+1);
if (!eval_int) {
PHALCON_INIT_VAR(dummy_value);
ZVAL_STRING(dummy_value, "", 1);
} else {
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_string(&r3, params, "dummyValue", strlen("dummyValue"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(dummy_value, r3);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, "dummyValue", strlen("dummyValue")+1);
}
eval_int = phalcon_array_isset_string(params, "dummyText", strlen("dummyText")+1);
if (!eval_int) {
PHALCON_INIT_VAR(dummy_text);
ZVAL_STRING(dummy_text, "Choose...", 1);
} else {
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_string(&r4, params, "dummyText", strlen("dummyText"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(dummy_text, r4);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, "dummyText", strlen("dummyText")+1);
}
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CONCAT_SVSVS(r5, "<select id=\"", id, "\" name=\"", id, "\"");
PHALCON_CPY_WRT(code, r5);
if (Z_TYPE_P(params) == IS_ARRAY) {
if (phalcon_valid_foreach(params TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9c31_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9c31_0;
} else {
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
}
PHALCON_INIT_VAR(avalue);
ZVAL_ZVAL(avalue, *hd, 1, 0);
if (Z_TYPE_P(key) != IS_LONG) {
if (Z_TYPE_P(avalue) != IS_ARRAY) {
PHALCON_INIT_VAR(r6);
PHALCON_CONCAT_SVSVS(r6, " ", key, "=\"", avalue, "\"");
phalcon_concat_self(&code, r6 TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9c31_0;
fee_9c31_0:
if(0){}
} else {
return;
}
}
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_CONCAT_SV(r7, ">", eol);
phalcon_concat_self(&code, r7 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CONCAT_SV(r8, "</option>", eol);
PHALCON_CPY_WRT(close_option, r8);
eval_int = phalcon_array_isset_string(params, "useDummy", strlen("useDummy")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_CONCAT_SVSVV(r9, "\t<option value=\"", dummy_value, "\">", dummy_text, close_option);
phalcon_concat_self(&code, r9 TSRMLS_CC);
}
eval_int = phalcon_array_isset_long(params, 1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r10);
phalcon_array_fetch_long(&r10, params, 1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(options, r10);
} else {
PHALCON_CPY_WRT(options, data);
}
if (Z_TYPE_P(options) == IS_OBJECT) {
eval_int = phalcon_array_isset_string(params, "using", strlen("using")+1);
if (!eval_int) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter is required");
return;
} else {
PHALCON_ALLOC_ZVAL_MM(r11);
phalcon_array_fetch_string(&r11, params, "using", strlen("using"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(using, r11);
if (Z_TYPE_P(using) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter should be an Array");
return;
}
}
PHALCON_ALLOC_ZVAL_MM(r12);
p1[0] = options;
p1[1] = using;
p1[2] = value;
p1[3] = close_option;
PHALCON_CALL_SELF_PARAMS(r12, this_ptr, "_optionsfromresultset", 4, p1);
phalcon_concat_self(&code, r12 TSRMLS_CC);
} else {
PHP_METHOD(air_view, render){
AIR_INIT_THIS;
char *tpl_str;
int tpl_len = 0;
zend_bool ret_res = 0;
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sb", &tpl_str, &tpl_len, &ret_res) == FAILURE)
{
RETURN_FALSE;
}
smart_str ss_path = {0};
if(tpl_str[0] != '/'){
zval *root_path = NULL;
MAKE_STD_ZVAL(root_path);
if(zend_get_constant(ZEND_STRL("ROOT_PATH"), root_path) == FAILURE){
php_error_docref(NULL TSRMLS_CC, E_ERROR, "ROOT_PATH not defined");
}
smart_str_appendl(&ss_path, Z_STRVAL_P(root_path), Z_STRLEN_P(root_path));
smart_str_appendc(&ss_path, '/');
if(root_path != NULL){
zval_ptr_dtor(&root_path);
}
zval *tmp = NULL;
zval **tmp_pp;
zval *config = zend_read_property(air_view_ce, getThis(), ZEND_STRL("_config"), 0 TSRMLS_CC);
if(config != NULL && Z_TYPE_P(config) == IS_ARRAY
&& zend_hash_find(Z_ARRVAL_P(config), ZEND_STRL("path"), (void **)&tmp_pp) == SUCCESS){
smart_str_appendl(&ss_path, Z_STRVAL_PP(tmp_pp), Z_STRLEN_PP(tmp_pp));
}else{
zval *app_conf;
zval *view_conf;
if(air_config_get(NULL, ZEND_STRS("app"), &app_conf TSRMLS_CC) == FAILURE){
AIR_NEW_EXCEPTION(1, "@error config: app");
}
zval *app_path = NULL;
if(air_config_get(app_conf, ZEND_STRS("path"), &app_path) == FAILURE){
AIR_NEW_EXCEPTION(1, "@error config: app.path");
}
zval *view_path = NULL;
if(air_config_get_path(app_conf, ZEND_STRS("view.path"), &view_path) == FAILURE){
AIR_NEW_EXCEPTION(1, "@view config not found");
}
smart_str_appendl(&ss_path, Z_STRVAL_P(app_path), Z_STRLEN_P(app_path));
smart_str_appendc(&ss_path, '/');
smart_str_appendl(&ss_path, Z_STRVAL_P(view_path), Z_STRLEN_P(view_path));
}
smart_str_appendc(&ss_path, '/');
}
smart_str_appendl(&ss_path, tpl_str, tpl_len);
smart_str_0(&ss_path);
//php_printf("full view path: %s\n", ss_path.c);
//构造运行时所需基本变量
HashTable *origin_symbol_table = NULL;
zval *output_handler = NULL;
long chunk_size = 0;
long flags = PHP_OUTPUT_HANDLER_STDFLAGS;
zval *view_ret = NULL;
//尝试缓存当前符号表
if(EG(active_symbol_table)){
origin_symbol_table = EG(active_symbol_table);
}
if (ret_res) {
MAKE_STD_ZVAL(view_ret);
if(php_output_start_user(output_handler, chunk_size, flags TSRMLS_CC) == FAILURE)
{
php_error_docref("ref.outcontrol" TSRMLS_CC, E_NOTICE, "failed to create buffer");
RETURN_FALSE;
}
}
ALLOC_HASHTABLE(EG(active_symbol_table));
zval *data = zend_read_property(air_view_ce, getThis(), ZEND_STRL("_data"), 0 TSRMLS_CC);
zend_hash_init(EG(active_symbol_table), 0, NULL, ZVAL_PTR_DTOR, 0);
//将当前的模板变量放到符号表去
ZEND_SET_SYMBOL_WITH_LENGTH(EG(active_symbol_table), "var", 4, data, Z_REFCOUNT_P(data) + 1, PZVAL_IS_REF(data));
if(air_loader_include_file(ss_path.c TSRMLS_CC) == FAILURE){
air_throw_exception_ex(1, "tpl %s render failed!\n", ss_path.c);
return ;
}
if(ret_res){
php_output_get_contents(view_ret TSRMLS_CC);
php_output_discard(TSRMLS_C);
RETVAL_ZVAL(view_ret, 1, 0);
zval_ptr_dtor(&view_ret);
}
zend_hash_destroy(EG(active_symbol_table));
FREE_HASHTABLE(EG(active_symbol_table));
EG(active_symbol_table) = origin_symbol_table;
smart_str_free(&ss_path);
}
/**
* Executes the validator
*
* @param Phalcon\Mvc\ModelInterface $record
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Json, validate){
zval *record, *option = NULL, *field_name = NULL, *invalid = NULL;
zval *value = NULL, *keys = NULL, *assoc, *json = NULL, *constant, *ret = NULL;
zval *message = NULL, *type, *is_set_code = NULL, *code = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &record);
PHALCON_INIT_VAR(option);
ZVAL_STRING(option, "field", 1);
PHALCON_CALL_METHOD(&field_name, this_ptr, "getoption", option);
if (Z_TYPE_P(field_name) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Field name must be a string");
return;
}
PHALCON_INIT_VAR(invalid);
ZVAL_BOOL(invalid, 0);
PHALCON_CALL_METHOD(&value, record, "readattribute", field_name);
PHALCON_INIT_VAR(assoc);
ZVAL_TRUE(assoc);
PHALCON_CALL_FUNCTION(&json, "json_decode", value, assoc);
if (Z_TYPE_P(json) == IS_NULL) {
PHALCON_INIT_VAR(constant);
if (zend_get_constant(SL("JSON_ERROR_NONE"), constant TSRMLS_CC)) {
PHALCON_INIT_NVAR(ret);
PHALCON_CALL_FUNCTION(&ret, "json_last_error");
if (!PHALCON_IS_EQUAL(ret, constant)) {
PHALCON_INIT_NVAR(invalid);
ZVAL_BOOL(invalid, 1);
}
}
}
if (!PHALCON_IS_TRUE(invalid)) {
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "keys", 1);
PHALCON_CALL_METHOD(&keys, this_ptr, "getoption", option);
if (Z_TYPE_P(keys) != IS_NULL) {
PHALCON_INIT_NVAR(ret);
PHALCON_CALL_FUNCTION(&ret, "array_key_exists", keys, json);
if (!zend_is_true(ret)) {
PHALCON_INIT_NVAR(invalid);
ZVAL_BOOL(invalid, 1);
}
}
}
if (PHALCON_IS_TRUE(invalid)) {
/**
* Check if the developer has defined a custom message
*/
PHALCON_INIT_NVAR(option);
PHALCON_ZVAL_MAYBE_INTERNED_STRING(option, phalcon_interned_message);
PHALCON_CALL_METHOD(&message, this_ptr, "getoption", option);
if (!zend_is_true(message)) {
PHALCON_INIT_NVAR(message);
PHALCON_CONCAT_SVS(message, "Value of field '", field_name, "' must have a valid json format");
}
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "Json", 1);
/*
* Is code set
*/
PHALCON_INIT_NVAR(option);
PHALCON_ZVAL_MAYBE_INTERNED_STRING(option, phalcon_interned_code);
PHALCON_CALL_METHOD(&is_set_code, this_ptr, "issetoption", option);
if (zend_is_true(is_set_code)) {
PHALCON_CALL_METHOD(&code, this_ptr, "getoption", option);
} else {
PHALCON_INIT_VAR(code);
ZVAL_LONG(code, 0);
}
PHALCON_CALL_METHOD(NULL, this_ptr, "appendmessage", message, field_name, type, code);
RETURN_MM_FALSE;
}
RETURN_MM_TRUE;
}