PHP_METHOD(Test_Flow, testFor24) { HashTable *_3; HashPosition _2; zval *_0; zval *b; zval *a = NULL, *_1, **_4; ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(b); ZVAL_EMPTY_STRING(b); ZEPHIR_INIT_VAR(_0); array_init_size(_0, 6); ZEPHIR_INIT_VAR(_1); ZVAL_LONG(_1, 'a'); zephir_array_fast_append(_0, _1); ZEPHIR_INIT_BNVAR(_1); ZVAL_LONG(_1, 'b'); zephir_array_fast_append(_0, _1); ZEPHIR_INIT_BNVAR(_1); ZVAL_LONG(_1, 'c'); zephir_array_fast_append(_0, _1); ZEPHIR_INIT_BNVAR(_1); ZVAL_LONG(_1, 'd'); zephir_array_fast_append(_0, _1); zephir_is_iterable(_0, &_3, &_2, 0, 0); for ( ; zend_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS ; zend_hash_move_forward_ex(_3, &_2) ) { ZEPHIR_GET_HVALUE(a, _4); zephir_concat_self(&b, a TSRMLS_CC); } RETURN_CTOR(b); }
static zval *phannot_ret_zval_list(zval *list_left, zval *right_list) { zval *ret; HashPosition pos; HashTable *list; MAKE_STD_ZVAL(ret); array_init(ret); if (list_left) { list = Z_ARRVAL_P(list_left); if (zend_hash_index_exists(list, 0)) { zend_hash_internal_pointer_reset_ex(list, &pos); for (;; zend_hash_move_forward_ex(list, &pos)) { zval ** item; if (zend_hash_get_current_data_ex(list, (void**) &item, &pos) == FAILURE) { break; } Z_ADDREF_PP(item); add_next_index_zval(ret, *item); } zval_ptr_dtor(&list_left); } else { add_next_index_zval(ret, list_left); } } add_next_index_zval(ret, right_list); return ret; }
/** * Restore a \Phalcon\Http\Response\Headers object */ PHP_METHOD(Phalcon_Http_Response_Headers, __set_state) { HashTable *_1$$3; HashPosition _0$$3; zephir_fcall_cache_entry *_3 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *data_param = NULL, *headers = NULL, *key = NULL, *value = NULL, *dataHeaders = NULL, **_2$$3; zval *data = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &data_param); data = data_param; ZEPHIR_INIT_VAR(headers); object_init_ex(headers, phalcon_http_response_headers_ce); if (zephir_has_constructor(headers TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, headers, "__construct", NULL, 0); zephir_check_call_status(); } ZEPHIR_OBS_VAR(dataHeaders); if (zephir_array_isset_string_fetch(&dataHeaders, data, SS("_headers"), 0 TSRMLS_CC)) { zephir_is_iterable(dataHeaders, &_1$$3, &_0$$3, 0, 0, "phalcon/http/response/headers.zep", 126); for ( ; zend_hash_get_current_data_ex(_1$$3, (void**) &_2$$3, &_0$$3) == SUCCESS ; zend_hash_move_forward_ex(_1$$3, &_0$$3) ) { ZEPHIR_GET_HMKEY(key, _1$$3, _0$$3); ZEPHIR_GET_HVALUE(value, _2$$3); ZEPHIR_CALL_METHOD(NULL, headers, "set", &_3, 258, key, value); zephir_check_call_status(); } } RETURN_CCTOR(headers); }
/** * Sets the path for a domain * * <code> * // Set the directory path * $gettext->setDirectory("/path/to/the/messages"); * * // Set the domains and directories path * $gettext->setDirectory( * [ * "messages" => "/path/to/the/messages", * "another" => "/path/to/the/another", * ] * ); * </code> * * @param string|array directory The directory path or an array of directories and domains */ PHP_METHOD(Phalcon_Translate_Adapter_Gettext, setDirectory) { HashTable *_1$$4; HashPosition _0$$4; zend_long ZEPHIR_LAST_CALL_STATUS; zephir_fcall_cache_entry *_3 = NULL; zval *directory, *key = NULL, *value = NULL, **_2$$4, *_4$$6 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &directory); if (ZEPHIR_IS_EMPTY(directory)) { RETURN_MM_NULL(); } zephir_update_property_this(getThis(), SL("_directory"), directory TSRMLS_CC); if (Z_TYPE_P(directory) == IS_ARRAY) { zephir_is_iterable(directory, &_1$$4, &_0$$4, 0, 0, "phalcon/translate/adapter/gettext.zep", 180); for ( ; zend_hash_get_current_data_ex(_1$$4, (void**) &_2$$4, &_0$$4) == SUCCESS ; zend_hash_move_forward_ex(_1$$4, &_0$$4) ) { ZEPHIR_GET_HMKEY(key, _1$$4, _0$$4); ZEPHIR_GET_HVALUE(value, _2$$4); ZEPHIR_CALL_FUNCTION(NULL, "bindtextdomain", &_3, 473, key, value); zephir_check_call_status(); } } else { ZEPHIR_CALL_METHOD(&_4$$6, this_ptr, "getdefaultdomain", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(NULL, "bindtextdomain", &_3, 473, _4$$6, directory); zephir_check_call_status(); } ZEPHIR_MM_RESTORE(); }
/** * Check if HTTP method match any of the passed methods * * @param string|array $methods * @return boolean */ PHP_METHOD(Phalcon_Http_Request, isMethod){ zval *methods, *http_method, *is_equals, *method = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &methods); PHALCON_INIT_VAR(http_method); phalcon_call_method(http_method, this_ptr, "getmethod"); if (Z_TYPE_P(methods) == IS_STRING) { PHALCON_INIT_VAR(is_equals); is_equal_function(is_equals, methods, http_method TSRMLS_CC); RETURN_NCTOR(is_equals); } else { phalcon_is_iterable(methods, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(method); if (PHALCON_IS_EQUAL(method, http_method)) { RETURN_MM_TRUE; } zend_hash_move_forward_ex(ah0, &hp0); } } RETURN_MM_FALSE; }
PHP_METHOD(Test_Flow, testFor2) { HashTable *_2; HashPosition _1; double c; zval *v = NULL, *k = NULL, *b, *_0, **_3; ZEPHIR_MM_GROW(); c = (double) (0); ZEPHIR_INIT_VAR(b); array_init_size(b, 5); ZEPHIR_INIT_VAR(_0); ZVAL_LONG(_0, 1); zephir_array_fast_append(b, _0); ZEPHIR_INIT_BNVAR(_0); ZVAL_LONG(_0, 2); zephir_array_fast_append(b, _0); ZEPHIR_INIT_BNVAR(_0); ZVAL_LONG(_0, 3); zephir_array_fast_append(b, _0); ZEPHIR_INIT_BNVAR(_0); ZVAL_LONG(_0, 4); zephir_array_fast_append(b, _0); zephir_is_iterable(b, &_2, &_1, 0, 0); for ( ; zend_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS ; zend_hash_move_forward_ex(_2, &_1) ) { ZEPHIR_GET_HMKEY(k, _2, _1); ZEPHIR_GET_HVALUE(v, _3); c += zephir_get_numberval(k); } RETURN_MM_DOUBLE(c); }
ZEND_METHOD(Vedis, mget) { zval *keys; zval **val; size_t n; HashPosition pos; VEDIS_PARAM(MGET, 4); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &keys) == FAILURE) { return; } VEDIS_SELF(intern); n = zend_hash_num_elements(HASH_OF(keys)); if (n == 0) { RETURN_FALSE; } VEDIS_ARGS_INIT(n); zend_hash_internal_pointer_reset_ex(HASH_OF(keys), &pos); while (zend_hash_get_current_data_ex(HASH_OF(keys), (void **)&val, &pos) == SUCCESS) { if (Z_TYPE_PP(val) != IS_STRING) { convert_to_string(*val); } VEDIS_ARGS_STRING(Z_STRVAL_PP(val), Z_STRLEN_PP(val)); zend_hash_move_forward_ex(HASH_OF(keys), &pos); } VEDIS_ARGS_EXEC(RETURN_FALSE); VEDIS_RETURN_ARRAY(); }
/** * Returns the paths using positions as keys and names as values * * @return array */ PHP_METHOD(Test_Router_Route, getReversedPaths) { HashTable *_2; HashPosition _1; zval *reversed, *path = NULL, *position = NULL, *_0, **_3; ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(reversed); array_init(reversed); ZEPHIR_OBS_VAR(_0); zephir_read_property_this(&_0, this_ptr, SL("_paths"), PH_NOISY_CC); zephir_is_iterable(_0, &_2, &_1, 0, 0); for ( ; zend_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS ; zend_hash_move_forward_ex(_2, &_1) ) { ZEPHIR_GET_HMKEY(path, _2, _1); ZEPHIR_GET_HVALUE(position, _3); zephir_array_update_zval(&reversed, position, &path, PH_COPY | PH_SEPARATE); } RETURN_CCTOR(reversed); }
/** * Starts every backend * * @param int|string $keyName * @param long $lifetime * @return mixed */ PHP_METHOD(Phalcon_Cache_Multiple, start){ zval *key_name, *lifetime = NULL, *backends, *backend = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &key_name, &lifetime) == FAILURE) { RETURN_MM_NULL(); } if (!lifetime) { PHALCON_INIT_VAR(lifetime); } PHALCON_OBS_VAR(backends); phalcon_read_property(&backends, this_ptr, SL("_backends"), PH_NOISY_CC); if (!phalcon_is_iterable(backends, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(backend); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(backend, "start", key_name, lifetime); zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_MM_RESTORE(); }
//is used to validate objects before serialization and after deserialization. For now, only required fields are validated. static void validate_thrift_object(zval* object) { zend_class_entry* object_class_entry = Z_OBJCE_P(object); zval* is_validate = zend_read_static_property(object_class_entry, "isValidate", sizeof("isValidate")-1, false); zval* spec = zend_read_static_property(object_class_entry, "_TSPEC", sizeof("_TSPEC")-1, false); HashPosition key_ptr; zval* val_ptr; if (Z_TYPE_INFO_P(is_validate) == IS_TRUE) { for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(spec), &key_ptr); (val_ptr = zend_hash_get_current_data_ex(Z_ARRVAL_P(spec), &key_ptr)) != nullptr; zend_hash_move_forward_ex(Z_ARRVAL_P(spec), &key_ptr)) { zend_ulong fieldno; if (zend_hash_get_current_key_ex(Z_ARRVAL_P(spec), nullptr, &fieldno, &key_ptr) != HASH_KEY_IS_LONG) { throw_tprotocolexception("Bad keytype in TSPEC (expected 'long')", INVALID_DATA); return; } HashTable* fieldspec = Z_ARRVAL_P(val_ptr); // field name zval* zvarname = zend_hash_str_find(fieldspec, "var", sizeof("var")-1); char* varname = Z_STRVAL_P(zvarname); zval* is_required = zend_hash_str_find(fieldspec, "isRequired", sizeof("isRequired")-1); zval rv; zval* prop = zend_read_property(object_class_entry, object, varname, strlen(varname), false, &rv); if (Z_TYPE_INFO_P(is_required) == IS_TRUE && Z_TYPE_P(prop) == IS_NULL) { char errbuf[128]; snprintf(errbuf, 128, "Required field %s.%s is unset!", ZSTR_VAL(object_class_entry->name), varname); throw_tprotocolexception(errbuf, INVALID_DATA); } } } }
/** * Commmits active transactions within the manager * */ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, commit){ zval *transactions, *transaction = NULL, *connection = NULL; zval *is_under_transaction = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); PHALCON_OBS_VAR(transactions); phalcon_read_property_this(&transactions, this_ptr, SL("_transactions"), PH_NOISY_CC); if (Z_TYPE_P(transactions) == IS_ARRAY) { phalcon_is_iterable(transactions, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(transaction); PHALCON_INIT_NVAR(connection); phalcon_call_method(connection, transaction, "getconnection"); PHALCON_INIT_NVAR(is_under_transaction); phalcon_call_method(is_under_transaction, connection, "isundertransaction"); if (zend_is_true(is_under_transaction)) { phalcon_call_method_noret(connection, "commit"); } zend_hash_move_forward_ex(ah0, &hp0); } } PHALCON_MM_RESTORE(); }
/** * Prints the messages in the session flasher * * @param string $type * @param boolean $remove */ PHP_METHOD(Phalcon_Flash_Session, output){ zval *remove = NULL, *messages, *message = NULL, *type = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &remove); if (!remove) { PHALCON_INIT_VAR(remove); ZVAL_BOOL(remove, 1); } PHALCON_INIT_VAR(messages); phalcon_call_method_p1(messages, this_ptr, "_getsessionmessages", remove); if (Z_TYPE_P(messages) == IS_ARRAY) { phalcon_is_iterable(messages, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HKEY(type, ah0, hp0); PHALCON_GET_HVALUE(message); phalcon_call_method_p2_noret(this_ptr, "outputmessage", type, message); zend_hash_move_forward_ex(ah0, &hp0); } } PHALCON_MM_RESTORE(); }
/** * Sets a global formatter * * @param Phalcon\Logger\FormatterInterface $formatter */ PHP_METHOD(Phalcon_Logger_Multiple, setFormatter){ zval *formatter, *loggers, *logger = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &formatter) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(loggers); phalcon_read_property_this(&loggers, this_ptr, SL("_loggers"), PH_NOISY_CC); if (Z_TYPE_P(loggers) == IS_ARRAY) { if (!phalcon_is_iterable(loggers, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(logger); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(logger, "setformatter", formatter); zend_hash_move_forward_ex(ah0, &hp0); } } phalcon_update_property_this(this_ptr, SL("_formatter"), formatter TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Validate a set of data according to a set of rules * * @param array|object $data * @param object $entity * @return Phalcon\Validation\Message\Group */ PHP_METHOD(Phalcon_Validation, validate){ zval *data = NULL, *entity = NULL, *validators, *messages = NULL, *status = NULL; zval *cancel_on_fail, *scope = NULL, *attribute = NULL, *validator = NULL; zval *must_cancel = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 2, &data, &entity); if (!data) { PHALCON_INIT_VAR(data); } if (!entity) { PHALCON_INIT_VAR(entity); } PHALCON_OBS_VAR(validators); phalcon_read_property_this(&validators, this_ptr, SL("_validators"), PH_NOISY_CC); if (Z_TYPE_P(validators) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "There are no validators to validate"); return; } /** * Clear pre-calculated values */ phalcon_update_property_null(this_ptr, SL("_values") TSRMLS_CC); /** * Implicitly creates a Phalcon\Validation\Message\Group object */ PHALCON_INIT_VAR(messages); object_init_ex(messages, phalcon_validation_message_group_ce); phalcon_call_method_noret(messages, "__construct"); /** * Validation classes can implement the 'beforeValidation' callback */ if (phalcon_method_exists_ex(this_ptr, SS("beforevalidation") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(status); phalcon_call_method_p3(status, this_ptr, "beforevalidation", data, entity, messages); if (PHALCON_IS_FALSE(status)) { RETURN_CCTOR(status); } } phalcon_update_property_this(this_ptr, SL("_messages"), messages TSRMLS_CC); if (Z_TYPE_P(data) == IS_ARRAY) { phalcon_update_property_this(this_ptr, SL("_data"), data TSRMLS_CC); } else { if (Z_TYPE_P(data) == IS_OBJECT) { phalcon_update_property_this(this_ptr, SL("_data"), data TSRMLS_CC); } } PHALCON_INIT_VAR(cancel_on_fail); ZVAL_STRING(cancel_on_fail, "cancelOnFail", 1); phalcon_is_iterable(validators, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(scope); if (Z_TYPE_P(scope) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "The validator scope is not valid"); return; } PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_long(&attribute, scope, 0, PH_NOISY_CC); PHALCON_OBS_NVAR(validator); phalcon_array_fetch_long(&validator, scope, 1, PH_NOISY_CC); if (Z_TYPE_P(validator) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "One of the validators is not valid"); return; } PHALCON_INIT_NVAR(status); phalcon_call_method_p2(status, validator, "validate", this_ptr, attribute); /** * Check if the validation must be canceled if this validator fails */ if (PHALCON_IS_FALSE(status)) { PHALCON_INIT_NVAR(must_cancel); phalcon_call_method_p1(must_cancel, validator, "getoption", cancel_on_fail); if (zend_is_true(must_cancel)) { break; } } zend_hash_move_forward_ex(ah0, &hp0); } /** * Get the messages generated by the validators */ PHALCON_OBS_NVAR(messages); phalcon_read_property_this(&messages, this_ptr, SL("_messages"), PH_NOISY_CC); if (phalcon_method_exists_ex(this_ptr, SS("aftervalidation") TSRMLS_CC) == SUCCESS) { phalcon_call_method_p3_noret(this_ptr, "aftervalidation", data, entity, messages); } RETURN_CCTOR(messages); }
/** * Initialize the metadata for certain table * * @param Phalcon\Mvc\Model $model * @param string $key * @param string $table * @param string $schema */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, _initializeMetaData){ zval *model, *key, *table, *schema, *meta_data, *data; zval *table_metadata = NULL, *class_name = NULL, *exception_message = NULL; zval *connection, *exists, *complete_table = NULL, *attributes; zval *primary_keys, *non_primary_keys, *numeric_typed; zval *not_null, *field_types, *field_bind_types; zval *automatic_default, *identity_field = NULL; zval *columns, *column = NULL, *field_name = NULL, *feature = NULL, *type = NULL; zval *bind_type = NULL; zval *t0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz", &model, &key, &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(meta_data); phalcon_read_property(&meta_data, this_ptr, SL("_metaData"), PH_NOISY_CC); eval_int = phalcon_array_isset(meta_data, key); if (!eval_int) { PHALCON_INIT_VAR(data); PHALCON_CALL_METHOD_PARAMS_1(data, this_ptr, "read", key, PH_NO_CHECK); if (Z_TYPE_P(data) != IS_NULL) { phalcon_array_update_zval(&meta_data, key, &data, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_metaData"), meta_data TSRMLS_CC); PHALCON_MM_RESTORE(); RETURN_NULL(); } if (phalcon_method_exists_ex(model, SS("metadata") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(table_metadata); PHALCON_CALL_METHOD(table_metadata, model, "metadata", PH_NO_CHECK); if (Z_TYPE_P(table_metadata) != IS_ARRAY) { PHALCON_INIT_VAR(class_name); phalcon_get_class(class_name, model TSRMLS_CC); PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SV(exception_message, "Invalid meta-data for model ", class_name); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } } else { PHALCON_INIT_VAR(connection); PHALCON_CALL_METHOD(connection, model, "getconnection", PH_NO_CHECK); PHALCON_INIT_VAR(exists); PHALCON_CALL_METHOD_PARAMS_2(exists, connection, "tableexists", table, schema, PH_NO_CHECK); if (!zend_is_true(exists)) { if (zend_is_true(schema)) { PHALCON_INIT_VAR(complete_table); PHALCON_CONCAT_VSV(complete_table, schema, "\".\"", table); } else { PHALCON_CPY_WRT(complete_table, table); } PHALCON_INIT_NVAR(class_name); phalcon_get_class(class_name, model TSRMLS_CC); PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVSV(exception_message, "Table \"", complete_table, "\" doesn't exist on database when dumping meta-data for ", class_name); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } PHALCON_INIT_VAR(attributes); array_init(attributes); PHALCON_INIT_VAR(primary_keys); array_init(primary_keys); PHALCON_INIT_VAR(non_primary_keys); array_init(non_primary_keys); PHALCON_INIT_VAR(numeric_typed); array_init(numeric_typed); PHALCON_INIT_VAR(not_null); array_init(not_null); PHALCON_INIT_VAR(field_types); array_init(field_types); PHALCON_INIT_VAR(field_bind_types); array_init(field_bind_types); PHALCON_INIT_VAR(automatic_default); array_init(automatic_default); PHALCON_INIT_VAR(identity_field); ZVAL_BOOL(identity_field, 0); PHALCON_INIT_VAR(columns); PHALCON_CALL_METHOD_PARAMS_2(columns, connection, "describecolumns", table, schema, PH_NO_CHECK); if (!phalcon_fast_count_ev(columns TSRMLS_CC)) { if (zend_is_true(schema)) { PHALCON_INIT_NVAR(complete_table); PHALCON_CONCAT_VSV(complete_table, schema, "\".\"", table); } else { PHALCON_CPY_WRT(complete_table, table); } PHALCON_INIT_NVAR(class_name); phalcon_get_class(class_name, model TSRMLS_CC); PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVSV(exception_message, "Cannot obtain table columns for the mapped source \"", complete_table, "\" used in model ", class_name); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } if (!phalcon_valid_foreach(columns TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(columns); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) { goto ph_cycle_end_0; } PHALCON_GET_FOREACH_VALUE(column); PHALCON_INIT_NVAR(field_name); PHALCON_CALL_METHOD(field_name, column, "getname", PH_NO_CHECK); phalcon_array_append(&attributes, field_name, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isprimary", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { phalcon_array_append(&primary_keys, field_name, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_append(&non_primary_keys, field_name, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isnumeric", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { phalcon_array_update_zval_bool(&numeric_typed, field_name, 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isnotnull", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { phalcon_array_append(¬_null, field_name, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isautoincrement", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { PHALCON_CPY_WRT(identity_field, field_name); } PHALCON_INIT_NVAR(type); PHALCON_CALL_METHOD(type, column, "gettype", PH_NO_CHECK); phalcon_array_update_zval(&field_types, field_name, &type, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(bind_type); PHALCON_CALL_METHOD(bind_type, column, "getbindtype", PH_NO_CHECK); phalcon_array_update_zval(&field_bind_types, field_name, &bind_type, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: PHALCON_INIT_NVAR(table_metadata); array_init(table_metadata); phalcon_array_update_long(&table_metadata, 0, &attributes, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 1, &primary_keys, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 2, &non_primary_keys, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 3, ¬_null, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 4, &field_types, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 5, &numeric_typed, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 8, &identity_field, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 9, &field_bind_types, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 10, &automatic_default, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 11, &automatic_default, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(t0); phalcon_read_property(&t0, this_ptr, SL("_metaData"), PH_NOISY_CC); phalcon_array_update_zval(&t0, key, &table_metadata, PH_COPY TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_metaData"), t0 TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "write", key, table_metadata, PH_NO_CHECK); } PHALCON_MM_RESTORE(); }
/* {{{ php_runkit_import_functions */ static int php_runkit_import_functions(HashTable *function_table, long flags TSRMLS_DC) { HashPosition pos; int i, func_count = zend_hash_num_elements(function_table); zend_hash_internal_pointer_reset_ex(function_table, &pos); for(i = 0; i < func_count; i++) { zend_function *fe = NULL; char *key, *new_key; int key_len, new_key_len, type; long idx; zend_bool add_function = 1; zend_bool exists = 0; zend_hash_get_current_data_ex(function_table, (void**)&fe, &pos); new_key = fe->common.function_name; new_key_len = strlen(new_key) + 1; if (((type = zend_hash_get_current_key_ex(function_table, &key, &key_len, &idx, 0, &pos)) != HASH_KEY_NON_EXISTANT) && fe && fe->type == ZEND_USER_FUNCTION) { if (type == HASH_KEY_IS_STRING) { new_key = key; new_key_len = key_len; exists = zend_hash_exists(EG(function_table), new_key, new_key_len); } else { exists = zend_hash_index_exists(EG(function_table), idx); } if (exists) { if (flags & PHP_RUNKIT_IMPORT_OVERRIDE) { if (type == HASH_KEY_IS_STRING) { if (zend_hash_del(EG(function_table), new_key, new_key_len) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Inconsistency cleaning up import environment"); return FAILURE; } } else { if (zend_hash_index_del(EG(function_table), idx) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Inconsistency cleaning up import environment"); return FAILURE; } } } else { add_function = 0; } } } if (add_function) { if (zend_hash_add(EG(function_table), new_key, new_key_len, fe, sizeof(zend_function), NULL) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failure importing %s()", fe->common.function_name); #ifdef ZEND_ENGINE_2 destroy_zend_function(fe TSRMLS_CC); #else destroy_end_function(fe); #endif return FAILURE; } else { fe->op_array.static_variables = NULL; (*fe->op_array.refcount)++; } } zend_hash_move_forward_ex(function_table, &pos); } return SUCCESS; }
/** * 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); }
/** * 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(); }
/** * Create/Returns a new transaction or an existing one */ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, getOrCreateTransaction) { HashTable *_2$$5; HashPosition _1$$5; zend_long ZEPHIR_LAST_CALL_STATUS; zval *autoBegin_param = NULL, *dependencyInjector = NULL, *transaction = NULL, *transactions = NULL, *_0, *_5, *_6, **_3$$5, *_4$$7 = NULL; zend_bool autoBegin; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &autoBegin_param); if (!autoBegin_param) { autoBegin = 1; } else { autoBegin = zephir_get_boolval(autoBegin_param); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); ZEPHIR_CPY_WRT(dependencyInjector, _0); if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_transaction_exception_ce, "A dependency injector container is required to obtain the services related to the ORM", "phalcon/mvc/model/transaction/manager.zep", 188); return; } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_number"), PH_NOISY_CC); if (zephir_is_true(_0)) { ZEPHIR_OBS_VAR(transactions); zephir_read_property_this(&transactions, this_ptr, SL("_transactions"), PH_NOISY_CC); if (Z_TYPE_P(transactions) == IS_ARRAY) { zephir_is_iterable(transactions, &_2$$5, &_1$$5, 0, 1, "phalcon/mvc/model/transaction/manager.zep", 200); for ( ; zend_hash_get_current_data_ex(_2$$5, (void**) &_3$$5, &_1$$5) == SUCCESS ; zend_hash_move_backwards_ex(_2$$5, &_1$$5) ) { ZEPHIR_GET_HVALUE(transaction, _3$$5); if (Z_TYPE_P(transaction) == IS_OBJECT) { ZEPHIR_INIT_NVAR(_4$$7); ZVAL_BOOL(_4$$7, 0); ZEPHIR_CALL_METHOD(NULL, transaction, "setisnewtransaction", NULL, 0, _4$$7); zephir_check_call_status(); RETURN_CCTOR(transaction); } } } } ZEPHIR_INIT_NVAR(transaction); object_init_ex(transaction, phalcon_mvc_model_transaction_ce); _5 = zephir_fetch_nproperty_this(this_ptr, SL("_service"), PH_NOISY_CC); ZEPHIR_INIT_VAR(_6); if (autoBegin) { ZVAL_BOOL(_6, 1); } else { ZVAL_BOOL(_6, 0); } ZEPHIR_CALL_METHOD(NULL, transaction, "__construct", NULL, 383, dependencyInjector, _6, _5); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, transaction, "settransactionmanager", NULL, 384, this_ptr); zephir_check_call_status(); zephir_update_property_array_append(this_ptr, SL("_transactions"), transaction TSRMLS_CC); RETURN_ON_FAILURE(zephir_property_incr(this_ptr, SL("_number") TSRMLS_CC)); RETURN_CCTOR(transaction); }
static int oauth_provider_parse_auth_header(php_oauth_provider *sop, char *auth_header) /* {{{ */ { pcre_cache_entry *pce; zval subpats, return_value, *item_param, *current_param, *current_val; HashPosition hpos; zend_string *regex = zend_string_init(OAUTH_REGEX, sizeof(OAUTH_REGEX) - 1, 0); size_t decoded_len; if(!auth_header || strncasecmp(auth_header, "oauth", 4) || !sop) { return FAILURE; } /* pass "OAuth " */ auth_header += 5; if ((pce = pcre_get_compiled_regex_cache(regex)) == NULL) { zend_string_release(regex); return FAILURE; } zend_string_release(regex); ZVAL_NULL(&subpats); ZVAL_NULL(&return_value); php_pcre_match_impl( pce, auth_header, strlen(auth_header), &return_value, &subpats, 1, /* global */ 1, /* use flags */ 2, /* PREG_SET_ORDER */ 0 ); if (0 == Z_LVAL(return_value)) { return FAILURE; } zend_hash_internal_pointer_reset_ex(Z_ARRVAL(subpats), &hpos); /* walk the oauth param names */ do { if ((item_param = zend_hash_get_current_data_ex(Z_ARRVAL(subpats), &hpos)) != NULL) { zval decoded_val; char *tmp; /* * item = array( * 1 => param name * 2 => quoted value * 3 => unquoted value (defined if matched) * ) */ current_param = zend_hash_index_find(Z_ARRVAL_P(item_param), 1); if ((current_val =zend_hash_index_find(Z_ARRVAL_P(item_param), 3)) == NULL) { current_val = zend_hash_index_find(Z_ARRVAL_P(item_param), 2); } tmp = estrndup(Z_STRVAL_P(current_val), Z_STRLEN_P(current_val)); decoded_len = php_url_decode(tmp, Z_STRLEN_P(current_val)); ZVAL_STRINGL(&decoded_val, tmp, decoded_len); if (oauth_provider_set_param_value(sop->oauth_params, Z_STRVAL_P(current_param), &decoded_val)==FAILURE) { return FAILURE; } Z_DELREF(decoded_val); } } while (SUCCESS==zend_hash_move_forward_ex(Z_ARRVAL(subpats), &hpos)); zval_ptr_dtor(&return_value); zval_ptr_dtor(&subpats); return SUCCESS; }
/** * Internal validations, if it returns true, then skip the current validator */ PHP_METHOD(Phalcon_Validation, preChecking) { HashTable *_1$$3, *_7$$9; HashPosition _0$$3, _6$$9; zephir_fcall_cache_entry *_3 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *field, *validator, *singleField = NULL, *allowEmpty = NULL, *emptyValue = NULL, *value = NULL, *result = NULL, **_2$$3, *_4$$6, *_5$$6, **_8$$9; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &field, &validator); if (Z_TYPE_P(field) == IS_ARRAY) { zephir_is_iterable(field, &_1$$3, &_0$$3, 0, 0, "phalcon/validation.zep", 590); for ( ; zend_hash_get_current_data_ex(_1$$3, (void**) &_2$$3, &_0$$3) == SUCCESS ; zend_hash_move_forward_ex(_1$$3, &_0$$3) ) { ZEPHIR_GET_HVALUE(singleField, _2$$3); ZEPHIR_CALL_METHOD(&result, this_ptr, "prechecking", &_3, 469, singleField, validator); zephir_check_call_status(); if (zephir_is_true(result)) { RETURN_CCTOR(result); } } } else { ZEPHIR_INIT_VAR(_4$$6); ZVAL_STRING(_4$$6, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_VAR(_5$$6); ZVAL_BOOL(_5$$6, 0); ZEPHIR_CALL_METHOD(&allowEmpty, validator, "getoption", NULL, 0, _4$$6, _5$$6); zephir_check_temp_parameter(_4$$6); zephir_check_call_status(); if (zephir_is_true(allowEmpty)) { if ((zephir_method_exists_ex(validator, SS("isallowempty") TSRMLS_CC) == SUCCESS)) { ZEPHIR_RETURN_CALL_METHOD(validator, "isallowempty", NULL, 0, this_ptr, field); zephir_check_call_status(); RETURN_MM(); } ZEPHIR_CALL_METHOD(&value, this_ptr, "getvalue", NULL, 0, field); zephir_check_call_status(); if (Z_TYPE_P(allowEmpty) == IS_ARRAY) { zephir_is_iterable(allowEmpty, &_7$$9, &_6$$9, 0, 0, "phalcon/validation.zep", 604); for ( ; zend_hash_get_current_data_ex(_7$$9, (void**) &_8$$9, &_6$$9) == SUCCESS ; zend_hash_move_forward_ex(_7$$9, &_6$$9) ) { ZEPHIR_GET_HVALUE(emptyValue, _8$$9); if (ZEPHIR_IS_IDENTICAL(emptyValue, value)) { RETURN_MM_BOOL(1); } } RETURN_MM_BOOL(0); } RETURN_MM_BOOL(ZEPHIR_IS_EMPTY(value)); } } RETURN_MM_BOOL(0); }
int msgpack_convert_object(zval *return_value, zval *tpl, zval **value) { zend_class_entry *ce, **pce; TSRMLS_FETCH(); switch (Z_TYPE_P(tpl)) { case IS_STRING: if (zend_lookup_class( Z_STRVAL_P(tpl), Z_STRLEN_P(tpl), &pce TSRMLS_CC) != SUCCESS) { MSGPACK_ERROR("[msgpack] (%s) Class '%s' not found", __FUNCTION__, Z_STRVAL_P(tpl)); return FAILURE; } ce = *pce; break; case IS_OBJECT: ce = zend_get_class_entry(tpl TSRMLS_CC); break; default: MSGPACK_ERROR("[msgpack] (%s) object type is unsupported", __FUNCTION__); return FAILURE; } if (Z_TYPE_PP(value) == IS_OBJECT) { zend_class_entry *vce; vce = zend_get_class_entry(*value TSRMLS_CC); if (strcmp(ce->name, vce->name) == 0) { *return_value = **value; zval_copy_ctor(return_value); zval_ptr_dtor(value); return SUCCESS; } } object_init_ex(return_value, ce); /* Run the constructor if there is one */ if (ce->constructor && (ce->constructor->common.fn_flags & ZEND_ACC_PUBLIC)) { zval *retval_ptr = NULL; zval ***params = NULL; int num_args = 0; zend_fcall_info fci; zend_fcall_info_cache fcc; #if ZEND_MODULE_API_NO >= 20090626 fci.size = sizeof(fci); fci.function_table = EG(function_table); fci.function_name = NULL; fci.symbol_table = NULL; fci.object_ptr = return_value; fci.retval_ptr_ptr = &retval_ptr; fci.param_count = num_args; fci.params = params; fci.no_separation = 1; fcc.initialized = 1; fcc.function_handler = ce->constructor; fcc.calling_scope = EG(scope); fcc.called_scope = Z_OBJCE_P(return_value); fcc.object_ptr = return_value; #else fci.size = sizeof(fci); fci.function_table = EG(function_table); fci.function_name = NULL; fci.symbol_table = NULL; fci.object_pp = &return_value; fci.retval_ptr_ptr = &retval_ptr; fci.param_count = num_args; fci.params = params; fci.no_separation = 1; fcc.initialized = 1; fcc.function_handler = ce->constructor; fcc.calling_scope = EG(scope); fcc.object_pp = &return_value; #endif if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) { if (params) { efree(params); } if (retval_ptr) { zval_ptr_dtor(&retval_ptr); } MSGPACK_WARNING( "[msgpack] (%s) Invocation of %s's constructor failed", __FUNCTION__, ce->name); return FAILURE; } if (retval_ptr) { zval_ptr_dtor(&retval_ptr); } if (params) { efree(params); } } switch (Z_TYPE_PP(value)) { case IS_ARRAY: { char *key; uint key_len; int key_type; ulong key_index; zval **data; HashPosition pos; HashTable *ht, *ret; HashTable *var = NULL; int num; ht = HASH_OF(*value); ret = HASH_OF(return_value); num = zend_hash_num_elements(ht); if (num <= 0) { zval_ptr_dtor(value); break; } /* string - php_only mode? */ if (ht->nNumOfElements != ht->nNextFreeElement || ht->nNumOfElements != ret->nNumOfElements) { HashTable *properties = NULL; HashPosition prop_pos; ALLOC_HASHTABLE(var); zend_hash_init(var, num, NULL, NULL, 0); zend_hash_internal_pointer_reset_ex(ht, &pos); for (;; zend_hash_move_forward_ex(ht, &pos)) { key_type = zend_hash_get_current_key_ex( ht, &key, &key_len, &key_index, 0, &pos); if (key_type == HASH_KEY_NON_EXISTANT) { break; } if (zend_hash_get_current_data_ex( ht, (void *)&data, &pos) != SUCCESS) { continue; } if (key_type == HASH_KEY_IS_STRING) { zval *val; MSGPACK_CONVERT_COPY_ZVAL(val, data); if (msgpack_convert_string_to_properties( return_value, key, key_len, val, var) != SUCCESS) { zval_ptr_dtor(&val); MSGPACK_WARNING( "[msgpack] (%s) " "illegal offset type, skip this decoding", __FUNCTION__); } } } /* index */ properties = Z_OBJ_HT_P(return_value)->get_properties( return_value TSRMLS_CC); if (HASH_OF(tpl)) { properties = HASH_OF(tpl); } zend_hash_internal_pointer_reset_ex(properties, &prop_pos); zend_hash_internal_pointer_reset_ex(ht, &pos); for (;; zend_hash_move_forward_ex(ht, &pos)) { key_type = zend_hash_get_current_key_ex( ht, &key, &key_len, &key_index, 0, &pos); if (key_type == HASH_KEY_NON_EXISTANT) { break; } if (zend_hash_get_current_data_ex( ht, (void *)&data, &pos) != SUCCESS) { continue; } switch (key_type) { case HASH_KEY_IS_LONG: { zval *val; MSGPACK_CONVERT_COPY_ZVAL(val, data); if (msgpack_convert_long_to_properties( ret, &properties, &prop_pos, key_index, val, var) != SUCCESS) { zval_ptr_dtor(&val); MSGPACK_WARNING( "[msgpack] (%s) " "illegal offset type, skip this decoding", __FUNCTION__); } break; } case HASH_KEY_IS_STRING: break; default: MSGPACK_WARNING( "[msgpack] (%s) key is not string nor array", __FUNCTION__); break; } } zend_hash_destroy(var); FREE_HASHTABLE(var); } else { HashPosition valpos; int (*convert_function)(zval *, zval *, zval **) = NULL; zval **arydata, *aryval; /* index */ zend_hash_internal_pointer_reset_ex(ret, &pos); zend_hash_internal_pointer_reset_ex(ht, &valpos); for (;; zend_hash_move_forward_ex(ret, &pos), zend_hash_move_forward_ex(ht, &valpos)) { key_type = zend_hash_get_current_key_ex( ret, &key, &key_len, &key_index, 0, &pos); if (key_type == HASH_KEY_NON_EXISTANT) { break; } if (zend_hash_get_current_data_ex( ret, (void *)&data, &pos) != SUCCESS) { continue; } switch (Z_TYPE_PP(data)) { case IS_ARRAY: convert_function = msgpack_convert_array; break; case IS_OBJECT: //case IS_STRING: -- may have default values of // class members, so it's not wise to allow convert_function = msgpack_convert_object; break; default: break; } if (zend_hash_get_current_data_ex( ht, (void *)&arydata, &valpos) != SUCCESS) { MSGPACK_WARNING( "[msgpack] (%s) can't get data value by index", __FUNCTION__); return FAILURE; } MSGPACK_CONVERT_COPY_ZVAL(aryval, arydata); if (convert_function) { zval *rv; ALLOC_INIT_ZVAL(rv); if (convert_function(rv, *data, &aryval) != SUCCESS) { zval_ptr_dtor(&aryval); MSGPACK_WARNING( "[msgpack] (%s) " "convert failure in convert_object", __FUNCTION__); return FAILURE; } zend_symtable_update( ret, key, key_len, &rv, sizeof(rv), NULL); } else { zend_symtable_update( ret, key, key_len, &aryval, sizeof(aryval), NULL); } } } zval_ptr_dtor(value); break; } default: { HashTable *properties = NULL; HashPosition prop_pos; properties = Z_OBJ_HT_P(return_value)->get_properties( return_value TSRMLS_CC); zend_hash_internal_pointer_reset_ex(properties, &prop_pos); if (msgpack_convert_long_to_properties( HASH_OF(return_value), &properties, &prop_pos, 0, *value, NULL) != SUCCESS) { MSGPACK_WARNING( "[msgpack] (%s) illegal offset type, skip this decoding", __FUNCTION__); } break; } } return SUCCESS; }
int msgpack_convert_array(zval *return_value, zval *tpl, zval **value) { TSRMLS_FETCH(); if (Z_TYPE_P(tpl) == IS_ARRAY) { char *key; uint key_len; int key_type; ulong key_index; zval **data, **arydata; HashPosition pos, valpos; HashTable *ht, *htval; int num; ht = HASH_OF(tpl); // TODO: maybe need to release memory? array_init(return_value); num = zend_hash_num_elements(ht); if (num <= 0) { MSGPACK_WARNING( "[msgpack] (%s) template array length is 0", __FUNCTION__); zval_ptr_dtor(value); return FAILURE; } /* string */ if (ht->nNumOfElements != ht->nNextFreeElement) { htval = HASH_OF(*value); if (!htval) { MSGPACK_WARNING( "[msgpack] (%s) input data is not array", __FUNCTION__); zval_ptr_dtor(value); return FAILURE; } zend_hash_internal_pointer_reset_ex(ht, &pos); zend_hash_internal_pointer_reset_ex(htval, &valpos); for (;; zend_hash_move_forward_ex(ht, &pos), zend_hash_move_forward_ex(htval, &valpos)) { key_type = zend_hash_get_current_key_ex( ht, &key, &key_len, &key_index, 0, &pos); if (key_type == HASH_KEY_NON_EXISTANT) { break; } if (zend_hash_get_current_data_ex( ht, (void *)&data, &pos) != SUCCESS) { continue; } if (key_type == HASH_KEY_IS_STRING) { int (*convert_function)(zval *, zval *, zval **) = NULL; zval **dataval, *val; switch (Z_TYPE_PP(data)) { case IS_ARRAY: convert_function = msgpack_convert_array; break; case IS_OBJECT: // case IS_STRING: convert_function = msgpack_convert_object; break; default: break; } if (zend_hash_get_current_data_ex( htval, (void *)&dataval, &valpos) != SUCCESS) { MSGPACK_WARNING( "[msgpack] (%s) can't get data", __FUNCTION__); zval_ptr_dtor(value); return FAILURE; } MSGPACK_CONVERT_COPY_ZVAL(val, dataval); if (convert_function) { zval *rv; ALLOC_INIT_ZVAL(rv); if (convert_function(rv, *data, &val) != SUCCESS) { zval_ptr_dtor(&val); return FAILURE; } add_assoc_zval_ex(return_value, key, key_len, rv); } else { add_assoc_zval_ex(return_value, key, key_len, val); } } } zval_ptr_dtor(value); return SUCCESS; } else { /* index */ int (*convert_function)(zval *, zval *, zval **) = NULL; if (Z_TYPE_PP(value) != IS_ARRAY) { MSGPACK_WARNING( "[msgpack] (%s) unserialized data must be array.", __FUNCTION__); zval_ptr_dtor(value); return FAILURE; } zend_hash_internal_pointer_reset_ex(ht, &pos); key_type = zend_hash_get_current_key_ex( ht, &key, &key_len, &key_index, 0, &pos); if (key_type == HASH_KEY_NON_EXISTANT) { MSGPACK_WARNING( "[msgpack] (%s) first element in template array is empty", __FUNCTION__); zval_ptr_dtor(value); return FAILURE; } if (zend_hash_get_current_data_ex( ht, (void *)&data, &pos) != SUCCESS) { MSGPACK_WARNING( "[msgpack] (%s) invalid template: empty array?", __FUNCTION__); zval_ptr_dtor(value); return FAILURE; } switch (Z_TYPE_PP(data)) { case IS_ARRAY: convert_function = msgpack_convert_array; break; case IS_OBJECT: case IS_STRING: convert_function = msgpack_convert_object; break; default: break; } htval = HASH_OF(*value); num = zend_hash_num_elements(htval); if (num <= 0) { MSGPACK_WARNING( "[msgpack] (%s) array length is 0 in unserialized data", __FUNCTION__); zval_ptr_dtor(value); return FAILURE; } zend_hash_internal_pointer_reset_ex(htval, &valpos); for (;; zend_hash_move_forward_ex(htval, &valpos)) { key_type = zend_hash_get_current_key_ex( htval, &key, &key_len, &key_index, 0, &valpos); if (key_type == HASH_KEY_NON_EXISTANT) { break; } if (zend_hash_get_current_data_ex( htval, (void *)&arydata, &valpos) != SUCCESS) { MSGPACK_WARNING( "[msgpack] (%s) can't get next data in indexed array", __FUNCTION__); continue; } switch (key_type) { case HASH_KEY_IS_LONG: { zval *aryval, *rv; ALLOC_INIT_ZVAL(rv); MSGPACK_CONVERT_COPY_ZVAL(aryval, arydata); if (convert_function) { if (convert_function(rv, *data, &aryval) != SUCCESS) { zval_ptr_dtor(&aryval); MSGPACK_WARNING( "[msgpack] (%s) " "convert failure in HASH_KEY_IS_LONG " "in indexed array", __FUNCTION__); zval_ptr_dtor(value); return FAILURE; } add_next_index_zval(return_value, rv); } else { add_next_index_zval(return_value, aryval); } break; } case HASH_KEY_IS_STRING: MSGPACK_WARNING( "[msgpack] (%s) key is string", __FUNCTION__); zval_ptr_dtor(value); return FAILURE; default: MSGPACK_WARNING( "[msgpack] (%s) key is not string nor array", __FUNCTION__); zval_ptr_dtor(value); return FAILURE; } } zval_ptr_dtor(value); return SUCCESS; } } else { // shouldn't reach MSGPACK_WARNING( "[msgpack] (%s) template is not array", __FUNCTION__); zval_ptr_dtor(value); return FAILURE; } // shouldn't reach zval_ptr_dtor(value); return FAILURE; }
/** * Shows a backtrace item * * @param int $n * @param array $trace */ PHP_METHOD(Phalcon_Debug, showTraceItem){ zval *n, *trace, *space, *two_spaces, *underscore; zval *minus, *html, *class_name, *pattern, *is_phalcon_class; zval *namespace_separator, *prepare_uri_class; zval *class_reflection, *is_internal = NULL, *lower_class_name; zval *prepare_internal_class, *type, *function_name = NULL; zval *function_reflection, *prepared_function_name; zval *trace_args, *arguments, *argument = NULL, *dumped_argument = NULL; zval *span_argument = NULL, *joined_arguments, *one; zval *file, *line, *show_files, *lines, *number_lines; zval *show_file_fragment, *seven, *before_line; zval *first_line = NULL, *five, *after_line, *last_line = NULL; zval *comment_pattern, *utf8, *ent_compat, *tab; zval *comment, *i = NULL, *line_position = NULL, *current_line = NULL; zval *trimmed = NULL, *is_comment = NULL, *spaced_current_line = NULL; zval *escaped_line = NULL; HashTable *ah0; HashPosition hp0; zval **hd; zend_class_entry *ce0, *ce1; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &n, &trace); PHALCON_INIT_VAR(space); ZVAL_STRING(space, " ", 1); PHALCON_INIT_VAR(two_spaces); ZVAL_STRING(two_spaces, " ", 1); PHALCON_INIT_VAR(underscore); ZVAL_STRING(underscore, "_", 1); PHALCON_INIT_VAR(minus); ZVAL_STRING(minus, "-", 1); /** * Every trace in the backtrace have a unique number */ PHALCON_INIT_VAR(html); PHALCON_CONCAT_SVS(html, "<tr><td align=\"right\" valign=\"top\" class=\"error-number\">#", n, "</td><td>"); if (phalcon_array_isset_string(trace, SS("class"))) { PHALCON_OBS_VAR(class_name); phalcon_array_fetch_string(&class_name, trace, SL("class"), PH_NOISY); PHALCON_INIT_VAR(pattern); ZVAL_STRING(pattern, "/^Phalcon/", 1); PHALCON_INIT_VAR(is_phalcon_class); phalcon_preg_match(is_phalcon_class, pattern, class_name, NULL TSRMLS_CC); /** * We assume that classes starting by Phalcon are framework's classes */ if (zend_is_true(is_phalcon_class)) { PHALCON_INIT_VAR(namespace_separator); ZVAL_STRING(namespace_separator, "\\", 1); /** * Prepare the class name according to the Phalcon's conventions */ PHALCON_INIT_VAR(prepare_uri_class); phalcon_fast_str_replace(prepare_uri_class, namespace_separator, underscore, class_name); /** * Generate a link to the official docs */ PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://docs.phalconphp.com/en/latest/api/", prepare_uri_class, ".html\">", class_name, "</a></span>"); } else { ce0 = zend_fetch_class(SL("ReflectionClass"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); PHALCON_INIT_VAR(class_reflection); object_init_ex(class_reflection, ce0); if (phalcon_has_constructor(class_reflection TSRMLS_CC)) { phalcon_call_method_p1_noret(class_reflection, "__construct", class_name); } /** * Check if classes are PHP's classes */ PHALCON_INIT_VAR(is_internal); phalcon_call_method(is_internal, class_reflection, "isinternal"); if (zend_is_true(is_internal)) { PHALCON_INIT_VAR(lower_class_name); phalcon_fast_strtolower(lower_class_name, class_name); PHALCON_INIT_VAR(prepare_internal_class); phalcon_fast_str_replace(prepare_internal_class, underscore, minus, lower_class_name); /** * Generate a link to the official docs */ PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://php.net/manual/en/class.", prepare_internal_class, ".php\">", class_name, "</a></span>"); } else { PHALCON_SCONCAT_SVS(html, "<span class=\"error-class\">", class_name, "</span>"); } } /** * Object access operator: static/instance */ PHALCON_OBS_VAR(type); phalcon_array_fetch_string(&type, trace, SL("type"), PH_NOISY); phalcon_concat_self(&html, type TSRMLS_CC); } /** * Normally the backtrace contains only classes */ if (phalcon_array_isset_string(trace, SS("class"))) { PHALCON_OBS_VAR(function_name); phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY); PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>"); } else { PHALCON_OBS_NVAR(function_name); phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY); /** * Check if the function exists */ if (phalcon_function_exists(function_name TSRMLS_CC) == SUCCESS) { ce1 = zend_fetch_class(SL("ReflectionFunction"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); PHALCON_INIT_VAR(function_reflection); object_init_ex(function_reflection, ce1); if (phalcon_has_constructor(function_reflection TSRMLS_CC)) { phalcon_call_method_p1_noret(function_reflection, "__construct", function_name); } PHALCON_INIT_NVAR(is_internal); phalcon_call_method(is_internal, function_reflection, "isinternal"); /** * Internal functions links to the PHP documentation */ if (zend_is_true(is_internal)) { /** * Prepare function's name according to the conventions in the docs */ PHALCON_INIT_VAR(prepared_function_name); phalcon_fast_str_replace(prepared_function_name, underscore, minus, function_name); PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-function\"><a target=\"_new\" href=\"http://php.net/manual/en/function.", prepared_function_name, ".php\">", function_name, "</a></span>"); } else { PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>"); } } else { PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>"); } } /** * Check for arguments in the function */ if (phalcon_array_isset_string(trace, SS("args"))) { PHALCON_OBS_VAR(trace_args); phalcon_array_fetch_string(&trace_args, trace, SL("args"), PH_NOISY); if (phalcon_fast_count_ev(trace_args TSRMLS_CC)) { PHALCON_INIT_VAR(arguments); array_init(arguments); phalcon_is_iterable(trace_args, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(argument); /** * Every argument is generated using _getVarDump */ PHALCON_INIT_NVAR(dumped_argument); phalcon_call_method_p1(dumped_argument, this_ptr, "_getvardump", argument); PHALCON_INIT_NVAR(span_argument); PHALCON_CONCAT_SVS(span_argument, "<span class=\"error-parameter\">", dumped_argument, "</span>"); /** * Append the HTML generated to the argument's list */ phalcon_array_append(&arguments, span_argument, PH_SEPARATE); zend_hash_move_forward_ex(ah0, &hp0); } /** * Join all the arguments */ PHALCON_INIT_VAR(joined_arguments); phalcon_fast_join_str(joined_arguments, SL(", "), arguments TSRMLS_CC); PHALCON_SCONCAT_SVS(html, "(", joined_arguments, ")"); } else { phalcon_concat_self_str(&html, SL("()") TSRMLS_CC); } } /** * When 'file' is present, it usually means the function is provided by the user */ if (phalcon_array_isset_string(trace, SS("file"))) { PHALCON_INIT_VAR(one); ZVAL_LONG(one, 1); PHALCON_OBS_VAR(file); phalcon_array_fetch_string(&file, trace, SL("file"), PH_NOISY); PHALCON_OBS_VAR(line); phalcon_array_fetch_string(&line, trace, SL("line"), PH_NOISY); /** * Realpath to the file and its line using a special header */ PHALCON_SCONCAT_SVSVS(html, "<br/><div class=\"error-file\">", file, " (", line, ")</div>"); PHALCON_OBS_VAR(show_files); phalcon_read_property_this(&show_files, this_ptr, SL("_showFiles"), PH_NOISY_CC); /** * The developer can change if the files must be opened or not */ if (zend_is_true(show_files)) { /** * Open the file to an array using 'file', this respects the openbase-dir directive */ PHALCON_INIT_VAR(lines); phalcon_call_func_p1(lines, "file", file); PHALCON_INIT_VAR(number_lines); phalcon_fast_count(number_lines, lines TSRMLS_CC); PHALCON_OBS_VAR(show_file_fragment); phalcon_read_property_this(&show_file_fragment, this_ptr, SL("_showFileFragment"), PH_NOISY_CC); /** * File fragments just show a piece of the file where the exception is located */ if (zend_is_true(show_file_fragment)) { /** * Take seven lines back to the current exception's line, @TODO add an option for * this */ PHALCON_INIT_VAR(seven); ZVAL_LONG(seven, 7); PHALCON_INIT_VAR(before_line); sub_function(before_line, line, seven TSRMLS_CC); /** * Check for overflows */ if (PHALCON_LT_LONG(before_line, 1)) { PHALCON_CPY_WRT(first_line, one); } else { PHALCON_CPY_WRT(first_line, before_line); } /** * Take five lines after the current exception's line, @TODO add an option for this */ PHALCON_INIT_VAR(five); ZVAL_LONG(five, 5); PHALCON_INIT_VAR(after_line); phalcon_add_function(after_line, line, five TSRMLS_CC); /** * Check for overflows */ if (PHALCON_GT(after_line, number_lines)) { PHALCON_CPY_WRT(last_line, number_lines); } else { PHALCON_CPY_WRT(last_line, after_line); } PHALCON_SCONCAT_SVSVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums:", first_line, "'>"); } else { PHALCON_CPY_WRT(first_line, one); PHALCON_CPY_WRT(last_line, number_lines); PHALCON_SCONCAT_SVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums error-scroll'>"); } PHALCON_INIT_VAR(comment_pattern); ZVAL_STRING(comment_pattern, "#\\*\\/$#", 1); /** * We assume the file is utf-8 encoded, @TODO add an option for this */ PHALCON_INIT_VAR(utf8); ZVAL_STRING(utf8, "UTF-8", 1); /** * Don't escape quotes */ PHALCON_INIT_VAR(ent_compat); ZVAL_LONG(ent_compat, 2); PHALCON_INIT_VAR(tab); ZVAL_STRING(tab, "\t", 1); PHALCON_INIT_VAR(comment); ZVAL_STRING(comment, "* /", 1); PHALCON_CPY_WRT(i, first_line); while (1) { if (PHALCON_LE(i, last_line)) { } else { break; } /** * Current line in the file */ PHALCON_INIT_NVAR(line_position); sub_function(line_position, i, one TSRMLS_CC); /** * Current line content in the piece of file */ PHALCON_OBS_NVAR(current_line); phalcon_array_fetch(¤t_line, lines, line_position, PH_NOISY); /** * File fragments are cleaned, removing tabs and comments */ if (zend_is_true(show_file_fragment)) { if (PHALCON_IS_EQUAL(i, first_line)) { PHALCON_INIT_NVAR(trimmed); phalcon_fast_trim(trimmed, current_line, PHALCON_TRIM_RIGHT TSRMLS_CC); PHALCON_INIT_NVAR(is_comment); phalcon_preg_match(is_comment, comment_pattern, current_line, NULL TSRMLS_CC); if (zend_is_true(is_comment)) { PHALCON_INIT_NVAR(spaced_current_line); phalcon_fast_str_replace(spaced_current_line, comment, space, current_line); PHALCON_CPY_WRT(current_line, spaced_current_line); } } } /** * Print a non break space if the current line is a line break, this allows to show * the html zebra properly */ if (PHALCON_IS_STRING(current_line, "\n")) { phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC); } else { if (PHALCON_IS_STRING(current_line, "\r\n")) { phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC); } else { PHALCON_INIT_NVAR(spaced_current_line); phalcon_fast_str_replace(spaced_current_line, tab, two_spaces, current_line); PHALCON_INIT_NVAR(escaped_line); phalcon_call_func_p3(escaped_line, "htmlentities", spaced_current_line, ent_compat, utf8); phalcon_concat_self(&html, escaped_line TSRMLS_CC); } } PHALCON_SEPARATE(i); phalcon_increment(i); } phalcon_concat_self_str(&html, SL("</pre>") TSRMLS_CC); } } phalcon_concat_self_str(&html, SL("</td></tr>") TSRMLS_CC); RETURN_CTOR(html); }
/** * Validate a set of data according to a set of rules * * @param array|object data * @param object entity * @return \Phalcon\Validation\Message\Group */ PHP_METHOD(Phalcon_Validation, validate) { zend_bool _0$$7; HashTable *_2, *_10; HashPosition _1, _9; zephir_fcall_cache_entry *_5 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *data = NULL, *entity = NULL, *validators = NULL, *messages = NULL, *scope = NULL, *field = NULL, *validator = NULL, *status = NULL, *combinedFieldsValidators = NULL, **_3, **_11, *_4$$10 = NULL, *_6$$10 = NULL, *_7$$14 = NULL, *_8$$14 = NULL, *_12$$16 = NULL, *_13$$16 = NULL, *_14$$20 = NULL, *_15$$20 = NULL, *_16$$22; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 2, &data, &entity); if (!data) { data = ZEPHIR_GLOBAL(global_null); } if (!entity) { entity = ZEPHIR_GLOBAL(global_null); } ZEPHIR_OBS_VAR(validators); zephir_read_property_this(&validators, this_ptr, SL("_validators"), PH_NOISY_CC); ZEPHIR_OBS_VAR(combinedFieldsValidators); zephir_read_property_this(&combinedFieldsValidators, this_ptr, SL("_combinedFieldsValidators"), PH_NOISY_CC); if (Z_TYPE_P(validators) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "There are no validators to validate", "phalcon/validation.zep", 94); return; } zephir_update_property_this(getThis(), SL("_values"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC); ZEPHIR_INIT_VAR(messages); object_init_ex(messages, phalcon_validation_message_group_ce); ZEPHIR_CALL_METHOD(NULL, messages, "__construct", NULL, 3); zephir_check_call_status(); if (Z_TYPE_P(entity) != IS_NULL) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "setentity", NULL, 0, entity); zephir_check_call_status(); } if ((zephir_method_exists_ex(this_ptr, SS("beforevalidation") TSRMLS_CC) == SUCCESS)) { ZEPHIR_CALL_METHOD(&status, this_ptr, "beforevalidation", NULL, 0, data, entity, messages); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(status)) { RETURN_CCTOR(status); } } zephir_update_property_this(getThis(), SL("_messages"), messages TSRMLS_CC); if (Z_TYPE_P(data) != IS_NULL) { _0$$7 = Z_TYPE_P(data) == IS_ARRAY; if (!(_0$$7)) { _0$$7 = Z_TYPE_P(data) == IS_OBJECT; } if (_0$$7) { zephir_update_property_this(getThis(), SL("_data"), data TSRMLS_CC); } else { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Invalid data to validate", "phalcon/validation.zep", 127); return; } } zephir_is_iterable(validators, &_2, &_1, 0, 0, "phalcon/validation.zep", 161); for ( ; zend_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS ; zend_hash_move_forward_ex(_2, &_1) ) { ZEPHIR_GET_HVALUE(scope, _3); if (Z_TYPE_P(scope) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "The validator scope is not valid", "phalcon/validation.zep", 134); return; } ZEPHIR_OBS_NVAR(field); zephir_array_fetch_long(&field, scope, 0, PH_NOISY, "phalcon/validation.zep", 137 TSRMLS_CC); ZEPHIR_OBS_NVAR(validator); zephir_array_fetch_long(&validator, scope, 1, PH_NOISY, "phalcon/validation.zep", 138 TSRMLS_CC); if (Z_TYPE_P(validator) != IS_OBJECT) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "One of the validators is not valid", "phalcon/validation.zep", 141); return; } ZEPHIR_CALL_METHOD(&_4$$10, this_ptr, "prechecking", &_5, 0, field, validator); zephir_check_call_status(); if (zephir_is_true(_4$$10)) { continue; } ZEPHIR_CALL_METHOD(&_6$$10, validator, "validate", NULL, 0, this_ptr, field); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(_6$$10)) { ZEPHIR_INIT_NVAR(_8$$14); ZVAL_STRING(_8$$14, "cancelOnFail", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_7$$14, validator, "getoption", NULL, 0, _8$$14); zephir_check_temp_parameter(_8$$14); zephir_check_call_status(); if (zephir_is_true(_7$$14)) { break; } } } zephir_is_iterable(combinedFieldsValidators, &_10, &_9, 0, 0, "phalcon/validation.zep", 193); for ( ; zend_hash_get_current_data_ex(_10, (void**) &_11, &_9) == SUCCESS ; zend_hash_move_forward_ex(_10, &_9) ) { ZEPHIR_GET_HVALUE(scope, _11); if (Z_TYPE_P(scope) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "The validator scope is not valid", "phalcon/validation.zep", 163); return; } ZEPHIR_OBS_NVAR(field); zephir_array_fetch_long(&field, scope, 0, PH_NOISY, "phalcon/validation.zep", 166 TSRMLS_CC); ZEPHIR_OBS_NVAR(validator); zephir_array_fetch_long(&validator, scope, 1, PH_NOISY, "phalcon/validation.zep", 167 TSRMLS_CC); if (Z_TYPE_P(validator) != IS_OBJECT) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "One of the validators is not valid", "phalcon/validation.zep", 170); return; } ZEPHIR_CALL_METHOD(&_12$$16, this_ptr, "prechecking", &_5, 0, field, validator); zephir_check_call_status(); if (zephir_is_true(_12$$16)) { continue; } ZEPHIR_CALL_METHOD(&_13$$16, validator, "validate", NULL, 0, this_ptr, field); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(_13$$16)) { ZEPHIR_INIT_NVAR(_15$$20); ZVAL_STRING(_15$$20, "cancelOnFail", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_14$$20, validator, "getoption", NULL, 0, _15$$20); zephir_check_temp_parameter(_15$$20); zephir_check_call_status(); if (zephir_is_true(_14$$20)) { break; } } } if ((zephir_method_exists_ex(this_ptr, SS("aftervalidation") TSRMLS_CC) == SUCCESS)) { _16$$22 = zephir_fetch_nproperty_this(this_ptr, SL("_messages"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(NULL, this_ptr, "aftervalidation", NULL, 0, data, entity, _16$$22); zephir_check_call_status(); } RETURN_MM_MEMBER(getThis(), "_messages"); }
/** * Handles uncaught exceptions * * @param \Exception $exception * @return boolean */ PHP_METHOD(Phalcon_Debug, onUncaughtException){ zval *exception, *is_active = NULL, *message = NULL; zval *class_name, *css_sources, *escaped_message = NULL; zval *html, *version, *file, *line, *show_back_trace; zval *data_vars, *trace, *trace_item = NULL, *n = NULL, *html_item = NULL; zval *_REQUEST, *value = NULL, *key_request = NULL, *_SERVER; zval *key_server = NULL, *files, *key_file = NULL; zval *memory, *data_var = NULL, *key_var = NULL, *variable = NULL, *dumped_argument = NULL; zval *js_sources; HashTable *ah0, *ah1, *ah2, *ah3, *ah4; HashPosition hp0, hp1, hp2, hp3, hp4; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &exception); /** * Cancel the output buffer if active */ if (phalcon_ob_get_level(TSRMLS_C) > 0) { phalcon_ob_end_clean(TSRMLS_C); } PHALCON_OBS_VAR(is_active); phalcon_read_static_property(&is_active, SL("phalcon\\debug"), SL("_isActive") TSRMLS_CC); /** * Avoid that multiple exceptions being showed */ if (zend_is_true(is_active)) { PHALCON_INIT_VAR(message); phalcon_call_method(message, exception, "getmessage"); zend_print_zval(message, 0); } PHALCON_INIT_NVAR(is_active); ZVAL_BOOL(is_active, 1); /** * Globally block the debug component to avoid other exceptions must be shown */ phalcon_update_static_property(SL("phalcon\\debug"), SL("_isActive"), is_active TSRMLS_CC); PHALCON_INIT_VAR(class_name); phalcon_get_class(class_name, exception, 0 TSRMLS_CC); PHALCON_INIT_NVAR(message); phalcon_call_method(message, exception, "getmessage"); /** * CSS static sources to style the error presentation */ PHALCON_INIT_VAR(css_sources); phalcon_call_method(css_sources, this_ptr, "getcsssources"); /** * Escape the exception's message avoiding possible XSS injections? */ PHALCON_CPY_WRT(escaped_message, message); /** * Use the exception info as document's title */ PHALCON_INIT_VAR(html); PHALCON_CONCAT_SVSVS(html, "<html><head><title>", class_name, ": ", escaped_message, "</title>"); PHALCON_SCONCAT_VS(html, css_sources, "</head><body>"); /** * Get the version link */ PHALCON_INIT_VAR(version); phalcon_call_method(version, this_ptr, "getversion"); phalcon_concat_self(&html, version TSRMLS_CC); PHALCON_INIT_VAR(file); phalcon_call_method(file, exception, "getfile"); PHALCON_INIT_VAR(line); phalcon_call_method(line, exception, "getline"); /** * Main exception info */ phalcon_concat_self_str(&html, SL("<div align=\"center\"><div class=\"error-main\">") TSRMLS_CC); PHALCON_SCONCAT_SVSVS(html, "<h1>", class_name, ": ", escaped_message, "</h1>"); PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-file\">", file, " (", line, ")</span>"); phalcon_concat_self_str(&html, SL("</div>") TSRMLS_CC); PHALCON_OBS_VAR(show_back_trace); phalcon_read_property_this(&show_back_trace, this_ptr, SL("_showBackTrace"), PH_NOISY_CC); /** * Check if the developer wants to show the backtrace or not */ if (zend_is_true(show_back_trace)) { PHALCON_OBS_VAR(data_vars); phalcon_read_property_this(&data_vars, this_ptr, SL("_data"), PH_NOISY_CC); /** * Create the tabs in the page */ phalcon_concat_self_str(&html, SL("<div class=\"error-info\"><div id=\"tabs\"><ul>") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-1\">Backtrace</a></li>") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-2\">Request</a></li>") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-3\">Server</a></li>") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-4\">Included Files</a></li>") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-5\">Memory</a></li>") TSRMLS_CC); if (Z_TYPE_P(data_vars) == IS_ARRAY) { phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-6\">Variables</a></li>") TSRMLS_CC); } phalcon_concat_self_str(&html, SL("</ul>") TSRMLS_CC); /** * Print backtrace */ phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-1\"><table cellspacing=\"0\" align=\"center\" width=\"100%\">") TSRMLS_CC); PHALCON_INIT_VAR(trace); phalcon_call_method(trace, exception, "gettrace"); phalcon_is_iterable(trace, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HKEY(n, ah0, hp0); PHALCON_GET_HVALUE(trace_item); /** * Every line in the trace is rendered using 'showTraceItem' */ PHALCON_INIT_NVAR(html_item); phalcon_call_method_p2(html_item, this_ptr, "showtraceitem", n, trace_item); phalcon_concat_self(&html, html_item TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); } phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC); /** * Print _REQUEST superglobal */ phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-2\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC); phalcon_get_global(&_REQUEST, SS("_REQUEST") TSRMLS_CC); phalcon_is_iterable(_REQUEST, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HKEY(key_request, ah1, hp1); PHALCON_GET_HVALUE(value); PHALCON_SCONCAT_SVSVS(html, "<tr><td class=\"key\">", key_request, "</td><td>", value, "</td></tr>"); zend_hash_move_forward_ex(ah1, &hp1); } phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC); /** * Print _SERVER superglobal */ phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-3\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC); phalcon_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC); phalcon_is_iterable(_SERVER, &ah2, &hp2, 0, 0); while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_HKEY(key_server, ah2, hp2); PHALCON_GET_HVALUE(value); PHALCON_SCONCAT_SVSVS(html, "<tr><td class=\"key\">", key_server, "</td><td>", value, "</td></tr>"); zend_hash_move_forward_ex(ah2, &hp2); } phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC); /** * Show included files */ PHALCON_INIT_VAR(files); phalcon_call_func(files, "get_included_files"); phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-4\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<tr><th>#</th><th>Path</th></tr>") TSRMLS_CC); phalcon_is_iterable(files, &ah3, &hp3, 0, 0); while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) { PHALCON_GET_HKEY(key_file, ah3, hp3); PHALCON_GET_HVALUE(value); PHALCON_SCONCAT_SVSVS(html, "<tr><td>", key_file, "</th><td>", value, "</td></tr>"); zend_hash_move_forward_ex(ah3, &hp3); } phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC); /** * Memory usage */ PHALCON_INIT_VAR(memory); ZVAL_LONG(memory, zend_memory_usage(1 TSRMLS_CC)); phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-5\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC); PHALCON_SCONCAT_SVS(html, "<tr><th colspan=\"2\">Memory</th></tr><tr><td>Usage</td><td>", memory, "</td></tr>"); phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC); /** * Print extra variables passed to the component */ if (Z_TYPE_P(data_vars) == IS_ARRAY) { phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-6\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC); phalcon_is_iterable(data_vars, &ah4, &hp4, 0, 0); while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) { PHALCON_GET_HKEY(key_var, ah4, hp4); PHALCON_GET_HVALUE(data_var); PHALCON_OBS_NVAR(variable); phalcon_array_fetch_long(&variable, data_var, 0, PH_NOISY); PHALCON_INIT_NVAR(dumped_argument); phalcon_call_method_p1(dumped_argument, this_ptr, "_getvardump", variable); PHALCON_SCONCAT_SVSVS(html, "<tr><td class=\"key\">", key_var, "</td><td>", dumped_argument, "</td></tr>"); zend_hash_move_forward_ex(ah4, &hp4); } phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC); } phalcon_concat_self_str(&html, SL("</div>") TSRMLS_CC); } /** * Get Javascript sources */ PHALCON_INIT_VAR(js_sources); phalcon_call_method(js_sources, this_ptr, "getjssources"); PHALCON_SCONCAT_VS(html, js_sources, "</div></body></html>"); /** * Print the HTML, @TODO, add an option to store the html */ zend_print_zval(html, 0); PHALCON_INIT_NVAR(is_active); ZVAL_BOOL(is_active, 0); /** * Unlock the exception renderer */ phalcon_update_static_property(SL("phalcon\\debug"), SL("_isActive"), is_active TSRMLS_CC); RETURN_MM_TRUE; }
/** * Builds a SELECT statement * * @param array $definition * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Oracle, select){ zval *definition, *escape_char = NULL, *columns, *selected_columns, *distinct; zval *column = NULL, *column_item = NULL, *column_sql = NULL, *columns_sql = NULL; zval *column_domain = NULL, *column_domain_sql = NULL, *column_alias = NULL; zval *column_alias_sql = NULL, *tables, *selected_tables; zval *table = NULL, *sql_table = NULL, *tables_sql = NULL, *sql, *joins; zval *join = NULL, *type = NULL, *sql_join = NULL, *join_conditions_array = NULL; zval *join_expressions = NULL, *join_condition = NULL, *join_expression = NULL; zval *join_conditions = NULL, *where_conditions; zval *where_expression = NULL, *group_items, *group_fields; zval *group_field = NULL, *group_expression = NULL, *group_sql; zval *group_clause, *having_conditions, *having_expression = NULL; zval *order_fields, *order_items, *order_item = NULL; zval *order_expression = NULL, *order_sql_item = NULL, *sql_order_type = NULL; zval *order_sql_item_type = NULL, *order_sql, *limit_value; zval *number, *offset, *tmp1 = NULL, *tmp2 = NULL; zval *z_one, *ini_range, *end_range = NULL, *sql_limit; HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5; HashPosition hp0, hp1, hp2, hp3, hp4, hp5; zval **hd; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &definition) == FAILURE) { RETURN_NULL(); } if (Z_TYPE_P(definition) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "Invalid SELECT definition"); return; } if (!phalcon_array_isset_string(definition, SS("tables"))) { PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "The index 'tables' is required in the definition array"); return; } if (!phalcon_array_isset_string(definition, SS("columns"))) { PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "The index 'columns' is required in the definition array"); return; } PHALCON_MM_GROW(); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_OBS_VAR(escape_char); phalcon_read_property_this(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY TSRMLS_CC); } else { PHALCON_INIT_NVAR(escape_char); } PHALCON_OBS_VAR(columns); phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY); if (Z_TYPE_P(columns) == IS_ARRAY) { PHALCON_INIT_VAR(selected_columns); array_init(selected_columns); phalcon_is_iterable(columns, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(column); /** * Escape column name */ PHALCON_OBS_NVAR(column_item); phalcon_array_fetch_long(&column_item, column, 0, PH_NOISY); if (Z_TYPE_P(column_item) == IS_ARRAY) { PHALCON_CALL_METHOD(&column_sql, this_ptr, "getsqlexpression", column_item, escape_char); } else if (PHALCON_IS_STRING(column_item, "*")) { PHALCON_CPY_WRT(column_sql, column_item); } else if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(column_sql); PHALCON_CONCAT_VVV(column_sql, escape_char, column_item, escape_char); } else { PHALCON_CPY_WRT(columns_sql, column_item); } /** * Escape column domain */ if (phalcon_array_isset_long(column, 1)) { PHALCON_OBS_NVAR(column_domain); phalcon_array_fetch_long(&column_domain, column, 1, PH_NOISY); if (zend_is_true(column_domain)) { if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(column_domain_sql); PHALCON_CONCAT_VVVSV(column_domain_sql, escape_char, column_domain, escape_char, ".", column_sql); } else { PHALCON_INIT_NVAR(column_domain_sql); PHALCON_CONCAT_VSV(column_domain_sql, column_domain, ".", column_sql); } } else { PHALCON_CPY_WRT(column_domain_sql, column_sql); } } else { PHALCON_CPY_WRT(column_domain_sql, column_sql); } /** * Escape column alias */ if (phalcon_array_isset_long(column, 2)) { PHALCON_OBS_NVAR(column_alias); phalcon_array_fetch_long(&column_alias, column, 2, PH_NOISY); if (zend_is_true(column_alias)) { if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(column_alias_sql); PHALCON_CONCAT_VSVVV(column_alias_sql, column_domain_sql, " ", escape_char, column_alias, escape_char); } else { PHALCON_INIT_NVAR(column_alias_sql); PHALCON_CONCAT_VSV(column_alias_sql, column_domain_sql, " ", column_alias); } } else { PHALCON_CPY_WRT(column_alias_sql, column_domain_sql); } } else { PHALCON_CPY_WRT(column_alias_sql, column_domain_sql); } phalcon_array_append(&selected_columns, column_alias_sql, PH_SEPARATE); zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(columns_sql); phalcon_fast_join_str(columns_sql, SL(", "), selected_columns TSRMLS_CC); } else { PHALCON_CPY_WRT(columns_sql, columns); } /** * Check and escape tables */ PHALCON_OBS_VAR(tables); phalcon_array_fetch_string(&tables, definition, SL("tables"), PH_NOISY); if (Z_TYPE_P(tables) == IS_ARRAY) { PHALCON_INIT_VAR(selected_tables); array_init(selected_tables); phalcon_is_iterable(tables, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HVALUE(table); PHALCON_CALL_METHOD(&sql_table, this_ptr, "getsqltable", table, escape_char); phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE); zend_hash_move_forward_ex(ah1, &hp1); } PHALCON_INIT_VAR(tables_sql); phalcon_fast_join_str(tables_sql, SL(", "), selected_tables TSRMLS_CC); } else { PHALCON_CPY_WRT(tables_sql, tables); } PHALCON_INIT_VAR(sql); if (phalcon_array_isset_string_fetch(&distinct, definition, SS("definition"))) { assert(Z_TYPE_P(distinct) == IS_LONG); if (Z_LVAL_P(distinct) == 0) { ZVAL_STRING(sql, "SELECT ALL ", 1); } else if (Z_LVAL_P(distinct) == 1) { ZVAL_STRING(sql, "SELECT DISTINCT ", 1); } else { ZVAL_STRING(sql, "SELECT ", 1); } } else { ZVAL_STRING(sql, "SELECT ", 1); } /** * Check for joins */ if (phalcon_array_isset_string(definition, SS("joins"))) { PHALCON_OBS_VAR(joins); phalcon_array_fetch_string(&joins, definition, SL("joins"), PH_NOISY); phalcon_is_iterable(joins, &ah2, &hp2, 0, 0); while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_HVALUE(join); PHALCON_OBS_NVAR(type); phalcon_array_fetch_string(&type, join, SL("type"), PH_NOISY); PHALCON_OBS_NVAR(table); phalcon_array_fetch_string(&table, join, SL("source"), PH_NOISY); PHALCON_CALL_METHOD(&sql_table, this_ptr, "getsqltable", table, escape_char); phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE); PHALCON_INIT_NVAR(sql_join); PHALCON_CONCAT_SVSV(sql_join, " ", type, " JOIN ", sql_table); /** * Check if the join has conditions */ if (phalcon_array_isset_string(join, SS("conditions"))) { PHALCON_OBS_NVAR(join_conditions_array); phalcon_array_fetch_string(&join_conditions_array, join, SL("conditions"), PH_NOISY); if (phalcon_fast_count_ev(join_conditions_array TSRMLS_CC)) { PHALCON_INIT_NVAR(join_expressions); array_init(join_expressions); phalcon_is_iterable(join_conditions_array, &ah3, &hp3, 0, 0); while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) { PHALCON_GET_HVALUE(join_condition); PHALCON_CALL_METHOD(&join_expression, this_ptr, "getsqlexpression", join_condition, escape_char); phalcon_array_append(&join_expressions, join_expression, PH_SEPARATE); zend_hash_move_forward_ex(ah3, &hp3); } PHALCON_INIT_NVAR(join_conditions); phalcon_fast_join_str(join_conditions, SL(" AND "), join_expressions TSRMLS_CC); PHALCON_SCONCAT_SV(sql_join, " ON ", join_conditions); } } phalcon_concat_self(&sql, sql_join TSRMLS_CC); zend_hash_move_forward_ex(ah2, &hp2); } } /** * Check for a WHERE clause */ if (phalcon_array_isset_string(definition, SS("where"))) { PHALCON_OBS_VAR(where_conditions); phalcon_array_fetch_string(&where_conditions, definition, SL("where"), PH_NOISY); if (Z_TYPE_P(where_conditions) == IS_ARRAY) { PHALCON_CALL_METHOD(&where_expression, this_ptr, "getsqlexpression", where_conditions, escape_char); PHALCON_SCONCAT_SV(sql, " WHERE ", where_expression); } else { PHALCON_SCONCAT_SV(sql, " WHERE ", where_conditions); } } /** * Check for a GROUP clause */ if (phalcon_array_isset_string(definition, SS("group"))) { PHALCON_INIT_VAR(group_items); array_init(group_items); PHALCON_OBS_VAR(group_fields); phalcon_array_fetch_string(&group_fields, definition, SL("group"), PH_NOISY); phalcon_is_iterable(group_fields, &ah4, &hp4, 0, 0); while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) { PHALCON_GET_HVALUE(group_field); PHALCON_CALL_METHOD(&group_expression, this_ptr, "getsqlexpression", group_field, escape_char); phalcon_array_append(&group_items, group_expression, PH_SEPARATE); zend_hash_move_forward_ex(ah4, &hp4); } PHALCON_INIT_VAR(group_sql); phalcon_fast_join_str(group_sql, SL(", "), group_items TSRMLS_CC); PHALCON_INIT_VAR(group_clause); PHALCON_CONCAT_SV(group_clause, " GROUP BY ", group_sql); phalcon_concat_self(&sql, group_clause TSRMLS_CC); } /** * Check for a HAVING clause */ if (phalcon_array_isset_string(definition, SS("having"))) { PHALCON_OBS_VAR(having_conditions); phalcon_array_fetch_string(&having_conditions, definition, SL("having"), PH_NOISY); PHALCON_CALL_METHOD(&having_expression, this_ptr, "getsqlexpression", having_conditions, escape_char); PHALCON_SCONCAT_SV(sql, " HAVING ", having_expression); } /** * Check for a ORDER clause */ if (phalcon_array_isset_string(definition, SS("order"))) { PHALCON_OBS_VAR(order_fields); phalcon_array_fetch_string(&order_fields, definition, SL("order"), PH_NOISY); PHALCON_INIT_VAR(order_items); array_init(order_items); phalcon_is_iterable(order_fields, &ah5, &hp5, 0, 0); while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) { PHALCON_GET_HVALUE(order_item); PHALCON_OBS_NVAR(order_expression); phalcon_array_fetch_long(&order_expression, order_item, 0, PH_NOISY); PHALCON_CALL_METHOD(&order_sql_item, this_ptr, "getsqlexpression", order_expression, escape_char); /** * In the numeric 1 position could be a ASC/DESC clause */ if (phalcon_array_isset_long(order_item, 1)) { PHALCON_OBS_NVAR(sql_order_type); phalcon_array_fetch_long(&sql_order_type, order_item, 1, PH_NOISY); PHALCON_INIT_NVAR(order_sql_item_type); PHALCON_CONCAT_VSV(order_sql_item_type, order_sql_item, " ", sql_order_type); } else { PHALCON_CPY_WRT(order_sql_item_type, order_sql_item); } phalcon_array_append(&order_items, order_sql_item_type, PH_SEPARATE); zend_hash_move_forward_ex(ah5, &hp5); } PHALCON_INIT_VAR(order_sql); phalcon_fast_join_str(order_sql, SL(", "), order_items TSRMLS_CC); PHALCON_SCONCAT_SV(sql, " ORDER BY ", order_sql); } /** * Oracle does not implement the LIMIT clause as some RDBMS do. * We have to simulate it with subqueries and ROWNUM. * Unfortunately because we use the column wildcard "*", * this puts an extra column into the query result set. */ if (phalcon_array_isset_string_fetch(&limit_value, definition, SS("limit"))) { if (likely(Z_TYPE_P(limit_value) == IS_ARRAY)) { if (likely(phalcon_array_isset_string_fetch(&number, limit_value, SS("number")))) { PHALCON_OBS_NVAR(tmp1); phalcon_array_fetch_string(&tmp1, number, SL("value"), PH_NOISY); if (phalcon_array_isset_string_fetch(&offset, limit_value, SS("offset"))) { PHALCON_OBS_NVAR(tmp2); phalcon_array_fetch_string(&tmp2, offset, SL("value"), PH_NOISY); } else { PHALCON_INIT_NVAR(tmp2); ZVAL_LONG(tmp2, 0); } z_one = PHALCON_GLOBAL(z_one); PHALCON_INIT_VAR(ini_range); phalcon_add_function(ini_range, tmp2, z_one TSRMLS_CC); PHALCON_INIT_VAR(end_range); phalcon_add_function(end_range, tmp2, tmp1 TSRMLS_CC); PHALCON_INIT_VAR(sql_limit); PHALCON_SCONCAT_SVSVSV(sql_limit,"SELECT Z2.* FROM (SELECT Z1.*, ROWNUM DB_ROWNUM FROM ( ", sql, " ) Z1 ) Z2 WHERE Z2.DB_ROWNUM BETWEEN ", ini_range , " AND ", end_range ); PHALCON_CPY_WRT(sql, sql_limit); } } else { PHALCON_INIT_VAR(ini_range); ZVAL_LONG(ini_range, 1); PHALCON_CPY_WRT(end_range, limit_value); PHALCON_INIT_VAR(sql_limit); PHALCON_SCONCAT_SVSVSV(sql_limit,"SELECT Z2.* FROM (SELECT Z1.*, ROWNUM DB_ROWNUM FROM ( ", sql, " ) Z1 ) Z2 WHERE Z2.DB_ROWNUM BETWEEN ", ini_range , " AND ", end_range ); PHALCON_CPY_WRT(sql, sql_limit); } } RETURN_CTOR(sql); }
/* ArchiveWriter::finish {{{ * */ ZEND_METHOD(ArchiveWriter, finish) { zval *this = getThis(); int resource_id; HashPosition pos; archive_file_t *arch; archive_entry_t **entry; int result, error_num; const char *error_string; mode_t mode; php_stream *stream; zend_error_handling error_handling; zend_replace_error_handling(EH_THROW, ce_ArchiveException, &error_handling TSRMLS_CC); if (!_archive_get_fd(this, &arch TSRMLS_CC)) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } if (zend_hash_sort(arch->entries, zend_qsort, _archive_pathname_compare, 0 TSRMLS_CC) == FAILURE) { RETURN_FALSE; } zend_hash_internal_pointer_reset_ex(arch->entries, &pos); while (zend_hash_get_current_data_ex(arch->entries, (void **)&entry, &pos) == SUCCESS) { mode = archive_entry_mode((*entry)->entry); if (S_ISREG(mode) && archive_entry_size((*entry)->entry) > 0) { if ((stream = php_stream_open_wrapper_ex((*entry)->filename, "r", ENFORCE_SAFE_MODE | REPORT_ERRORS, NULL, NULL))) { char buf[PHP_ARCHIVE_BUF_LEN]; int header_written=0; int read_bytes; while ((read_bytes = php_stream_read(stream, buf, PHP_ARCHIVE_BUF_LEN))) { if (!header_written) { /* write header only after the first successful read */ result = archive_write_header(arch->arch, (*entry)->entry); if (result == ARCHIVE_FATAL) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write entry header for file %s: fatal error", (*entry)->filename); zend_restore_error_handling(&error_handling TSRMLS_CC); return; } header_written = 1; } result = archive_write_data(arch->arch, buf, read_bytes); if (result <= 0) { error_num = archive_errno(arch->arch); error_string = archive_error_string(arch->arch); if (error_num && error_string) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write file %s to archive: error #%d, %s", (*entry)->filename, error_num, error_string); } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write file %s: unknown error %d", (*entry)->filename, result); } php_stream_close(stream); zend_restore_error_handling(&error_handling TSRMLS_CC); return; } } php_stream_close(stream); } } else { result = archive_write_header(arch->arch, (*entry)->entry); if (result == ARCHIVE_FATAL) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write entry header for file %s: fatal error", (*entry)->filename); zend_restore_error_handling(&error_handling TSRMLS_CC); return; } } zend_hash_move_forward_ex(arch->entries, &pos); } if ((resource_id = _archive_get_rsrc_id(this TSRMLS_CC))) { add_property_resource(this, "fd", 0); zend_list_delete(resource_id); zend_restore_error_handling(&error_handling TSRMLS_CC); RETURN_TRUE; } php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to finish writing of archive file"); zend_restore_error_handling(&error_handling TSRMLS_CC); }
/* {{{ _php_array_to_envp */ static php_process_env_t _php_array_to_envp(zval *environment, int is_persistent TSRMLS_DC) { zval **element; php_process_env_t env; char *string_key, *data; #ifndef PHP_WIN32 char **ep; #endif char *p; uint string_length, cnt, l, sizeenv=0, el_len; ulong num_key; HashTable *target_hash; HashPosition pos; memset(&env, 0, sizeof(env)); if (!environment) { return env; } cnt = zend_hash_num_elements(Z_ARRVAL_P(environment)); if (cnt < 1) { #ifndef PHP_WIN32 env.envarray = (char **) pecalloc(1, sizeof(char *), is_persistent); #endif env.envp = (char *) pecalloc(4, 1, is_persistent); return env; } target_hash = HASH_OF(environment); if (!target_hash) { return env; } /* first, we have to get the size of all the elements in the hash */ for (zend_hash_internal_pointer_reset_ex(target_hash, &pos); zend_hash_get_current_data_ex(target_hash, (void **) &element, &pos) == SUCCESS; zend_hash_move_forward_ex(target_hash, &pos)) { if (Z_TYPE_PP(element) != IS_STRING) { zval tmp; MAKE_COPY_ZVAL(element, &tmp); convert_to_string(&tmp); el_len = Z_STRLEN(tmp); zval_dtor(&tmp); } else { el_len = Z_STRLEN_PP(element); } if (el_len == 0) { continue; } sizeenv += el_len+1; switch (zend_hash_get_current_key_ex(target_hash, &string_key, &string_length, &num_key, 0, &pos)) { case HASH_KEY_IS_STRING: if (string_length == 0) { continue; } sizeenv += string_length; break; } } #ifndef PHP_WIN32 ep = env.envarray = (char **) pecalloc(cnt + 1, sizeof(char *), is_persistent); #endif p = env.envp = (char *) pecalloc(sizeenv + 4, 1, is_persistent); for (zend_hash_internal_pointer_reset_ex(target_hash, &pos); zend_hash_get_current_data_ex(target_hash, (void **) &element, &pos) == SUCCESS; zend_hash_move_forward_ex(target_hash, &pos)) { zval tmp; if (Z_TYPE_PP(element) != IS_STRING) { MAKE_COPY_ZVAL(element, &tmp); convert_to_string(&tmp); } else { tmp = **element; } el_len = Z_STRLEN(tmp); if (el_len == 0) { goto next_element; } data = Z_STRVAL(tmp); switch (zend_hash_get_current_key_ex(target_hash, &string_key, &string_length, &num_key, 0, &pos)) { case HASH_KEY_IS_STRING: if (string_length == 0) { goto next_element; } l = string_length + el_len + 1; memcpy(p, string_key, string_length); strncat(p, "=", 1); strncat(p, data, el_len); #ifndef PHP_WIN32 *ep = p; ++ep; #endif p += l; break; case HASH_KEY_IS_LONG: memcpy(p,data,el_len); #ifndef PHP_WIN32 *ep = p; ++ep; #endif p += el_len + 1; break; case HASH_KEY_NON_EXISTENT: break; } next_element: if (Z_TYPE_PP(element) != IS_STRING) { zval_dtor(&tmp); } } assert((uint)(p - env.envp) <= sizeenv); zend_hash_internal_pointer_reset_ex(target_hash, &pos); return env; }
/** * Returns an array of Phalcon\Db\Column objects describing a table * * <code> * print_r($connection->describeColumns("posts")); ?> * </code> * * @param string $table * @param string $schema * @return Phalcon\Db\Column[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeColumns){ zval *table, *schema = NULL, *dialect, *ztrue, *sql, *fetch_num; zval *describe, *old_column = NULL, *size_pattern, *columns; zval *field = NULL, *definition = NULL, *column_type = NULL, *matches = NULL; zval *pos = NULL, *match_one = NULL, *match_two = NULL, *attribute = NULL, *column_name = NULL; zval *column = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &table, &schema); if (!schema) { PHALCON_INIT_VAR(schema); } PHALCON_OBS_VAR(dialect); phalcon_read_property_this(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_INIT_VAR(ztrue); ZVAL_BOOL(ztrue, 1); /** * Get the SQL to describe a table */ PHALCON_INIT_VAR(sql); phalcon_call_method_p2(sql, dialect, "describecolumns", table, schema); /** * We're using FETCH_NUM to fetch the columns */ PHALCON_INIT_VAR(fetch_num); ZVAL_LONG(fetch_num, 3); /** * Get the describe */ PHALCON_INIT_VAR(describe); phalcon_call_method_p2(describe, this_ptr, "fetchall", sql, fetch_num); PHALCON_INIT_VAR(old_column); PHALCON_INIT_VAR(size_pattern); ZVAL_STRING(size_pattern, "#\\(([0-9]++)(?:,\\s*([0-9]++))?\\)#", 1); PHALCON_INIT_VAR(columns); array_init(columns); /** * Field Indexes: 0:name, 1:type, 2:not null, 3:key, 4:default, 5:extra */ phalcon_is_iterable(describe, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(field); /** * By default the bind types is two */ PHALCON_INIT_NVAR(definition); array_init_size(definition, 1); add_assoc_long_ex(definition, SS("bindType"), 2); /** * By checking every column type we convert it to a Phalcon\Db\Column */ PHALCON_OBS_NVAR(column_type); phalcon_array_fetch_long(&column_type, field, 1, PH_NOISY); while (1) { /** * Enum are treated as char */ if (phalcon_memnstr_str(column_type, SL("enum"))) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE); break; } /** * Smallint/Bigint/Integers/Int are int */ if (phalcon_memnstr_str(column_type, SL("int"))) { phalcon_array_update_string_long(&definition, SL("type"), 0, PH_SEPARATE); phalcon_array_update_string(&definition, SL("isNumeric"), &ztrue, PH_COPY | PH_SEPARATE); phalcon_array_update_string_long(&definition, SL("bindType"), 1, PH_SEPARATE); break; } /** * Varchar are varchars */ if (phalcon_memnstr_str(column_type, SL("varchar"))) { phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE); break; } /** * Special type for datetime */ if (phalcon_memnstr_str(column_type, SL("datetime"))) { phalcon_array_update_string_long(&definition, SL("type"), 4, PH_SEPARATE); break; } /** * Decimals are floats */ if (phalcon_memnstr_str(column_type, SL("decimal"))) { phalcon_array_update_string_long(&definition, SL("type"), 3, PH_SEPARATE); phalcon_array_update_string(&definition, SL("isNumeric"), &ztrue, PH_COPY | PH_SEPARATE); phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE); break; } /** * Chars are chars */ if (phalcon_memnstr_str(column_type, SL("char"))) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE); break; } /** * Date/Datetime are varchars */ if (phalcon_memnstr_str(column_type, SL("date"))) { phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE); break; } /** * Text are varchars */ if (phalcon_memnstr_str(column_type, SL("text"))) { phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE); break; } /** * Float/Smallfloats/Decimals are float */ if (phalcon_memnstr_str(column_type, SL("float"))) { phalcon_array_update_string_long(&definition, SL("type"), 7, PH_SEPARATE); phalcon_array_update_string(&definition, SL("isNumeric"), &ztrue, PH_COPY | PH_SEPARATE); phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE); break; } /** * By default is string */ phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE); break; } /** * If the column type has a parentheses we try to get the column size from it */ if (phalcon_memnstr_str(column_type, SL("("))) { PHALCON_INIT_NVAR(matches); PHALCON_INIT_NVAR(pos); phalcon_preg_match(pos, size_pattern, column_type, matches TSRMLS_CC); if (zend_is_true(pos)) { if (phalcon_array_isset_long(matches, 1)) { PHALCON_OBS_NVAR(match_one); phalcon_array_fetch_long(&match_one, matches, 1, PH_NOISY); phalcon_array_update_string(&definition, SL("size"), &match_one, PH_COPY | PH_SEPARATE); } if (phalcon_array_isset_long(matches, 2)) { PHALCON_OBS_NVAR(match_two); phalcon_array_fetch_long(&match_two, matches, 2, PH_NOISY); phalcon_array_update_string(&definition, SL("scale"), &match_two, PH_COPY | PH_SEPARATE); } } } /** * Check if the column is unsigned, only MySQL support this */ if (phalcon_memnstr_str(column_type, SL("unsigned"))) { phalcon_array_update_string(&definition, SL("unsigned"), &ztrue, PH_COPY | PH_SEPARATE); } /** * Positions */ if (!zend_is_true(old_column)) { phalcon_array_update_string(&definition, SL("first"), &ztrue, PH_COPY | PH_SEPARATE); } else { phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE); } /** * Check if the field is primary key */ PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_long(&attribute, field, 3, PH_NOISY); if (PHALCON_IS_STRING(attribute, "PRI")) { phalcon_array_update_string(&definition, SL("primary"), &ztrue, PH_COPY | PH_SEPARATE); } /** * Check if the column allows null values */ PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_long(&attribute, field, 2, PH_NOISY); if (PHALCON_IS_STRING(attribute, "NO")) { phalcon_array_update_string(&definition, SL("notNull"), &ztrue, PH_COPY | PH_SEPARATE); } /** * Check if the column is auto increment */ PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_long(&attribute, field, 5, PH_NOISY); if (PHALCON_IS_STRING(attribute, "auto_increment")) { phalcon_array_update_string(&definition, SL("autoIncrement"), &ztrue, PH_COPY | PH_SEPARATE); } PHALCON_OBS_NVAR(column_name); phalcon_array_fetch_long(&column_name, field, 0, PH_NOISY); /** * Every route is stored as a Phalcon\Db\Column */ PHALCON_INIT_NVAR(column); object_init_ex(column, phalcon_db_column_ce); phalcon_call_method_p2_noret(column, "__construct", column_name, definition); phalcon_array_append(&columns, column, PH_SEPARATE); PHALCON_CPY_WRT(old_column, column_name); zend_hash_move_forward_ex(ah0, &hp0); } RETURN_CTOR(columns); }