/**
* Transforms an intermediate representation for a expression into a database system valid expression
*
* @param array expression
* @param string escapeChar
* @return string
*/
PHP_METHOD(Pdm_Db_AbstractDialect, getSqlExpression) {
zephir_fcall_cache_entry *_10 = NULL;
HashTable *_7, *_13;
HashPosition _6, _12;
int ZEPHIR_LAST_CALL_STATUS;
zval *escapeChar = NULL, *_1 = NULL;
zval *expression, *escapeChar_param = NULL, *type, *domain, *operator, *left = NULL, *right = NULL, *name = NULL, *sqlItems, *escapedName = NULL, *sqlArguments, *arguments, *argument = NULL, *item = NULL, *_0, *_2, *_3, *_4, *_5 = NULL, **_8, *_9 = NULL, *_11 = NULL, **_14, *_15, *_16;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &expression, &escapeChar_param);
if (!escapeChar_param) {
ZEPHIR_INIT_VAR(escapeChar);
ZVAL_EMPTY_STRING(escapeChar);
} else {
zephir_get_strval(escapeChar, escapeChar_param);
}
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
if (ZEPHIR_IS_STRING_IDENTICAL(escapeChar, "")) {
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("escapeChar"), PH_NOISY_CC);
zephir_get_strval(_1, _0);
ZEPHIR_CPY_WRT(escapeChar, _1);
}
}
if (Z_TYPE_P(expression) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "Invalid SQL expression", "pdm/db/abstractdialect.zep", 176);
return;
}
ZEPHIR_OBS_VAR(type);
if (!(zephir_array_isset_string_fetch(&type, expression, SS("type"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "Invalid SQL expression", "pdm/db/abstractdialect.zep", 180);
return;
}
if (ZEPHIR_IS_STRING(type, "qualified")) {
ZEPHIR_OBS_VAR(name);
zephir_array_fetch_string(&name, expression, SL("name"), PH_NOISY TSRMLS_CC);
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_INIT_VAR(escapedName);
ZEPHIR_CONCAT_VVV(escapedName, escapeChar, name, escapeChar);
} else {
ZEPHIR_CPY_WRT(escapedName, name);
}
ZEPHIR_OBS_VAR(domain);
if (zephir_array_isset_string_fetch(&domain, expression, SS("domain"), 0 TSRMLS_CC)) {
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_CONCAT_VVVSV(return_value, escapeChar, domain, escapeChar, ".", escapedName);
RETURN_MM();
} else {
ZEPHIR_CONCAT_VSV(return_value, domain, ".", escapedName);
RETURN_MM();
}
}
RETURN_CCTOR(escapedName);
}
if (ZEPHIR_IS_STRING(type, "literal")) {
zephir_array_fetch_string(&_2, expression, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC);
RETURN_CTOR(_2);
}
if (ZEPHIR_IS_STRING(type, "binary-op")) {
zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&left, this_ptr, "getsqlexpression", NULL, _2, escapeChar);
zephir_check_call_status();
zephir_array_fetch_string(&_3, expression, SL("right"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&right, this_ptr, "getsqlexpression", NULL, _3, escapeChar);
zephir_check_call_status();
zephir_array_fetch_string(&_4, expression, SL("op"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CONCAT_VSVSV(return_value, left, " ", _4, " ", right);
RETURN_MM();
}
if (ZEPHIR_IS_STRING(type, "unary-op")) {
ZEPHIR_OBS_VAR(operator);
zephir_array_fetch_string(&operator, expression, SL("op"), PH_NOISY TSRMLS_CC);
ZEPHIR_OBS_NVAR(left);
if (zephir_array_isset_string_fetch(&left, expression, SS("left"), 0 TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", NULL, left, escapeChar);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(return_value, _5, operator);
RETURN_MM();
}
ZEPHIR_OBS_NVAR(right);
if (zephir_array_isset_string_fetch(&right, expression, SS("right"), 0 TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", NULL, right, escapeChar);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(return_value, _5, operator);
RETURN_MM();
}
}
if (ZEPHIR_IS_STRING(type, "placeholder")) {
zephir_array_fetch_string(&_2, expression, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC);
RETURN_CTOR(_2);
}
if (ZEPHIR_IS_STRING(type, "parentheses")) {
zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", NULL, _2, escapeChar);
zephir_check_call_status();
ZEPHIR_CONCAT_SVS(return_value, "(", _5, ")");
RETURN_MM();
}
if (ZEPHIR_IS_STRING(type, "functionCall")) {
ZEPHIR_OBS_NVAR(name);
zephir_array_fetch_string(&name, expression, SL("name"), PH_NOISY TSRMLS_CC);
ZEPHIR_INIT_VAR(sqlArguments);
array_init(sqlArguments);
ZEPHIR_OBS_VAR(arguments);
if (zephir_array_isset_string_fetch(&arguments, expression, SS("arguments"), 0 TSRMLS_CC)) {
zephir_is_iterable(arguments, &_7, &_6, 0, 0);
for (
; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS
; zephir_hash_move_forward_ex(_7, &_6)
) {
ZEPHIR_GET_HVALUE(argument, _8);
ZEPHIR_CALL_METHOD(&_9, this_ptr, "getsqlexpression", &_10, argument, escapeChar);
zephir_check_call_status();
zephir_array_append(&sqlArguments, _9, PH_SEPARATE);
}
ZEPHIR_INIT_VAR(_11);
zephir_fast_join_str(_11, SL(", "), sqlArguments TSRMLS_CC);
ZEPHIR_CONCAT_VSVS(return_value, name, "(", _11, ")");
RETURN_MM();
} else {
ZEPHIR_CONCAT_VS(return_value, name, "()");
RETURN_MM();
}
}
if (ZEPHIR_IS_STRING(type, "list")) {
ZEPHIR_INIT_VAR(sqlItems);
array_init(sqlItems);
zephir_array_fetch_long(&_2, expression, 0, PH_NOISY | PH_READONLY TSRMLS_CC);
zephir_is_iterable(_2, &_13, &_12, 0, 0);
for (
; zephir_hash_get_current_data_ex(_13, (void**) &_14, &_12) == SUCCESS
; zephir_hash_move_forward_ex(_13, &_12)
) {
ZEPHIR_GET_HVALUE(item, _14);
ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", &_10, item, escapeChar);
zephir_check_call_status();
zephir_array_append(&sqlItems, _5, PH_SEPARATE);
}
ZEPHIR_INIT_NVAR(_11);
zephir_fast_join_str(_11, SL(", "), sqlItems TSRMLS_CC);
ZEPHIR_CONCAT_SVS(return_value, "(", _11, ")");
RETURN_MM();
}
if (ZEPHIR_IS_STRING(type, "all")) {
RETURN_MM_STRING("*", 1);
}
if (ZEPHIR_IS_STRING(type, "cast")) {
zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&left, this_ptr, "getsqlexpression", &_10, _2, escapeChar);
zephir_check_call_status();
zephir_array_fetch_string(&_3, expression, SL("right"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&right, this_ptr, "getsqlexpression", &_10, _3, escapeChar);
zephir_check_call_status();
ZEPHIR_CONCAT_SVSVS(return_value, "CAST(", left, " AS ", right, ")");
RETURN_MM();
}
if (ZEPHIR_IS_STRING(type, "convert")) {
zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&left, this_ptr, "getsqlexpression", &_10, _2, escapeChar);
zephir_check_call_status();
zephir_array_fetch_string(&_3, expression, SL("right"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&right, this_ptr, "getsqlexpression", &_10, _3, escapeChar);
zephir_check_call_status();
ZEPHIR_CONCAT_SVSVS(return_value, "CONVERT(", left, " USING ", right, ")");
RETURN_MM();
}
ZEPHIR_INIT_VAR(_15);
object_init_ex(_15, pdm_db_exception_ce);
ZEPHIR_INIT_VAR(_16);
ZEPHIR_CONCAT_SVS(_16, "Invalid SQL expression type '", type, "'");
ZEPHIR_CALL_METHOD(NULL, _15, "__construct", NULL, _16);
zephir_check_call_status();
zephir_throw_exception_debug(_15, "pdm/db/abstractdialect.zep", 287 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
/**
* Internal handler to call a queue of events
*
* @param \SplPriorityQueue|array queue
* @param Phalcon\Events\Event event
* @return mixed
*/
PHP_METHOD(Phalcon_Events_Manager, fireQueue) {
HashTable *_12;
HashPosition _11;
zephir_fcall_cache_entry *_8 = NULL, *_9 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_4 = NULL, *_5 = NULL;
zend_bool collect, cancelable, _6;
zval *queue, *event, *status = NULL, *arguments = NULL, *eventName = NULL, *data = NULL, *iterator, *source = NULL, *handler = NULL, *_0, *_1, _2, *_3 = NULL, *_7, *_10 = NULL, **_13;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &queue, &event);
if (Z_TYPE_P(queue) != IS_ARRAY) {
if (Z_TYPE_P(queue) == IS_OBJECT) {
if (!(zephir_instance_of_ev(queue, spl_ce_SplPriorityQueue TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, phalcon_events_exception_ce);
ZEPHIR_INIT_VAR(_1);
zephir_get_class(_1, queue, 0 TSRMLS_CC);
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "Unexpected value type: expected object of type SplPriorityQueue, %s given", 0);
ZEPHIR_CALL_FUNCTION(&_3, "sprintf", &_4, &_2, _1);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_5, _3);
zephir_check_call_status();
zephir_throw_exception_debug(_0, "phalcon/events/manager.zep", 223 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_events_exception_ce, "The queue is not valid", "phalcon/events/manager.zep", 226);
return;
}
}
_6 = Z_TYPE_P(event) != IS_OBJECT;
if (!(_6)) {
_6 = !((zephir_instance_of_ev(event, phalcon_events_event_ce TSRMLS_CC)));
}
if (_6) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_events_exception_ce, "The event is not valid", "phalcon/events/manager.zep", 231);
return;
}
ZEPHIR_INIT_VAR(status);
ZVAL_NULL(status);
ZEPHIR_INIT_VAR(arguments);
ZVAL_NULL(arguments);
ZEPHIR_CALL_METHOD(&eventName, event, "gettype", NULL);
zephir_check_call_status();
if (Z_TYPE_P(eventName) != IS_STRING) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_events_exception_ce, "The event type not valid", "phalcon/events/manager.zep", 239);
return;
}
ZEPHIR_CALL_METHOD(&source, event, "getsource", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&data, event, "getdata", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_3, event, "getcancelable", NULL);
zephir_check_call_status();
cancelable = zephir_get_boolval(_3);
ZEPHIR_OBS_VAR(_7);
zephir_read_property_this(&_7, this_ptr, SL("_collect"), PH_NOISY_CC);
collect = zephir_get_boolval(_7);
if (Z_TYPE_P(queue) == IS_OBJECT) {
ZEPHIR_INIT_VAR(iterator);
if (zephir_clone(iterator, queue TSRMLS_CC) == FAILURE) {
RETURN_MM();
}
ZEPHIR_CALL_METHOD(NULL, iterator, "top", NULL);
zephir_check_call_status();
while (1) {
ZEPHIR_CALL_METHOD(&_3, iterator, "valid", NULL);
zephir_check_call_status();
if (!(zephir_is_true(_3))) {
break;
}
ZEPHIR_CALL_METHOD(&handler, iterator, "current", &_8);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, iterator, "next", &_9);
zephir_check_call_status();
if (Z_TYPE_P(handler) == IS_OBJECT) {
if (zephir_instance_of_ev(handler, zend_ce_closure TSRMLS_CC)) {
if (Z_TYPE_P(arguments) == IS_NULL) {
ZEPHIR_INIT_NVAR(arguments);
zephir_create_array(arguments, 3, 0 TSRMLS_CC);
zephir_array_fast_append(arguments, event);
zephir_array_fast_append(arguments, source);
zephir_array_fast_append(arguments, data);
}
ZEPHIR_INIT_NVAR(status);
ZEPHIR_CALL_USER_FUNC_ARRAY(status, handler, arguments);
zephir_check_call_status();
if (collect) {
zephir_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC);
}
if (cancelable) {
ZEPHIR_CALL_METHOD(&_10, event, "isstopped", NULL);
zephir_check_call_status();
if (zephir_is_true(_10)) {
break;
}
}
} else {
if ((zephir_method_exists(handler, eventName TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD_ZVAL(&status, handler, eventName, NULL, event, source, data);
zephir_check_call_status();
if (collect) {
zephir_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC);
}
if (cancelable) {
ZEPHIR_CALL_METHOD(&_10, event, "isstopped", NULL);
zephir_check_call_status();
if (zephir_is_true(_10)) {
break;
}
}
}
}
}
}
} else {
zephir_is_iterable(queue, &_12, &_11, 0, 0, "phalcon/events/manager.zep", 380);
for (
; zephir_hash_get_current_data_ex(_12, (void**) &_13, &_11) == SUCCESS
; zephir_hash_move_forward_ex(_12, &_11)
) {
ZEPHIR_GET_HVALUE(handler, _13);
if (Z_TYPE_P(handler) == IS_OBJECT) {
if (zephir_instance_of_ev(handler, zend_ce_closure TSRMLS_CC)) {
if (Z_TYPE_P(arguments) == IS_NULL) {
ZEPHIR_INIT_NVAR(arguments);
zephir_create_array(arguments, 3, 0 TSRMLS_CC);
zephir_array_fast_append(arguments, event);
zephir_array_fast_append(arguments, source);
zephir_array_fast_append(arguments, data);
}
ZEPHIR_INIT_NVAR(status);
ZEPHIR_CALL_USER_FUNC_ARRAY(status, handler, arguments);
zephir_check_call_status();
if (collect) {
zephir_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC);
}
if (cancelable) {
ZEPHIR_CALL_METHOD(&_3, event, "isstopped", NULL);
zephir_check_call_status();
if (zephir_is_true(_3)) {
break;
}
}
} else {
if ((zephir_method_exists(handler, eventName TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD_ZVAL(&status, handler, eventName, NULL, event, source, data);
zephir_check_call_status();
if (collect) {
zephir_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC);
}
if (cancelable) {
ZEPHIR_CALL_METHOD(&_10, event, "isstopped", NULL);
zephir_check_call_status();
if (zephir_is_true(_10)) {
break;
}
}
}
}
}
}
}
RETURN_CCTOR(status);
}
/**
* Attach a listener to the events manager
*
* @param string eventType
* @param object|callable handler
* @param int priority
*/
PHP_METHOD(Phalcon_Events_Manager, attach) {
zephir_nts_static zephir_fcall_cache_entry *_3 = NULL, *_4 = NULL;
int priority, ZEPHIR_LAST_CALL_STATUS;
zval *eventType_param = NULL, *handler, *priority_param = NULL, *priorityQueue = NULL, *_0, *_1, *_2 = NULL;
zval *eventType = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &eventType_param, &handler, &priority_param);
if (unlikely(Z_TYPE_P(eventType_param) != IS_STRING && Z_TYPE_P(eventType_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'eventType' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(eventType_param) == IS_STRING)) {
zephir_get_strval(eventType, eventType_param);
} else {
ZEPHIR_INIT_VAR(eventType);
ZVAL_EMPTY_STRING(eventType);
}
if (!priority_param) {
priority = 100;
} else {
if (unlikely(Z_TYPE_P(priority_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'priority' must be a long/integer") TSRMLS_CC);
RETURN_MM_NULL();
}
priority = Z_LVAL_P(priority_param);
}
if (Z_TYPE_P(handler) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_events_exception_ce, "Event handler must be an Object", "phalcon/events/manager.zep", 56);
return;
}
ZEPHIR_OBS_VAR(priorityQueue);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_events"), PH_NOISY_CC);
if (!(zephir_array_isset_fetch(&priorityQueue, _0, eventType, 0 TSRMLS_CC))) {
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_enablePriorities"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(priorityQueue);
if (zephir_is_true(_1)) {
object_init_ex(priorityQueue, spl_ce_SplPriorityQueue);
if (zephir_has_constructor(priorityQueue TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, priorityQueue, "__construct", NULL);
zephir_check_call_status();
}
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, 1);
ZEPHIR_CALL_METHOD(NULL, priorityQueue, "setextractflags", &_3, _2);
zephir_check_call_status();
zephir_update_property_array(this_ptr, SL("_events"), eventType, priorityQueue TSRMLS_CC);
} else {
array_init(priorityQueue);
}
}
if (Z_TYPE_P(priorityQueue) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_2);
ZVAL_LONG(_2, priority);
ZEPHIR_CALL_METHOD(NULL, priorityQueue, "insert", &_4, handler, _2);
zephir_check_call_status();
} else {
zephir_array_append(&priorityQueue, handler, PH_SEPARATE, "phalcon/events/manager.zep", 82);
zephir_update_property_array(this_ptr, SL("_events"), eventType, priorityQueue TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
/**
* Reads annotations from the class dockblocks, its methods and/or properties
*/
PHP_METHOD(Phalcon_Annotations_Reader, parse) {
HashTable *_3$$5, *_9$$10;
HashPosition _2$$5, _8$$10;
int ZEPHIR_LAST_CALL_STATUS, line = 0;
zval *className_param = NULL, *annotations = NULL, *reflection = NULL, *comment = NULL, *properties = NULL, *methods = NULL, *property = NULL, *method = NULL, *classAnnotations = NULL, *annotationsProperties = NULL, *propertyAnnotations = NULL, *annotationsMethods = NULL, *methodAnnotations = NULL, *_0$$3 = NULL, *_1$$3 = NULL, **_4$$5, *_5$$7 = NULL, *_6$$7 = NULL, *_7$$8 = NULL, **_10$$10, *_11$$12 = NULL, *_12$$12 = NULL, *_13$$13 = NULL;
zval *className = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &className_param);
zephir_get_strval(className, className_param);
ZEPHIR_INIT_VAR(annotations);
array_init(annotations);
ZEPHIR_INIT_VAR(reflection);
object_init_ex(reflection, zephir_get_internal_ce(SS("reflectionclass") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, reflection, "__construct", NULL, 66, className);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&comment, reflection, "getdoccomment", NULL, 89);
zephir_check_call_status();
if (Z_TYPE_P(comment) == IS_STRING) {
ZEPHIR_INIT_VAR(classAnnotations);
ZEPHIR_CALL_METHOD(&_0$$3, reflection, "getfilename", NULL, 90);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_1$$3, reflection, "getstartline", NULL, 91);
zephir_check_call_status();
ZEPHIR_LAST_CALL_STATUS = phannot_parse_annotations(classAnnotations, comment, _0$$3, _1$$3 TSRMLS_CC);
zephir_check_call_status();
if (Z_TYPE_P(classAnnotations) == IS_ARRAY) {
zephir_array_update_string(&annotations, SL("class"), &classAnnotations, PH_COPY | PH_SEPARATE);
}
}
ZEPHIR_CALL_METHOD(&properties, reflection, "getproperties", NULL, 92);
zephir_check_call_status();
if (zephir_fast_count_int(properties TSRMLS_CC)) {
line = 1;
ZEPHIR_INIT_VAR(annotationsProperties);
array_init(annotationsProperties);
zephir_is_iterable(properties, &_3$$5, &_2$$5, 0, 0, "phalcon/annotations/reader.zep", 96);
for (
; zephir_hash_get_current_data_ex(_3$$5, (void**) &_4$$5, &_2$$5) == SUCCESS
; zephir_hash_move_forward_ex(_3$$5, &_2$$5)
) {
ZEPHIR_GET_HVALUE(property, _4$$5);
ZEPHIR_CALL_METHOD(&comment, property, "getdoccomment", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(comment) == IS_STRING) {
ZEPHIR_INIT_NVAR(propertyAnnotations);
ZEPHIR_CALL_METHOD(&_5$$7, reflection, "getfilename", NULL, 90);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_6$$7);
ZVAL_LONG(_6$$7, line);
ZEPHIR_LAST_CALL_STATUS = phannot_parse_annotations(propertyAnnotations, comment, _5$$7, _6$$7 TSRMLS_CC);
zephir_check_call_status();
if (Z_TYPE_P(propertyAnnotations) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(_7$$8);
zephir_read_property(&_7$$8, property, SL("name"), PH_NOISY_CC);
zephir_array_update_zval(&annotationsProperties, _7$$8, &propertyAnnotations, PH_COPY | PH_SEPARATE);
}
}
}
if (zephir_fast_count_int(annotationsProperties TSRMLS_CC)) {
zephir_array_update_string(&annotations, SL("properties"), &annotationsProperties, PH_COPY | PH_SEPARATE);
}
}
ZEPHIR_CALL_METHOD(&methods, reflection, "getmethods", NULL, 93);
zephir_check_call_status();
if (zephir_fast_count_int(methods TSRMLS_CC)) {
ZEPHIR_INIT_VAR(annotationsMethods);
array_init(annotationsMethods);
zephir_is_iterable(methods, &_9$$10, &_8$$10, 0, 0, "phalcon/annotations/reader.zep", 126);
for (
; zephir_hash_get_current_data_ex(_9$$10, (void**) &_10$$10, &_8$$10) == SUCCESS
; zephir_hash_move_forward_ex(_9$$10, &_8$$10)
) {
ZEPHIR_GET_HVALUE(method, _10$$10);
ZEPHIR_CALL_METHOD(&comment, method, "getdoccomment", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(comment) == IS_STRING) {
ZEPHIR_INIT_NVAR(methodAnnotations);
ZEPHIR_CALL_METHOD(&_11$$12, method, "getfilename", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_12$$12, method, "getstartline", NULL, 0);
zephir_check_call_status();
ZEPHIR_LAST_CALL_STATUS = phannot_parse_annotations(methodAnnotations, comment, _11$$12, _12$$12 TSRMLS_CC);
zephir_check_call_status();
if (Z_TYPE_P(methodAnnotations) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(_13$$13);
zephir_read_property(&_13$$13, method, SL("name"), PH_NOISY_CC);
zephir_array_update_zval(&annotationsMethods, _13$$13, &methodAnnotations, PH_COPY | PH_SEPARATE);
}
}
}
if (zephir_fast_count_int(annotationsMethods TSRMLS_CC)) {
zephir_array_update_string(&annotations, SL("methods"), &annotationsMethods, PH_COPY | PH_SEPARATE);
}
}
RETURN_CCTOR(annotations);
}
/**
* Sets locale information
*
* <code>
* // Set locale to Dutch
* $gettext->setLocale(LC_ALL, 'nl_NL');
*
* // Try different possible locale names for german
* $gettext->setLocale(LC_ALL, 'de_DE@euro', 'de_DE', 'de', 'ge');
* </code>
*/
PHP_METHOD(Phalcon_Translate_Adapter_Gettext, setLocale) {
zephir_fcall_cache_entry *_5 = NULL;
zval *locale = NULL;
zval *category_param = NULL, *locale_param = NULL, *_0, *_1 = NULL, _2, *_3, *_4, *_6, *_7, *_8, *_9, *_10, _11;
int category, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &category_param, &locale_param);
if (unlikely(Z_TYPE_P(category_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'category' must be a int") TSRMLS_CC);
RETURN_MM_NULL();
}
category = Z_LVAL_P(category_param);
if (unlikely(Z_TYPE_P(locale_param) != IS_STRING && Z_TYPE_P(locale_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'locale' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(locale_param) == IS_STRING)) {
zephir_get_strval(locale, locale_param);
} else {
ZEPHIR_INIT_VAR(locale);
ZVAL_EMPTY_STRING(locale);
}
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CALL_FUNCTION(&_1, "func_get_args", NULL, 163);
zephir_check_call_status();
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "setlocale", 0);
ZEPHIR_CALL_USER_FUNC_ARRAY(_0, &_2, _1);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_locale"), _0 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_3);
ZVAL_LONG(_3, category);
zephir_update_property_this(this_ptr, SL("_category"), _3 TSRMLS_CC);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_locale"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_4);
ZEPHIR_CONCAT_SV(_4, "LC_ALL=", _3);
ZEPHIR_CALL_FUNCTION(NULL, "putenv", &_5, 433, _4);
zephir_check_call_status();
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_locale"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_7);
ZEPHIR_CONCAT_SV(_7, "LANG=", _6);
ZEPHIR_CALL_FUNCTION(NULL, "putenv", &_5, 433, _7);
zephir_check_call_status();
_8 = zephir_fetch_nproperty_this(this_ptr, SL("_locale"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_9);
ZEPHIR_CONCAT_SV(_9, "LANGUAGE=", _8);
ZEPHIR_CALL_FUNCTION(NULL, "putenv", &_5, 433, _9);
zephir_check_call_status();
_10 = zephir_fetch_nproperty_this(this_ptr, SL("_locale"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_11);
ZVAL_LONG(&_11, 0);
ZEPHIR_CALL_FUNCTION(NULL, "setlocale", NULL, 413, &_11, _10);
zephir_check_call_status();
RETURN_MM_MEMBER(this_ptr, "_locale");
}
/**
* Finds the path to the file where the class is defined.
*
* @param string $class The name of the class
*
* @return string|false The path if found, false otherwise
*/
PHP_METHOD(Xpl_ClassLoader, findFile) {
zephir_fcall_cache_entry *_4 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *className_param = NULL, *file = NULL, *_0, _1, *_2, *_3, _5$$5, *_6$$5 = NULL, *_7$$6;
zval *className = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &className_param);
if (unlikely(Z_TYPE_P(className_param) != IS_STRING && Z_TYPE_P(className_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'className' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(className_param) == IS_STRING)) {
zephir_get_strval(className, className_param);
} else {
ZEPHIR_INIT_VAR(className);
ZVAL_EMPTY_STRING(className);
}
ZEPHIR_INIT_VAR(_0);
ZEPHIR_SINIT_VAR(_1);
ZVAL_STRING(&_1, "\\", 0);
zephir_fast_trim(_0, className, &_1, ZEPHIR_TRIM_LEFT TSRMLS_CC);
zephir_get_strval(className, _0);
ZEPHIR_OBS_VAR(file);
_2 = zephir_fetch_nproperty_this(this_ptr, SL("classMap"), PH_NOISY_CC);
if (zephir_array_isset_fetch(&file, _2, className, 0 TSRMLS_CC)) {
RETURN_CCTOR(file);
}
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, ".php", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&file, this_ptr, "findfilewithextension", &_4, 0, className, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(file) == IS_STRING) {
zephir_update_property_array(this_ptr, SL("classMap"), className, file TSRMLS_CC);
} else {
ZEPHIR_SINIT_VAR(_5$$5);
ZVAL_STRING(&_5$$5, "HHVM_VERSION", 0);
ZEPHIR_CALL_FUNCTION(&_6$$5, "defined", NULL, 55, &_5$$5);
zephir_check_call_status();
if (zephir_is_true(_6$$5)) {
ZEPHIR_INIT_VAR(_7$$6);
ZVAL_STRING(_7$$6, ".hh", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&file, this_ptr, "findfilewithextension", &_4, 0, className, _7$$6);
zephir_check_temp_parameter(_7$$6);
zephir_check_call_status();
if (Z_TYPE_P(file) == IS_STRING) {
zephir_update_property_array(this_ptr, SL("classMap"), className, file TSRMLS_CC);
RETURN_CCTOR(file);
}
}
ZEPHIR_INIT_NVAR(file);
ZVAL_BOOL(file, 0);
zephir_update_property_array(this_ptr, SL("classMap"), className, file TSRMLS_CC);
}
RETURN_CCTOR(file);
}
PHP_METHOD(Phalcon_Session_Adapter_Libmemcached, __construct) {
zval _8, _10;
zend_long ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL, *_2 = NULL;
zval options, *options_param = NULL, client, persistentId, prefix, servers, statsKey, ttl, _1, _3, _4, _5, _6, _7, _9;
zval *this_ptr = getThis();
ZVAL_UNDEF(&options);
ZVAL_UNDEF(&client);
ZVAL_UNDEF(&persistentId);
ZVAL_UNDEF(&prefix);
ZVAL_UNDEF(&servers);
ZVAL_UNDEF(&statsKey);
ZVAL_UNDEF(&ttl);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_3);
ZVAL_UNDEF(&_4);
ZVAL_UNDEF(&_5);
ZVAL_UNDEF(&_6);
ZVAL_UNDEF(&_7);
ZVAL_UNDEF(&_9);
ZVAL_UNDEF(&_8);
ZVAL_UNDEF(&_10);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &options_param);
if (!options_param) {
ZEPHIR_INIT_VAR(&options);
array_init(&options);
} else {
ZEPHIR_OBS_COPY_OR_DUP(&options, options_param);
}
ZEPHIR_CALL_PARENT(NULL, phalcon_session_adapter_libmemcached_ce, getThis(), "__construct", &_0, 0, &options);
zephir_check_call_status();
zephir_read_property(&_1, this_ptr, SL("options"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CPY_WRT(&options, &_1);
ZEPHIR_OBS_VAR(&servers);
if (!(zephir_array_isset_string_fetch(&servers, &options, SL("servers"), 0))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_session_exception_ce, "No 'servers' specified in the options", "phalcon/session/adapter/libmemcached.zep", 63);
return;
}
ZEPHIR_INIT_VAR(&_3);
array_init(&_3);
ZEPHIR_INIT_VAR(&_4);
ZVAL_STRING(&_4, "client");
ZEPHIR_CALL_CE_STATIC(&client, phalcon_helper_arr_ce, "get", &_2, 155, &options, &_4, &_3);
zephir_check_call_status();
zephir_read_property(&_1, this_ptr, SL("ttl"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_INIT_NVAR(&_4);
ZVAL_STRING(&_4, "ttl");
ZEPHIR_CALL_CE_STATIC(&ttl, phalcon_helper_arr_ce, "get", &_2, 155, &options, &_4, &_1);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_4);
ZVAL_STRING(&_4, "statsKey");
ZEPHIR_INIT_VAR(&_5);
ZVAL_STRING(&_5, "");
ZEPHIR_CALL_CE_STATIC(&statsKey, phalcon_helper_arr_ce, "get", &_2, 155, &options, &_4, &_5);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(&_4);
ZVAL_STRING(&_4, "persistent_id");
ZEPHIR_INIT_NVAR(&_5);
ZVAL_STRING(&_5, "phalcon-session");
ZEPHIR_CALL_CE_STATIC(&persistentId, phalcon_helper_arr_ce, "get", &_2, 155, &options, &_4, &_5);
zephir_check_call_status();
ZVAL_LONG(&_6, 2592000);
ZEPHIR_CALL_FUNCTION(&_7, "min", NULL, 416, &ttl, &_6);
zephir_check_call_status();
zephir_update_property_zval(this_ptr, SL("ttl"), &_7);
ZEPHIR_INIT_NVAR(&_4);
object_init_ex(&_4, phalcon_cache_backend_libmemcached_ce);
ZEPHIR_INIT_NVAR(&_5);
object_init_ex(&_5, phalcon_cache_frontend_data_ce);
ZEPHIR_INIT_VAR(&_8);
zephir_create_array(&_8, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(&_9);
zephir_read_property(&_9, this_ptr, SL("ttl"), PH_NOISY_CC);
zephir_array_update_string(&_8, SL("lifetime"), &_9, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, &_5, "__construct", NULL, 333, &_8);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_10);
zephir_create_array(&_10, 5, 0 TSRMLS_CC);
zephir_array_update_string(&_10, SL("servers"), &servers, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_10, SL("client"), &client, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_10, SL("prefix"), &prefix, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_10, SL("statsKey"), &statsKey, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_10, SL("persistent_id"), &persistentId, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, &_4, "__construct", NULL, 334, &_5, &_10);
zephir_check_call_status();
zephir_update_property_zval(this_ptr, SL("connection"), &_4);
ZEPHIR_MM_RESTORE();
}
/**
* Sends SQL statements to the database server returning the success state.
* Use this method only when the SQL statement sent to the server doesn't return any rows
*
*<code>
* //Inserting data
* $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')");
* $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy'));
*</code>
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, execute) {
int ZEPHIR_LAST_CALL_STATUS;
zval *sqlStatement_param = NULL, *bindParams = NULL, *bindTypes = NULL, *eventsManager = NULL, *affectedRows = NULL, *pdo = NULL, *newStatement = NULL, *statement = NULL, *_0, *_1$$3 = NULL, *_2$$3, *_3$$9;
zval *sqlStatement = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &sqlStatement_param, &bindParams, &bindTypes);
if (unlikely(Z_TYPE_P(sqlStatement_param) != IS_STRING && Z_TYPE_P(sqlStatement_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'sqlStatement' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(sqlStatement_param) == IS_STRING)) {
zephir_get_strval(sqlStatement, sqlStatement_param);
} else {
ZEPHIR_INIT_VAR(sqlStatement);
ZVAL_EMPTY_STRING(sqlStatement);
}
if (!bindParams) {
bindParams = ZEPHIR_GLOBAL(global_null);
}
if (!bindTypes) {
bindTypes = ZEPHIR_GLOBAL(global_null);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(eventsManager, _0);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
zephir_update_property_this(this_ptr, SL("_sqlStatement"), sqlStatement TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_sqlVariables"), bindParams TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_sqlBindTypes"), bindTypes TSRMLS_CC);
ZEPHIR_INIT_VAR(_2$$3);
ZVAL_STRING(_2$$3, "db:beforeQuery", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1$$3, eventsManager, "fire", NULL, 0, _2$$3, this_ptr);
zephir_check_temp_parameter(_2$$3);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_1$$3)) {
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_VAR(affectedRows);
ZVAL_LONG(affectedRows, 0);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_pdo"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(pdo, _0);
if (Z_TYPE_P(bindParams) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&statement, pdo, "prepare", NULL, 0, sqlStatement);
zephir_check_call_status();
if (Z_TYPE_P(statement) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&newStatement, this_ptr, "executeprepared", NULL, 0, statement, bindParams, bindTypes);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&affectedRows, newStatement, "rowcount", NULL, 0);
zephir_check_call_status();
}
} else {
ZEPHIR_CALL_METHOD(&affectedRows, pdo, "exec", NULL, 0, sqlStatement);
zephir_check_call_status();
}
if (Z_TYPE_P(affectedRows) == IS_LONG) {
zephir_update_property_this(this_ptr, SL("_affectedRows"), affectedRows TSRMLS_CC);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_3$$9);
ZVAL_STRING(_3$$9, "db:afterQuery", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _3$$9, this_ptr);
zephir_check_temp_parameter(_3$$9);
zephir_check_call_status();
}
}
RETURN_MM_BOOL(1);
}
/**
* Converts bound parameters such as :name: or ?1 into PDO bind params ?
*
*<code>
* print_r($connection->convertBoundParams('SELECT * FROM robots WHERE name = :name:', array('Bender')));
*</code>
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, convertBoundParams) {
HashTable *_3$$3;
HashPosition _2$$3;
int ZEPHIR_LAST_CALL_STATUS, setOrder = 0;
zval *params = NULL;
zval *sql_param = NULL, *params_param = NULL, *boundSql = NULL, *placeHolders = NULL, *bindPattern = NULL, *matches = NULL, *placeMatch = NULL, *value = NULL, *_0, *_1 = NULL, **_4$$3, *_7$$3, *_5$$4, *_6$$6;
zval *sql = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &sql_param, ¶ms_param);
if (unlikely(Z_TYPE_P(sql_param) != IS_STRING && Z_TYPE_P(sql_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'sql' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(sql_param) == IS_STRING)) {
zephir_get_strval(sql, sql_param);
} else {
ZEPHIR_INIT_VAR(sql);
ZVAL_EMPTY_STRING(sql);
}
if (!params_param) {
ZEPHIR_INIT_VAR(params);
array_init(params);
} else {
zephir_get_arrval(params, params_param);
}
ZEPHIR_INIT_VAR(placeHolders);
array_init(placeHolders);
ZEPHIR_INIT_VAR(bindPattern);
ZVAL_STRING(bindPattern, "/\\?([0-9]+)|:([a-zA-Z0-9_]+):/", 1);
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
setOrder = 2;
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, setOrder);
ZEPHIR_MAKE_REF(matches);
ZEPHIR_CALL_FUNCTION(&_1, "preg_match_all", NULL, 38, bindPattern, sql, matches, _0);
ZEPHIR_UNREF(matches);
zephir_check_call_status();
if (zephir_is_true(_1)) {
zephir_is_iterable(matches, &_3$$3, &_2$$3, 0, 0, "phalcon/db/adapter/pdo.zep", 483);
for (
; zephir_hash_get_current_data_ex(_3$$3, (void**) &_4$$3, &_2$$3) == SUCCESS
; zephir_hash_move_forward_ex(_3$$3, &_2$$3)
) {
ZEPHIR_GET_HVALUE(placeMatch, _4$$3);
ZEPHIR_OBS_NVAR(value);
zephir_array_fetch_long(&_5$$4, placeMatch, 1, PH_READONLY, "phalcon/db/adapter/pdo.zep", 470 TSRMLS_CC);
if (!(zephir_array_isset_fetch(&value, params, _5$$4, 0 TSRMLS_CC))) {
if (zephir_array_isset_long(placeMatch, 2)) {
ZEPHIR_OBS_NVAR(value);
zephir_array_fetch_long(&_6$$6, placeMatch, 2, PH_READONLY, "phalcon/db/adapter/pdo.zep", 472 TSRMLS_CC);
if (!(zephir_array_isset_fetch(&value, params, _6$$6, 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Matched parameter wasn't found in parameters list", "phalcon/db/adapter/pdo.zep", 473);
return;
}
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Matched parameter wasn't found in parameters list", "phalcon/db/adapter/pdo.zep", 476);
return;
}
}
zephir_array_append(&placeHolders, value, PH_SEPARATE, "phalcon/db/adapter/pdo.zep", 480);
}
ZEPHIR_INIT_VAR(_7$$3);
ZVAL_STRING(_7$$3, "?", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_FUNCTION(&boundSql, "preg_replace", NULL, 39, bindPattern, _7$$3, sql);
zephir_check_temp_parameter(_7$$3);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(boundSql, sql);
}
zephir_create_array(return_value, 2, 0 TSRMLS_CC);
zephir_array_update_string(&return_value, SL("sql"), &boundSql, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&return_value, SL("params"), &placeHolders, PH_COPY | PH_SEPARATE);
RETURN_MM();
}
/**
* Phalcon\Config\Adapter\Ini constructor
*/
PHP_METHOD(Phalcon_Config_Adapter_Ini, __construct) {
HashTable *_4, *_7$$6;
HashPosition _3, _6$$6;
zephir_fcall_cache_entry *_11 = NULL, *_15 = NULL, *_16 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *filePath_param = NULL, *mode = NULL, *iniConfig = NULL, *config = NULL, *section = NULL, *sections = NULL, *directives = NULL, *path = NULL, *lastValue = NULL, **_5, *_0$$4, *_1$$4, *_2$$4, **_8$$6, *_9$$7 = NULL, *_12$$8 = NULL, _13$$8 = zval_used_for_init, *_14$$9 = NULL;
zval *filePath = NULL, *_10$$7 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &filePath_param, &mode);
if (unlikely(Z_TYPE_P(filePath_param) != IS_STRING && Z_TYPE_P(filePath_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'filePath' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(filePath_param) == IS_STRING)) {
zephir_get_strval(filePath, filePath_param);
} else {
ZEPHIR_INIT_VAR(filePath);
ZVAL_EMPTY_STRING(filePath);
}
if (!mode) {
ZEPHIR_CPY_WRT(mode, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(mode);
}
if (Z_TYPE_P(mode) == IS_NULL) {
ZEPHIR_INIT_NVAR(mode);
ZVAL_LONG(mode, 1);
}
ZEPHIR_CALL_FUNCTION(&iniConfig, "parse_ini_file", NULL, 136, filePath, ZEPHIR_GLOBAL(global_true), mode);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(iniConfig)) {
ZEPHIR_INIT_VAR(_0$$4);
object_init_ex(_0$$4, phalcon_config_exception_ce);
ZEPHIR_INIT_VAR(_1$$4);
zephir_basename(_1$$4, filePath TSRMLS_CC);
ZEPHIR_INIT_VAR(_2$$4);
ZEPHIR_CONCAT_SVS(_2$$4, "Configuration file ", _1$$4, " can't be loaded");
ZEPHIR_CALL_METHOD(NULL, _0$$4, "__construct", NULL, 9, _2$$4);
zephir_check_call_status();
zephir_throw_exception_debug(_0$$4, "phalcon/config/adapter/ini.zep", 85 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(config);
array_init(config);
zephir_is_iterable(iniConfig, &_4, &_3, 0, 0, "phalcon/config/adapter/ini.zep", 106);
for (
; zephir_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS
; zephir_hash_move_forward_ex(_4, &_3)
) {
ZEPHIR_GET_HMKEY(section, _4, _3);
ZEPHIR_GET_HVALUE(directives, _5);
if (Z_TYPE_P(directives) == IS_ARRAY) {
ZEPHIR_INIT_NVAR(sections);
array_init(sections);
zephir_is_iterable(directives, &_7$$6, &_6$$6, 0, 0, "phalcon/config/adapter/ini.zep", 98);
for (
; zephir_hash_get_current_data_ex(_7$$6, (void**) &_8$$6, &_6$$6) == SUCCESS
; zephir_hash_move_forward_ex(_7$$6, &_6$$6)
) {
ZEPHIR_GET_HMKEY(path, _7$$6, _6$$6);
ZEPHIR_GET_HVALUE(lastValue, _8$$6);
zephir_get_strval(_10$$7, path);
ZEPHIR_CALL_METHOD(&_9$$7, this_ptr, "_parseinistring", &_11, 0, _10$$7, lastValue);
zephir_check_call_status();
zephir_array_append(§ions, _9$$7, PH_SEPARATE, "phalcon/config/adapter/ini.zep", 96);
}
if (zephir_fast_count_int(sections TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_12$$8);
ZEPHIR_SINIT_NVAR(_13$$8);
ZVAL_STRING(&_13$$8, "array_merge_recursive", 0);
ZEPHIR_CALL_USER_FUNC_ARRAY(_12$$8, &_13$$8, sections);
zephir_check_call_status();
zephir_array_update_zval(&config, section, &_12$$8, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CALL_METHOD(&_14$$9, this_ptr, "_cast", &_15, 0, directives);
zephir_check_call_status();
zephir_array_update_zval(&config, section, &_14$$9, PH_COPY | PH_SEPARATE);
}
}
ZEPHIR_CALL_PARENT(NULL, phalcon_config_adapter_ini_ce, this_ptr, "__construct", &_16, 19, config);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* This method is automatically called in \Phalcon\Db\Adapter\Pdo constructor.
*
* Call it when you need to restore a database connection.
*
*<code>
* use Phalcon\Db\Adapter\Pdo\Mysql;
*
* // Make a connection
* $connection = new Mysql([
* 'host' => 'localhost',
* 'username' => 'sigma',
* 'password' => 'secret',
* 'dbname' => 'blog',
* 'port' => 3306,
* ]);
*
* // Reconnect
* $connection->connect();
* </code>
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, connect) {
HashTable *_3$$13;
HashPosition _2$$13;
int ZEPHIR_LAST_CALL_STATUS;
zval *descriptor_param = NULL, *username = NULL, *password = NULL, *dsnParts = NULL, *dsnAttributes = NULL, *persistent = NULL, *options = NULL, *key = NULL, *value = NULL, *_6, *_7, *_8, *_9, *_0$$3, **_4$$13, *_5$$14 = NULL;
zval *descriptor = NULL, *_1$$3 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &descriptor_param);
if (!descriptor_param) {
ZEPHIR_INIT_VAR(descriptor);
array_init(descriptor);
} else {
zephir_get_arrval(descriptor, descriptor_param);
}
if (ZEPHIR_IS_EMPTY(descriptor)) {
ZEPHIR_OBS_VAR(_0$$3);
zephir_read_property_this(&_0$$3, this_ptr, SL("_descriptor"), PH_NOISY_CC);
zephir_get_arrval(_1$$3, _0$$3);
ZEPHIR_CPY_WRT(descriptor, _1$$3);
}
ZEPHIR_OBS_VAR(username);
if (zephir_array_isset_string_fetch(&username, descriptor, SS("username"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&descriptor, SS("username"), PH_SEPARATE);
} else {
ZEPHIR_INIT_NVAR(username);
ZVAL_NULL(username);
}
ZEPHIR_OBS_VAR(password);
if (zephir_array_isset_string_fetch(&password, descriptor, SS("password"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&descriptor, SS("password"), PH_SEPARATE);
} else {
ZEPHIR_INIT_NVAR(password);
ZVAL_NULL(password);
}
ZEPHIR_OBS_VAR(options);
if (zephir_array_isset_string_fetch(&options, descriptor, SS("options"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&descriptor, SS("options"), PH_SEPARATE);
} else {
ZEPHIR_INIT_NVAR(options);
array_init(options);
}
ZEPHIR_OBS_VAR(persistent);
if (zephir_array_isset_string_fetch(&persistent, descriptor, SS("persistent"), 0 TSRMLS_CC)) {
if (zephir_is_true(persistent)) {
zephir_array_update_long(&options, 12, &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
}
zephir_array_unset_string(&descriptor, SS("persistent"), PH_SEPARATE);
}
if (zephir_array_isset_string(descriptor, SS("dialectClass"))) {
zephir_array_unset_string(&descriptor, SS("dialectClass"), PH_SEPARATE);
}
ZEPHIR_OBS_VAR(dsnAttributes);
if (!(zephir_array_isset_string_fetch(&dsnAttributes, descriptor, SS("dsn"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(dsnParts);
array_init(dsnParts);
zephir_is_iterable(descriptor, &_3$$13, &_2$$13, 0, 0, "phalcon/db/adapter/pdo.zep", 154);
for (
; zephir_hash_get_current_data_ex(_3$$13, (void**) &_4$$13, &_2$$13) == SUCCESS
; zephir_hash_move_forward_ex(_3$$13, &_2$$13)
) {
ZEPHIR_GET_HMKEY(key, _3$$13, _2$$13);
ZEPHIR_GET_HVALUE(value, _4$$13);
ZEPHIR_INIT_LNVAR(_5$$14);
ZEPHIR_CONCAT_VSV(_5$$14, key, "=", value);
zephir_array_append(&dsnParts, _5$$14, PH_SEPARATE, "phalcon/db/adapter/pdo.zep", 152);
}
ZEPHIR_INIT_NVAR(dsnAttributes);
zephir_fast_join_str(dsnAttributes, SL(";"), dsnParts TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_6);
ZVAL_LONG(_6, 2);
zephir_array_update_long(&options, 3, &_6, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
ZEPHIR_INIT_VAR(_7);
object_init_ex(_7, php_pdo_get_dbh_ce());
_8 = zephir_fetch_nproperty_this(this_ptr, SL("_type"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_9);
ZEPHIR_CONCAT_VSV(_9, _8, ":", dsnAttributes);
ZEPHIR_CALL_METHOD(NULL, _7, "__construct", NULL, 0, _9, username, password, options);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_pdo"), _7 TSRMLS_CC);
RETURN_MM_BOOL(1);
}
/**
* We have to cast values manually because parse_ini_file() has a poor implementation.
*
* @param mixed ini The array casted by `parse_ini_file`
*/
PHP_METHOD(Phalcon_Config_Adapter_Ini, _cast) {
zend_bool _5$$5, _6$$5, _8$$5, _9$$5;
HashTable *_1$$3;
HashPosition _0$$3;
zephir_fcall_cache_entry *_4 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *ini, *key = NULL, *val = NULL, **_2$$3, *_3$$4 = NULL, *_7$$5, *_10$$5, *_11$$9, *_12$$9, _13$$9;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &ini);
ZEPHIR_SEPARATE_PARAM(ini);
if (Z_TYPE_P(ini) == IS_ARRAY) {
zephir_is_iterable(ini, &_1$$3, &_0$$3, 1, 0, "phalcon/config/adapter/ini.zep", 152);
for (
; zephir_hash_get_current_data_ex(_1$$3, (void**) &_2$$3, &_0$$3) == SUCCESS
; zephir_hash_move_forward_ex(_1$$3, &_0$$3)
) {
ZEPHIR_GET_HMKEY(key, _1$$3, _0$$3);
ZEPHIR_GET_HVALUE(val, _2$$3);
ZEPHIR_CALL_METHOD(&_3$$4, this_ptr, "_cast", &_4, 138, val);
zephir_check_call_status();
zephir_array_update_zval(&ini, key, &_3$$4, PH_COPY | PH_SEPARATE);
}
zend_hash_destroy(_1$$3);
FREE_HASHTABLE(_1$$3);
}
if (Z_TYPE_P(ini) == IS_STRING) {
_5$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "true");
if (!(_5$$5)) {
_5$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "yes");
}
_6$$5 = _5$$5;
if (!(_6$$5)) {
ZEPHIR_INIT_VAR(_7$$5);
zephir_fast_strtolower(_7$$5, ini);
_6$$5 = ZEPHIR_IS_STRING_IDENTICAL(_7$$5, "on");
}
if (_6$$5) {
RETURN_MM_BOOL(1);
}
_8$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "false");
if (!(_8$$5)) {
_8$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "no");
}
_9$$5 = _8$$5;
if (!(_9$$5)) {
ZEPHIR_INIT_VAR(_10$$5);
zephir_fast_strtolower(_10$$5, ini);
_9$$5 = ZEPHIR_IS_STRING_IDENTICAL(_10$$5, "off");
}
if (_9$$5) {
RETURN_MM_BOOL(0);
}
if (ZEPHIR_IS_STRING_IDENTICAL(ini, "null")) {
RETURN_MM_NULL();
}
if (zephir_is_numeric(ini)) {
ZEPHIR_INIT_VAR(_11$$9);
ZEPHIR_INIT_VAR(_12$$9);
ZEPHIR_SINIT_VAR(_13$$9);
ZVAL_STRING(&_13$$9, "/[.]+/", 0);
zephir_preg_match(_12$$9, &_13$$9, ini, _11$$9, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_12$$9)) {
RETURN_MM_DOUBLE(zephir_get_doubleval(ini));
} else {
RETURN_MM_LONG(zephir_get_intval(ini));
}
}
}
RETVAL_ZVAL(ini, 1, 0);
RETURN_MM();
}
/**
* Builds a SELECT statement
*
* @param array definition
* @return string
*/
PHP_METHOD(Pdm_Db_AbstractDialect, select) {
zephir_fcall_cache_entry *_4 = NULL, *_9 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_2, *_6, *_11, *_16, *_22, *_26;
HashPosition _1, _5, _10, _15, _21, _25;
zval *definition, *tables, *columns = NULL, *escapeChar = NULL, *columnItem = NULL, *column = NULL, *selectedColumns, *columnSql = NULL, *columnDomainSql = NULL, *columnAlias = NULL, *selectedTables, *sqlJoin = NULL, *joinExpressions = NULL, *joinCondition = NULL, *joinConditionsArray = NULL, *tablesSql = NULL, *columnDomain = NULL, *columnAliasSql = NULL, *columnsSql = NULL, *table = NULL, *sql, *joins, *join = NULL, *sqlTable = NULL, *whereConditions, *groupFields, *groupField = NULL, *groupItems, *havingConditions, *orderFields, *orderItem = NULL, *orderItems, *orderSqlItem = NULL, *sqlOrderType = NULL, *orderSqlItemType = NULL, *limitValue, *number, *offset, *_0, **_3, **_7, *_8 = NULL, **_12, *_13, *_14, **_17, *_18 = NULL, *_19 = NULL, *_20 = NULL, **_23, *_24 = NULL, **_27, *_28, *_29;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &definition);
if (Z_TYPE_P(definition) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "Invalid SELECT definition", "pdm/db/abstractdialect.zep", 375);
return;
}
ZEPHIR_OBS_VAR(tables);
if (!(zephir_array_isset_string_fetch(&tables, definition, SS("tables"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "The index 'tables' is required in the definition array", "pdm/db/abstractdialect.zep", 379);
return;
}
ZEPHIR_OBS_VAR(columns);
if (!(zephir_array_isset_string_fetch(&columns, definition, SS("columns"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "The index 'columns' is required in the definition array", "pdm/db/abstractdialect.zep", 383);
return;
}
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
_0 = zephir_fetch_nproperty_this(this_ptr, SL("escapeChar"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(escapeChar, _0);
} else {
ZEPHIR_INIT_VAR(escapeChar);
ZVAL_NULL(escapeChar);
}
ZEPHIR_OBS_NVAR(columns);
zephir_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(columns) == IS_ARRAY) {
ZEPHIR_INIT_VAR(selectedColumns);
array_init(selectedColumns);
zephir_is_iterable(columns, &_2, &_1, 0, 0);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(column, _3);
ZEPHIR_OBS_NVAR(columnItem);
zephir_array_fetch_long(&columnItem, column, 0, PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(columnItem) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&columnSql, this_ptr, "getsqlexpression", &_4, columnItem, escapeChar);
zephir_check_call_status();
} else {
if (ZEPHIR_IS_STRING(columnItem, "*")) {
ZEPHIR_CPY_WRT(columnSql, columnItem);
} else {
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_INIT_NVAR(columnSql);
ZEPHIR_CONCAT_VVV(columnSql, escapeChar, columnItem, escapeChar);
} else {
ZEPHIR_CPY_WRT(columnSql, columnItem);
}
}
}
ZEPHIR_OBS_NVAR(columnDomain);
if (zephir_array_isset_long_fetch(&columnDomain, column, 1, 0 TSRMLS_CC)) {
if (zephir_is_true(columnDomain)) {
ZEPHIR_INIT_NVAR(columnDomainSql);
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_CONCAT_VVVSV(columnDomainSql, escapeChar, columnDomain, escapeChar, ".", columnSql);
} else {
ZEPHIR_CONCAT_VSV(columnDomainSql, columnDomain, ".", columnSql);
}
} else {
ZEPHIR_CPY_WRT(columnDomainSql, columnSql);
}
} else {
ZEPHIR_CPY_WRT(columnDomainSql, columnSql);
}
ZEPHIR_OBS_NVAR(columnAlias);
if (zephir_array_isset_long_fetch(&columnAlias, column, 2, 0 TSRMLS_CC)) {
if (zephir_is_true(columnAlias)) {
ZEPHIR_INIT_NVAR(columnAliasSql);
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_CONCAT_VSVVV(columnAliasSql, columnDomainSql, " AS ", escapeChar, columnAlias, escapeChar);
} else {
ZEPHIR_CONCAT_VSV(columnAliasSql, columnDomainSql, " AS ", columnAlias);
}
} else {
ZEPHIR_CPY_WRT(columnAliasSql, columnDomainSql);
}
} else {
ZEPHIR_CPY_WRT(columnAliasSql, columnDomainSql);
}
zephir_array_append(&selectedColumns, columnAliasSql, PH_SEPARATE);
}
ZEPHIR_INIT_VAR(columnsSql);
zephir_fast_join_str(columnsSql, SL(", "), selectedColumns TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(columnsSql, columns);
}
if (Z_TYPE_P(tables) == IS_ARRAY) {
ZEPHIR_INIT_VAR(selectedTables);
array_init(selectedTables);
zephir_is_iterable(tables, &_6, &_5, 0, 0);
for (
; zephir_hash_get_current_data_ex(_6, (void**) &_7, &_5) == SUCCESS
; zephir_hash_move_forward_ex(_6, &_5)
) {
ZEPHIR_GET_HVALUE(table, _7);
ZEPHIR_CALL_METHOD(&_8, this_ptr, "getsqltable", &_9, table, escapeChar);
zephir_check_call_status();
zephir_array_append(&selectedTables, _8, PH_SEPARATE);
}
ZEPHIR_INIT_VAR(tablesSql);
zephir_fast_join_str(tablesSql, SL(", "), selectedTables TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(tablesSql, tables);
}
ZEPHIR_INIT_VAR(sql);
ZEPHIR_CONCAT_SVSV(sql, "SELECT ", columnsSql, " FROM ", tablesSql);
ZEPHIR_OBS_VAR(joins);
if (zephir_array_isset_string_fetch(&joins, definition, SS("joins"), 0 TSRMLS_CC)) {
zephir_is_iterable(joins, &_11, &_10, 0, 0);
for (
; zephir_hash_get_current_data_ex(_11, (void**) &_12, &_10) == SUCCESS
; zephir_hash_move_forward_ex(_11, &_10)
) {
ZEPHIR_GET_HVALUE(join, _12);
zephir_array_fetch_string(&_13, join, SL("source"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&sqlTable, this_ptr, "getsqltable", &_9, _13, escapeChar);
zephir_check_call_status();
zephir_array_append(&selectedTables, sqlTable, PH_SEPARATE);
zephir_array_fetch_string(&_14, join, SL("type"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_INIT_NVAR(sqlJoin);
ZEPHIR_CONCAT_SVSV(sqlJoin, " ", _14, " JOIN ", sqlTable);
ZEPHIR_OBS_NVAR(joinConditionsArray);
if (zephir_array_isset_string_fetch(&joinConditionsArray, join, SS("conditions"), 0 TSRMLS_CC)) {
if (zephir_fast_count_int(joinConditionsArray TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(joinExpressions);
array_init(joinExpressions);
zephir_is_iterable(joinConditionsArray, &_16, &_15, 0, 0);
for (
; zephir_hash_get_current_data_ex(_16, (void**) &_17, &_15) == SUCCESS
; zephir_hash_move_forward_ex(_16, &_15)
) {
ZEPHIR_GET_HVALUE(joinCondition, _17);
ZEPHIR_CALL_METHOD(&_8, this_ptr, "getsqlexpression", &_4, joinCondition, escapeChar);
zephir_check_call_status();
zephir_array_append(&joinExpressions, _8, PH_SEPARATE);
}
ZEPHIR_INIT_NVAR(_18);
zephir_fast_join_str(_18, SL(" AND "), joinExpressions TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_19);
ZEPHIR_CONCAT_SVS(_19, " ON ", _18, " ");
zephir_concat_self(&sqlJoin, _19 TSRMLS_CC);
}
}
zephir_concat_self(&sql, sqlJoin TSRMLS_CC);
}
}
ZEPHIR_OBS_VAR(whereConditions);
if (zephir_array_isset_string_fetch(&whereConditions, definition, SS("where"), 0 TSRMLS_CC)) {
if (Z_TYPE_P(whereConditions) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&_8, this_ptr, "getsqlexpression", &_4, whereConditions, escapeChar);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_19);
ZEPHIR_CONCAT_SV(_19, " WHERE ", _8);
zephir_concat_self(&sql, _19 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_20);
ZEPHIR_CONCAT_SV(_20, " WHERE ", whereConditions);
zephir_concat_self(&sql, _20 TSRMLS_CC);
}
}
ZEPHIR_OBS_VAR(groupFields);
if (zephir_array_isset_string_fetch(&groupFields, definition, SS("group"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(groupItems);
array_init(groupItems);
zephir_is_iterable(groupFields, &_22, &_21, 0, 0);
for (
; zephir_hash_get_current_data_ex(_22, (void**) &_23, &_21) == SUCCESS
; zephir_hash_move_forward_ex(_22, &_21)
) {
ZEPHIR_GET_HVALUE(groupField, _23);
ZEPHIR_CALL_METHOD(&_8, this_ptr, "getsqlexpression", &_4, groupField, escapeChar);
zephir_check_call_status();
zephir_array_append(&groupItems, _8, PH_SEPARATE);
}
ZEPHIR_INIT_NVAR(_18);
zephir_fast_join_str(_18, SL(", "), groupItems TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_20);
ZEPHIR_CONCAT_SV(_20, " GROUP BY ", _18);
zephir_concat_self(&sql, _20 TSRMLS_CC);
ZEPHIR_OBS_VAR(havingConditions);
if (zephir_array_isset_string_fetch(&havingConditions, definition, SS("having"), 0 TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(&_8, this_ptr, "getsqlexpression", &_4, havingConditions, escapeChar);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_24);
ZEPHIR_CONCAT_SV(_24, " HAVING ", _8);
zephir_concat_self(&sql, _24 TSRMLS_CC);
}
}
ZEPHIR_OBS_VAR(orderFields);
if (zephir_array_isset_string_fetch(&orderFields, definition, SS("order"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(orderItems);
array_init(orderItems);
zephir_is_iterable(orderFields, &_26, &_25, 0, 0);
for (
; zephir_hash_get_current_data_ex(_26, (void**) &_27, &_25) == SUCCESS
; zephir_hash_move_forward_ex(_26, &_25)
) {
ZEPHIR_GET_HVALUE(orderItem, _27);
zephir_array_fetch_long(&_13, orderItem, 0, PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&orderSqlItem, this_ptr, "getsqlexpression", &_4, _13, escapeChar);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(sqlOrderType);
if (zephir_array_isset_long_fetch(&sqlOrderType, orderItem, 1, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(orderSqlItemType);
ZEPHIR_CONCAT_VSV(orderSqlItemType, orderSqlItem, " ", sqlOrderType);
} else {
ZEPHIR_CPY_WRT(orderSqlItemType, orderSqlItem);
}
zephir_array_append(&orderItems, orderSqlItemType, PH_SEPARATE);
}
ZEPHIR_INIT_VAR(_28);
zephir_fast_join_str(_28, SL(", "), orderItems TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_20);
ZEPHIR_CONCAT_SV(_20, " ORDER BY ", _28);
zephir_concat_self(&sql, _20 TSRMLS_CC);
}
if (zephir_array_isset_string_fetch(&limitValue, definition, SS("limit"), 1 TSRMLS_CC)) {
if (Z_TYPE_P(limitValue) == IS_ARRAY) {
zephir_array_fetch_string(&_13, limitValue, SL("number"), PH_NOISY | PH_READONLY TSRMLS_CC);
zephir_array_fetch_string(&number, _13, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC);
if (zephir_array_isset_string_fetch(&offset, limitValue, SS("offset"), 1 TSRMLS_CC)) {
zephir_array_fetch_string(&_14, offset, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_24);
ZEPHIR_CONCAT_SVSV(_24, " LIMIT ", number, " OFFSET ", _14);
zephir_concat_self(&sql, _24 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_29);
ZEPHIR_CONCAT_SV(_29, " LIMIT ", number);
zephir_concat_self(&sql, _29 TSRMLS_CC);
}
} else {
ZEPHIR_INIT_LNVAR(_20);
ZEPHIR_CONCAT_SV(_20, " LIMIT ", limitValue);
zephir_concat_self(&sql, _20 TSRMLS_CC);
}
}
RETURN_CCTOR(sql);
}
/**
* Transform an intermediate representation for a schema/table into a database system valid expression
*
* @param array table
* @param string escapeChar
* @return string
*/
PHP_METHOD(Pdm_Db_AbstractDialect, getSqlTable) {
zval *escapeChar = NULL, *_1 = NULL;
zval *table, *escapeChar_param = NULL, *sqlTable = NULL, *sqlSchema = NULL, *aliasName, *sqlTableAlias = NULL, *schemaName, *tableName, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table, &escapeChar_param);
if (!escapeChar_param) {
ZEPHIR_INIT_VAR(escapeChar);
ZVAL_EMPTY_STRING(escapeChar);
} else {
zephir_get_strval(escapeChar, escapeChar_param);
}
if (ZEPHIR_IS_STRING_IDENTICAL(escapeChar, "")) {
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("escapeChar"), PH_NOISY_CC);
zephir_get_strval(_1, _0);
ZEPHIR_CPY_WRT(escapeChar, _1);
}
if (Z_TYPE_P(table) == IS_ARRAY) {
ZEPHIR_OBS_VAR(tableName);
zephir_array_fetch_long(&tableName, table, 0, PH_NOISY TSRMLS_CC);
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_INIT_VAR(sqlTable);
ZEPHIR_CONCAT_VVV(sqlTable, escapeChar, tableName, escapeChar);
} else {
ZEPHIR_CPY_WRT(sqlTable, tableName);
}
ZEPHIR_OBS_VAR(schemaName);
zephir_array_fetch_long(&schemaName, table, 1, PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(schemaName) != IS_ARRAY) {
ZEPHIR_INIT_VAR(sqlSchema);
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_CONCAT_VVVSV(sqlSchema, escapeChar, schemaName, escapeChar, ".", sqlTable);
} else {
ZEPHIR_CONCAT_VSV(sqlSchema, schemaName, ".", sqlTable);
}
} else {
ZEPHIR_CPY_WRT(sqlSchema, sqlTable);
}
ZEPHIR_OBS_VAR(aliasName);
if (zephir_array_isset_long_fetch(&aliasName, table, 2, 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(sqlTableAlias);
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_CONCAT_VSVVV(sqlTableAlias, sqlSchema, " AS ", escapeChar, aliasName, escapeChar);
} else {
ZEPHIR_CONCAT_VSV(sqlTableAlias, sqlSchema, " AS ", aliasName);
}
} else {
ZEPHIR_CPY_WRT(sqlTableAlias, sqlSchema);
}
RETURN_CCTOR(sqlTableAlias);
}
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_CONCAT_VVV(return_value, escapeChar, table, escapeChar);
RETURN_MM();
}
RETURN_CCTOR(table);
}
/**
* Registers a set of PSR-0 directories for a given prefix, either
* appending or prepending to the ones previously set for this prefix.
*
* @param string $prefix The prefix
* @param array|string $paths The PSR-0 root directories
* @param bool $prepend Whether to prepend the directories
*/
PHP_METHOD(Xpl_ClassLoader, add) {
zend_bool prepend;
zval *prefix, *paths = NULL, *prepend_param = NULL, *firstChar = NULL, *prefixPaths = NULL, _4, _5, *_6, *_7, *_0$$5, *_1$$5, *_2$$6, *_3$$6, *_8$$9, *_9$$10;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &prefix, &paths, &prepend_param);
ZEPHIR_SEPARATE_PARAM(paths);
if (!prepend_param) {
prepend = 0;
} else {
prepend = zephir_get_boolval(prepend_param);
}
if (Z_TYPE_P(paths) == IS_STRING) {
ZEPHIR_INIT_NVAR(paths);
zephir_create_array(paths, 1, 0 TSRMLS_CC);
zephir_array_fast_append(paths, paths);
}
if (Z_TYPE_P(prefix) != IS_STRING) {
if (prepend) {
ZEPHIR_INIT_VAR(_0$$5);
_1$$5 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr0"), PH_NOISY_CC);
zephir_fast_array_merge(_0$$5, &(paths), &(_1$$5) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("fallbackDirsPsr0"), _0$$5 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_2$$6);
_3$$6 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr0"), PH_NOISY_CC);
zephir_fast_array_merge(_2$$6, &(_3$$6), &(paths) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("fallbackDirsPsr0"), _2$$6 TSRMLS_CC);
}
RETURN_MM_NULL();
}
ZEPHIR_SINIT_VAR(_4);
ZVAL_LONG(&_4, 0);
ZEPHIR_SINIT_VAR(_5);
ZVAL_LONG(&_5, 1);
ZEPHIR_INIT_VAR(firstChar);
zephir_substr(firstChar, prefix, 0 , 1 , 0);
ZEPHIR_OBS_VAR(prefixPaths);
_6 = zephir_fetch_nproperty_this(this_ptr, SL("prefixesPsr0"), PH_NOISY_CC);
zephir_array_fetch(&_7, _6, firstChar, PH_READONLY, "xpl/classloader.zep", 262 TSRMLS_CC);
if (!(zephir_array_isset_fetch(&prefixPaths, _7, prefix, 0 TSRMLS_CC))) {
ZEPHIR_CPY_WRT(prefixPaths, paths);
} else {
if (prepend) {
ZEPHIR_INIT_VAR(_8$$9);
zephir_fast_array_merge(_8$$9, &(paths), &(prefixPaths) TSRMLS_CC);
ZEPHIR_CPY_WRT(prefixPaths, _8$$9);
} else {
ZEPHIR_INIT_VAR(_9$$10);
zephir_fast_array_merge(_9$$10, &(prefixPaths), &(paths) TSRMLS_CC);
ZEPHIR_CPY_WRT(prefixPaths, _9$$10);
}
}
zephir_update_property_array_multi(this_ptr, SL("prefixesPsr0"), &prefixPaths TSRMLS_CC, SL("zz"), 2, firstChar, prefix);
ZEPHIR_MM_RESTORE();
}
/**
* Starts a transaction in the connection
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, begin) {
int ZEPHIR_LAST_CALL_STATUS, transactionLevel = 0;
zval *nesting_param = NULL, *pdo = NULL, *eventsManager = NULL, *savepointName = NULL, *_0, *_1$$4, *_2$$5, *_5$$6 = NULL, *_6$$7, *_7$$8;
zend_bool nesting, _3$$6, _4$$6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &nesting_param);
if (!nesting_param) {
nesting = 1;
} else {
nesting = zephir_get_boolval(nesting_param);
}
ZEPHIR_OBS_VAR(pdo);
zephir_read_property_this(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
if (Z_TYPE_P(pdo) != IS_OBJECT) {
RETURN_MM_BOOL(0);
}
RETURN_ON_FAILURE(zephir_property_incr(this_ptr, SL("_transactionLevel") TSRMLS_CC));
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("_transactionLevel"), PH_NOISY_CC);
transactionLevel = zephir_get_intval(_0);
if (transactionLevel == 1) {
_1$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(eventsManager, _1$$4);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_2$$5);
ZVAL_STRING(_2$$5, "db:beginTransaction", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _2$$5, this_ptr);
zephir_check_temp_parameter(_2$$5);
zephir_check_call_status();
}
ZEPHIR_RETURN_CALL_METHOD(pdo, "begintransaction", NULL, 0);
zephir_check_call_status();
RETURN_MM();
} else {
_3$$6 = ((transactionLevel) ? 1 : 0);
if (_3$$6) {
_3$$6 = nesting;
}
_4$$6 = _3$$6;
if (_4$$6) {
ZEPHIR_CALL_METHOD(&_5$$6, this_ptr, "isnestedtransactionswithsavepoints", NULL, 0);
zephir_check_call_status();
_4$$6 = zephir_is_true(_5$$6);
}
if (_4$$6) {
_6$$7 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(eventsManager, _6$$7);
ZEPHIR_CALL_METHOD(&savepointName, this_ptr, "getnestedtransactionsavepointname", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_7$$8);
ZVAL_STRING(_7$$8, "db:createSavepoint", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _7$$8, this_ptr, savepointName);
zephir_check_temp_parameter(_7$$8);
zephir_check_call_status();
}
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "createsavepoint", NULL, 0, savepointName);
zephir_check_call_status();
RETURN_MM();
}
}
RETURN_MM_BOOL(0);
}
/**
* Registers a set of PSR-4 directories for a given namespace, either
* appending or prepending to the ones previously set for this namespace.
*
* @param string $prefix The prefix/namespace, with trailing "\\"
* @param array|string $paths The PSR-0 base directories
* @param bool $prepend Whether to prepend the directories
* @throws \InvalidArgumentException
*/
PHP_METHOD(Xpl_ClassLoader, addPsr4) {
zend_bool prepend;
zval *prefix, *paths = NULL, *prepend_param = NULL, *firstChar = NULL, *prefixDirs = NULL, *_4, *_0$$5, *_1$$5, *_2$$6, *_3$$6, _5$$7, _6$$7, *_7$$7, *_8$$10, *_9$$11;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &prefix, &paths, &prepend_param);
ZEPHIR_SEPARATE_PARAM(paths);
if (!prepend_param) {
prepend = 0;
} else {
prepend = zephir_get_boolval(prepend_param);
}
if (Z_TYPE_P(paths) == IS_STRING) {
ZEPHIR_INIT_NVAR(paths);
zephir_create_array(paths, 1, 0 TSRMLS_CC);
zephir_array_fast_append(paths, paths);
}
if (Z_TYPE_P(prefix) != IS_STRING) {
if (prepend) {
ZEPHIR_INIT_VAR(_0$$5);
_1$$5 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr4"), PH_NOISY_CC);
zephir_fast_array_merge(_0$$5, &(paths), &(_1$$5) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("fallbackDirsPsr4"), _0$$5 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_2$$6);
_3$$6 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr4"), PH_NOISY_CC);
zephir_fast_array_merge(_2$$6, &(_3$$6), &(paths) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("fallbackDirsPsr4"), _2$$6 TSRMLS_CC);
}
RETURN_MM_NULL();
}
ZEPHIR_OBS_VAR(prefixDirs);
_4 = zephir_fetch_nproperty_this(this_ptr, SL("prefixDirsPsr4"), PH_NOISY_CC);
if (!(zephir_array_isset_fetch(&prefixDirs, _4, prefix, 0 TSRMLS_CC))) {
ZEPHIR_SINIT_VAR(_5$$7);
ZVAL_LONG(&_5$$7, 0);
ZEPHIR_SINIT_VAR(_6$$7);
ZVAL_LONG(&_6$$7, 1);
ZEPHIR_INIT_VAR(firstChar);
zephir_substr(firstChar, prefix, 0 , 1 , 0);
if (!(zephir_end_with_str(prefix, SL("\\")))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "A non-empty PSR-4 prefix must end with a namespace separator.", "xpl/classloader.zep", 310);
return;
}
ZEPHIR_INIT_VAR(_7$$7);
ZVAL_LONG(_7$$7, zephir_fast_strlen_ev(prefix));
zephir_update_property_array_multi(this_ptr, SL("prefixLengthsPsr4"), &_7$$7 TSRMLS_CC, SL("zz"), 2, firstChar, prefix);
zephir_update_property_array(this_ptr, SL("prefixDirsPsr4"), prefix, paths TSRMLS_CC);
} else {
if (prepend) {
ZEPHIR_INIT_VAR(_8$$10);
zephir_fast_array_merge(_8$$10, &(paths), &(prefixDirs) TSRMLS_CC);
zephir_update_property_array(this_ptr, SL("prefixDirsPsr4"), prefix, _8$$10 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_9$$11);
zephir_fast_array_merge(_9$$11, &(prefixDirs), &(paths) TSRMLS_CC);
zephir_update_property_array(this_ptr, SL("prefixDirsPsr4"), prefix, _9$$11 TSRMLS_CC);
}
}
ZEPHIR_MM_RESTORE();
}
/**
* Commits the active transaction in the connection
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, commit) {
int ZEPHIR_LAST_CALL_STATUS, transactionLevel = 0;
zval *nesting_param = NULL, *pdo = NULL, *eventsManager = NULL, *savepointName = NULL, *_0, *_1$$5, *_2$$6, *_5$$7 = NULL, *_6$$8, *_7$$9;
zend_bool nesting, _3$$7, _4$$7;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &nesting_param);
if (!nesting_param) {
nesting = 1;
} else {
nesting = zephir_get_boolval(nesting_param);
}
ZEPHIR_OBS_VAR(pdo);
zephir_read_property_this(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
if (Z_TYPE_P(pdo) != IS_OBJECT) {
RETURN_MM_BOOL(0);
}
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("_transactionLevel"), PH_NOISY_CC);
transactionLevel = zephir_get_intval(_0);
if (!(transactionLevel)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "There is no active transaction", "phalcon/db/adapter/pdo.zep", 670);
return;
}
if (transactionLevel == 1) {
_1$$5 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(eventsManager, _1$$5);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_2$$6);
ZVAL_STRING(_2$$6, "db:commitTransaction", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _2$$6, this_ptr);
zephir_check_temp_parameter(_2$$6);
zephir_check_call_status();
}
RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC));
ZEPHIR_RETURN_CALL_METHOD(pdo, "commit", NULL, 0);
zephir_check_call_status();
RETURN_MM();
} else {
_3$$7 = ((transactionLevel) ? 1 : 0);
if (_3$$7) {
_3$$7 = nesting;
}
_4$$7 = _3$$7;
if (_4$$7) {
ZEPHIR_CALL_METHOD(&_5$$7, this_ptr, "isnestedtransactionswithsavepoints", NULL, 0);
zephir_check_call_status();
_4$$7 = zephir_is_true(_5$$7);
}
if (_4$$7) {
_6$$8 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(eventsManager, _6$$8);
ZEPHIR_CALL_METHOD(&savepointName, this_ptr, "getnestedtransactionsavepointname", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_7$$9);
ZVAL_STRING(_7$$9, "db:releaseSavepoint", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _7$$9, this_ptr, savepointName);
zephir_check_temp_parameter(_7$$9);
zephir_check_call_status();
}
RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC));
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "releasesavepoint", NULL, 0, savepointName);
zephir_check_call_status();
RETURN_MM();
}
}
if (transactionLevel > 0) {
RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC));
}
RETURN_MM_BOOL(0);
}
PHP_METHOD(Xpl_ClassLoader, findFileWithExtension) {
HashTable *_16, *_39, *_6$$3, *_11$$5, *_32$$12, *_35$$14;
HashPosition _15, _38, _5$$3, _10$$5, _31$$12, _34$$14;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_3 = NULL;
zval *className_param = NULL, *ext_param = NULL, *logicalPathPsr4 = NULL, *firstChar = NULL, *prefixLengthsPsr4 = NULL, *prefix = NULL, *length = NULL, *dir = NULL, *file = NULL, *prefixesPsr0 = NULL, *logicalPathPsr0 = NULL, *nsPos = NULL, *dirs = NULL, _0 = zval_used_for_init, _1 = zval_used_for_init, *_2 = NULL, *_4, *_14, **_17, _18, *_30, *_37, **_40, *_41, **_7$$3, *_8$$5, *_9$$5, **_12$$5, *_13$$6 = NULL, _19$$10, _20$$10, *_21$$10, _22$$10, *_23$$10, _24$$10, _25$$10, *_26$$10 = NULL, _27$$11, _28$$11, *_29$$11 = NULL, **_33$$12, **_36$$14;
zval *className = NULL, *ext = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &className_param, &ext_param);
if (unlikely(Z_TYPE_P(className_param) != IS_STRING && Z_TYPE_P(className_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'className' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(className_param) == IS_STRING)) {
zephir_get_strval(className, className_param);
} else {
ZEPHIR_INIT_VAR(className);
ZVAL_EMPTY_STRING(className);
}
zephir_get_strval(ext, ext_param);
ZEPHIR_SINIT_VAR(_0);
ZVAL_STRING(&_0, "\\", 0);
ZEPHIR_SINIT_VAR(_1);
ZVAL_STRING(&_1, "/", 0);
ZEPHIR_CALL_FUNCTION(&_2, "strtr", &_3, 56, className, &_0, &_1);
zephir_check_call_status();
ZEPHIR_INIT_VAR(logicalPathPsr4);
ZEPHIR_CONCAT_VV(logicalPathPsr4, _2, ext);
ZEPHIR_SINIT_NVAR(_0);
ZVAL_LONG(&_0, 0);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 1);
ZEPHIR_INIT_VAR(firstChar);
zephir_substr(firstChar, className, 0 , 1 , 0);
ZEPHIR_OBS_VAR(prefixLengthsPsr4);
_4 = zephir_fetch_nproperty_this(this_ptr, SL("prefixLengthsPsr4"), PH_NOISY_CC);
if (zephir_array_isset_fetch(&prefixLengthsPsr4, _4, firstChar, 0 TSRMLS_CC)) {
zephir_is_iterable(prefixLengthsPsr4, &_6$$3, &_5$$3, 0, 0, "xpl/classloader.zep", 505);
for (
; zephir_hash_get_current_data_ex(_6$$3, (void**) &_7$$3, &_5$$3) == SUCCESS
; zephir_hash_move_forward_ex(_6$$3, &_5$$3)
) {
ZEPHIR_GET_HMKEY(prefix, _6$$3, _5$$3);
ZEPHIR_GET_HVALUE(length, _7$$3);
if (zephir_start_with(className, prefix, ZEPHIR_GLOBAL(global_false))) {
_8$$5 = zephir_fetch_nproperty_this(this_ptr, SL("prefixDirsPsr4"), PH_NOISY_CC);
zephir_array_fetch(&_9$$5, _8$$5, prefix, PH_NOISY | PH_READONLY, "xpl/classloader.zep", 495 TSRMLS_CC);
zephir_is_iterable(_9$$5, &_11$$5, &_10$$5, 0, 0, "xpl/classloader.zep", 503);
for (
; zephir_hash_get_current_data_ex(_11$$5, (void**) &_12$$5, &_10$$5) == SUCCESS
; zephir_hash_move_forward_ex(_11$$5, &_10$$5)
) {
ZEPHIR_GET_HVALUE(dir, _12$$5);
ZEPHIR_INIT_NVAR(_13$$6);
zephir_substr(_13$$6, logicalPathPsr4, zephir_get_intval(length), 0, ZEPHIR_SUBSTR_NO_LENGTH);
ZEPHIR_INIT_NVAR(file);
ZEPHIR_CONCAT_VSV(file, dir, "/", _13$$6);
if ((zephir_file_exists(file TSRMLS_CC) == SUCCESS)) {
RETURN_CCTOR(file);
}
}
}
}
}
_14 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr4"), PH_NOISY_CC);
zephir_is_iterable(_14, &_16, &_15, 0, 0, "xpl/classloader.zep", 517);
for (
; zephir_hash_get_current_data_ex(_16, (void**) &_17, &_15) == SUCCESS
; zephir_hash_move_forward_ex(_16, &_15)
) {
ZEPHIR_GET_HVALUE(dir, _17);
ZEPHIR_INIT_NVAR(file);
ZEPHIR_CONCAT_VSV(file, dir, "/", logicalPathPsr4);
if ((zephir_file_exists(file TSRMLS_CC) == SUCCESS)) {
RETURN_CCTOR(file);
}
}
ZEPHIR_SINIT_VAR(_18);
ZVAL_STRING(&_18, "\\", 0);
ZEPHIR_CALL_FUNCTION(&nsPos, "strrpos", NULL, 57, className, &_18);
zephir_check_call_status();
ZEPHIR_INIT_VAR(logicalPathPsr0);
if (zephir_is_true(nsPos)) {
ZEPHIR_SINIT_VAR(_19$$10);
ZVAL_LONG(&_19$$10, 0);
ZEPHIR_SINIT_VAR(_20$$10);
ZVAL_LONG(&_20$$10, (zephir_get_numberval(nsPos) + 1));
ZEPHIR_INIT_VAR(_21$$10);
zephir_substr(_21$$10, logicalPathPsr4, 0 , zephir_get_intval(&_20$$10), 0);
ZEPHIR_SINIT_VAR(_22$$10);
ZVAL_LONG(&_22$$10, (zephir_get_numberval(nsPos) + 1));
ZEPHIR_INIT_VAR(_23$$10);
zephir_substr(_23$$10, logicalPathPsr4, zephir_get_intval(&_22$$10), 0, ZEPHIR_SUBSTR_NO_LENGTH);
ZEPHIR_SINIT_VAR(_24$$10);
ZVAL_STRING(&_24$$10, "_", 0);
ZEPHIR_SINIT_VAR(_25$$10);
ZVAL_STRING(&_25$$10, "/", 0);
ZEPHIR_CALL_FUNCTION(&_26$$10, "strtr", &_3, 56, _23$$10, &_24$$10, &_25$$10);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(logicalPathPsr0, _21$$10, _26$$10);
} else {
ZEPHIR_SINIT_VAR(_27$$11);
ZVAL_STRING(&_27$$11, "_", 0);
ZEPHIR_SINIT_VAR(_28$$11);
ZVAL_STRING(&_28$$11, "/", 0);
ZEPHIR_CALL_FUNCTION(&_29$$11, "strtr", &_3, 56, className, &_27$$11, &_28$$11);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(logicalPathPsr0, _29$$11, ext);
}
ZEPHIR_OBS_VAR(prefixesPsr0);
_30 = zephir_fetch_nproperty_this(this_ptr, SL("prefixesPsr0"), PH_NOISY_CC);
if (zephir_array_isset_fetch(&prefixesPsr0, _30, firstChar, 0 TSRMLS_CC)) {
zephir_is_iterable(prefixesPsr0, &_32$$12, &_31$$12, 0, 0, "xpl/classloader.zep", 546);
for (
; zephir_hash_get_current_data_ex(_32$$12, (void**) &_33$$12, &_31$$12) == SUCCESS
; zephir_hash_move_forward_ex(_32$$12, &_31$$12)
) {
ZEPHIR_GET_HMKEY(prefix, _32$$12, _31$$12);
ZEPHIR_GET_HVALUE(dirs, _33$$12);
if (zephir_start_with(className, prefix, NULL)) {
zephir_is_iterable(dirs, &_35$$14, &_34$$14, 0, 0, "xpl/classloader.zep", 544);
for (
; zephir_hash_get_current_data_ex(_35$$14, (void**) &_36$$14, &_34$$14) == SUCCESS
; zephir_hash_move_forward_ex(_35$$14, &_34$$14)
) {
ZEPHIR_GET_HVALUE(dir, _36$$14);
ZEPHIR_INIT_NVAR(file);
ZEPHIR_CONCAT_VSV(file, dir, "/", logicalPathPsr0);
if ((zephir_file_exists(file TSRMLS_CC) == SUCCESS)) {
RETURN_CCTOR(file);
}
}
}
}
}
_37 = zephir_fetch_nproperty_this(this_ptr, SL("fallbackDirsPsr0"), PH_NOISY_CC);
zephir_is_iterable(_37, &_39, &_38, 0, 0, "xpl/classloader.zep", 559);
for (
; zephir_hash_get_current_data_ex(_39, (void**) &_40, &_38) == SUCCESS
; zephir_hash_move_forward_ex(_39, &_38)
) {
ZEPHIR_GET_HVALUE(dir, _40);
ZEPHIR_INIT_NVAR(file);
ZEPHIR_CONCAT_VSV(file, dir, "/", logicalPathPsr0);
if ((zephir_file_exists(file TSRMLS_CC) == SUCCESS)) {
RETURN_CCTOR(file);
}
}
_41 = zephir_fetch_nproperty_this(this_ptr, SL("useIncludePath"), PH_NOISY_CC);
if (ZEPHIR_IS_TRUE_IDENTICAL(_41)) {
ZEPHIR_CALL_FUNCTION(&file, "stream_resolve_include_path", NULL, 58, logicalPathPsr0);
zephir_check_call_status();
if (zephir_is_true(file)) {
RETURN_CCTOR(file);
}
}
RETURN_MM_NULL();
}
/**
* Pads texts before encryption
*
* @see http://www.di-mgt.com.au/cryptopad.html
*/
PHP_METHOD(Phalcon_Crypt, _cryptPadText) {
zephir_fcall_cache_entry *_3 = NULL, *_5 = NULL, *_10 = NULL;
zend_bool _0, _7;
int blockSize, paddingType, i, paddingSize = 0, ZEPHIR_LAST_CALL_STATUS, _8, _9;
zval *text_param = NULL, *mode_param = NULL, *blockSize_param = NULL, *paddingType_param = NULL, *padding = NULL, _1 = zval_used_for_init, *_2 = NULL, *_4 = NULL, *_6 = NULL, _11 = zval_used_for_init, *_12;
zval *text = NULL, *mode = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &text_param, &mode_param, &blockSize_param, &paddingType_param);
zephir_get_strval(text, text_param);
if (unlikely(Z_TYPE_P(mode_param) != IS_STRING && Z_TYPE_P(mode_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'mode' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(mode_param) == IS_STRING)) {
zephir_get_strval(mode, mode_param);
} else {
ZEPHIR_INIT_VAR(mode);
ZVAL_EMPTY_STRING(mode);
}
if (unlikely(Z_TYPE_P(blockSize_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'blockSize' must be a long/integer") TSRMLS_CC);
RETURN_MM_NULL();
}
blockSize = Z_LVAL_P(blockSize_param);
if (unlikely(Z_TYPE_P(paddingType_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'paddingType' must be a long/integer") TSRMLS_CC);
RETURN_MM_NULL();
}
paddingType = Z_LVAL_P(paddingType_param);
ZEPHIR_INIT_VAR(padding);
ZVAL_NULL(padding);
_0 = ZEPHIR_IS_STRING(mode, "cbc");
if (!(_0)) {
_0 = ZEPHIR_IS_STRING(mode, "ecb");
}
if (_0) {
paddingSize = (blockSize - (zephir_safe_mod_long_long(zephir_fast_strlen_ev(text), blockSize TSRMLS_CC)));
if (paddingSize >= 256) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Block size is bigger than 256", "phalcon/crypt.zep", 142);
return;
}
do {
if (paddingType == 1) {
ZEPHIR_SINIT_VAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_CALL_FUNCTION(&_2, "chr", &_3, 128, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, (paddingSize - 1));
ZEPHIR_CALL_FUNCTION(&_4, "str_repeat", &_5, 129, _2, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, paddingSize);
ZEPHIR_CALL_FUNCTION(&_6, "chr", &_3, 128, &_1);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(padding);
ZEPHIR_CONCAT_VV(padding, _4, _6);
break;
}
if (paddingType == 2) {
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, paddingSize);
ZEPHIR_CALL_FUNCTION(&_2, "chr", &_3, 128, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, paddingSize);
ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_5, 129, _2, &_1);
zephir_check_call_status();
break;
}
if (paddingType == 3) {
ZEPHIR_INIT_NVAR(padding);
ZVAL_STRING(padding, "", 1);
_9 = (paddingSize - 2);
_8 = 0;
_7 = 0;
if (_8 <= _9) {
while (1) {
if (_7) {
_8++;
if (!(_8 <= _9)) {
break;
}
} else {
_7 = 1;
}
i = _8;
ZEPHIR_CALL_FUNCTION(&_2, "rand", &_10, 107);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_4, "chr", &_3, 128, _2);
zephir_check_call_status();
zephir_concat_self(&padding, _4 TSRMLS_CC);
}
}
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, paddingSize);
ZEPHIR_CALL_FUNCTION(&_6, "chr", &_3, 128, &_1);
zephir_check_call_status();
zephir_concat_self(&padding, _6 TSRMLS_CC);
break;
}
if (paddingType == 4) {
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 0x80);
ZEPHIR_CALL_FUNCTION(&_2, "chr", &_3, 128, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_CALL_FUNCTION(&_4, "chr", &_3, 128, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, (paddingSize - 1));
ZEPHIR_CALL_FUNCTION(&_6, "str_repeat", &_5, 129, _4, &_1);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(padding);
ZEPHIR_CONCAT_VV(padding, _2, _6);
break;
}
if (paddingType == 5) {
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_CALL_FUNCTION(&_2, "chr", &_3, 128, &_1);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, paddingSize);
ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_5, 129, _2, &_1);
zephir_check_call_status();
break;
}
if (paddingType == 6) {
ZEPHIR_SINIT_NVAR(_1);
ZVAL_STRING(&_1, " ", 0);
ZEPHIR_SINIT_VAR(_11);
ZVAL_LONG(&_11, paddingSize);
ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_5, 129, &_1, &_11);
zephir_check_call_status();
break;
}
paddingSize = 0;
break;
} while(0);
}
if (!(paddingSize)) {
RETURN_CTOR(text);
}
if (paddingSize > blockSize) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Invalid padding size", "phalcon/crypt.zep", 186);
return;
}
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_SINIT_NVAR(_11);
ZVAL_LONG(&_11, paddingSize);
ZEPHIR_INIT_VAR(_12);
zephir_substr(_12, padding, 0 , zephir_get_intval(&_11), 0);
ZEPHIR_CONCAT_VV(return_value, text, _12);
RETURN_MM();
}
/**
* Phalcon\Session\Adapter\Libmemcached constructor
*/
PHP_METHOD(Phalcon_Session_Adapter_Libmemcached, __construct) {
zephir_fcall_cache_entry *_12 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *options_param = NULL, *servers, *client = NULL, *lifetime = NULL, *prefix = NULL, *statsKey = NULL, *_0, *_1, *_3, *_6 = NULL;
zval *options = NULL, *_2, *_4, *_5, *_7, *_8, *_9, *_10, *_11;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &options_param);
zephir_get_arrval(options, options_param);
ZEPHIR_OBS_VAR(servers);
if (!(zephir_array_isset_string_fetch(&servers, options, SS("servers"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_session_exception_ce, "No servers given in options", "phalcon/session/adapter/libmemcached.zep", 68);
return;
}
ZEPHIR_OBS_VAR(client);
if (!(zephir_array_isset_string_fetch(&client, options, SS("client"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(client);
ZVAL_NULL(client);
}
ZEPHIR_OBS_VAR(lifetime);
if (!(zephir_array_isset_string_fetch(&lifetime, options, SS("lifetime"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(lifetime);
ZVAL_LONG(lifetime, 8600);
}
zephir_update_property_this(this_ptr, SL("_lifetime"), lifetime TSRMLS_CC);
ZEPHIR_OBS_VAR(prefix);
if (!(zephir_array_isset_string_fetch(&prefix, options, SS("prefix"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(prefix);
ZVAL_NULL(prefix);
}
ZEPHIR_OBS_VAR(statsKey);
if (!(zephir_array_isset_string_fetch(&statsKey, options, SS("statsKey"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(statsKey);
ZVAL_NULL(statsKey);
}
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, phalcon_cache_backend_libmemcached_ce);
ZEPHIR_INIT_VAR(_1);
object_init_ex(_1, phalcon_cache_frontend_data_ce);
ZEPHIR_INIT_VAR(_2);
zephir_create_array(_2, 1, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_3);
zephir_read_property_this(&_3, this_ptr, SL("_lifetime"), PH_NOISY_CC);
zephir_array_update_string(&_2, SL("lifetime"), &_3, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 311, _2);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_4);
zephir_create_array(_4, 4, 0 TSRMLS_CC);
zephir_array_update_string(&_4, SL("servers"), &servers, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_4, SL("client"), &client, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_4, SL("prefix"), &prefix, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_4, SL("statsKey"), &statsKey, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 312, _1, _4);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_libmemcached"), _0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_5);
zephir_create_array(_5, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_5, this_ptr);
ZEPHIR_INIT_VAR(_6);
ZVAL_STRING(_6, "open", 1);
zephir_array_fast_append(_5, _6);
ZEPHIR_INIT_VAR(_7);
zephir_create_array(_7, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_7, this_ptr);
ZEPHIR_INIT_NVAR(_6);
ZVAL_STRING(_6, "close", 1);
zephir_array_fast_append(_7, _6);
ZEPHIR_INIT_VAR(_8);
zephir_create_array(_8, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_8, this_ptr);
ZEPHIR_INIT_NVAR(_6);
ZVAL_STRING(_6, "read", 1);
zephir_array_fast_append(_8, _6);
ZEPHIR_INIT_VAR(_9);
zephir_create_array(_9, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_9, this_ptr);
ZEPHIR_INIT_NVAR(_6);
ZVAL_STRING(_6, "write", 1);
zephir_array_fast_append(_9, _6);
ZEPHIR_INIT_VAR(_10);
zephir_create_array(_10, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_10, this_ptr);
ZEPHIR_INIT_NVAR(_6);
ZVAL_STRING(_6, "destroy", 1);
zephir_array_fast_append(_10, _6);
ZEPHIR_INIT_VAR(_11);
zephir_create_array(_11, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_11, this_ptr);
ZEPHIR_INIT_NVAR(_6);
ZVAL_STRING(_6, "gc", 1);
zephir_array_fast_append(_11, _6);
ZEPHIR_CALL_FUNCTION(NULL, "session_set_save_handler", NULL, 409, _5, _7, _8, _9, _10, _11);
zephir_check_call_status();
ZEPHIR_CALL_PARENT(NULL, phalcon_session_adapter_libmemcached_ce, this_ptr, "__construct", &_12, 410, options);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Removes padding @a padding_type from @a text
* If the function detects that the text was not padded, it will return it unmodified
*
* @param return_value Result, possibly unpadded
* @param text Message to be unpadded
* @param mode Encryption mode; unpadding is applied only in CBC or ECB mode
* @param block_size Cipher block size
* @param padding_type Padding scheme
*/
PHP_METHOD(Phalcon_Crypt, _cryptUnpadText) {
unsigned char _14, _16;
zephir_fcall_cache_entry *_6 = NULL, *_9 = NULL, *_11 = NULL;
zend_bool _0, _1, _2, _13, _15;
long length;
int blockSize, paddingType, i, paddingSize = 0, ord, ZEPHIR_LAST_CALL_STATUS;
zval *text_param = NULL, *mode_param = NULL, *blockSize_param = NULL, *paddingType_param = NULL, *padding = NULL, *last = NULL, _3 = zval_used_for_init, _4 = zval_used_for_init, *_5 = NULL, _7 = zval_used_for_init, *_8 = NULL, *_10 = NULL, *_12 = NULL;
zval *text = NULL, *mode = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &text_param, &mode_param, &blockSize_param, &paddingType_param);
zephir_get_strval(text, text_param);
if (unlikely(Z_TYPE_P(mode_param) != IS_STRING && Z_TYPE_P(mode_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'mode' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(mode_param) == IS_STRING)) {
zephir_get_strval(mode, mode_param);
} else {
ZEPHIR_INIT_VAR(mode);
ZVAL_EMPTY_STRING(mode);
}
if (unlikely(Z_TYPE_P(blockSize_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'blockSize' must be a long/integer") TSRMLS_CC);
RETURN_MM_NULL();
}
blockSize = Z_LVAL_P(blockSize_param);
if (unlikely(Z_TYPE_P(paddingType_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'paddingType' must be a long/integer") TSRMLS_CC);
RETURN_MM_NULL();
}
paddingType = Z_LVAL_P(paddingType_param);
length = zephir_fast_strlen_ev(text);
_0 = length > 0;
if (_0) {
_0 = (zephir_safe_mod_long_long(length, blockSize TSRMLS_CC) == 0);
}
_1 = _0;
if (_1) {
_2 = ZEPHIR_IS_STRING(mode, "cbc");
if (!(_2)) {
_2 = ZEPHIR_IS_STRING(mode, "ecb");
}
_1 = _2;
}
if (_1) {
do {
if (paddingType == 1) {
ZEPHIR_SINIT_VAR(_3);
ZVAL_LONG(&_3, (length - 1));
ZEPHIR_SINIT_VAR(_4);
ZVAL_LONG(&_4, 1);
ZEPHIR_INIT_VAR(last);
zephir_substr(last, text, zephir_get_intval(&_3), 1 , 0);
ZEPHIR_CALL_FUNCTION(&_5, "ord", &_6, 130, last);
zephir_check_call_status();
ord = zephir_get_intval(_5);
if (ord <= blockSize) {
paddingSize = ord;
ZEPHIR_SINIT_VAR(_7);
ZVAL_LONG(&_7, 0);
ZEPHIR_CALL_FUNCTION(&_8, "chr", &_9, 128, &_7);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, (paddingSize - 1));
ZEPHIR_CALL_FUNCTION(&_10, "str_repeat", &_11, 129, _8, &_7);
zephir_check_call_status();
ZEPHIR_INIT_VAR(padding);
ZEPHIR_CONCAT_VV(padding, _10, last);
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, (length - paddingSize));
ZEPHIR_INIT_VAR(_12);
zephir_substr(_12, text, zephir_get_intval(&_7), 0, ZEPHIR_SUBSTR_NO_LENGTH);
if (!ZEPHIR_IS_EQUAL(_12, padding)) {
paddingSize = 0;
}
}
break;
}
if (paddingType == 2) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, (length - 1));
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, 1);
ZEPHIR_INIT_NVAR(last);
zephir_substr(last, text, zephir_get_intval(&_3), 1 , 0);
ZEPHIR_CALL_FUNCTION(&_5, "ord", &_6, 130, last);
zephir_check_call_status();
ord = zephir_get_intval(_5);
if (ord <= blockSize) {
paddingSize = ord;
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, paddingSize);
ZEPHIR_CALL_FUNCTION(&_8, "chr", &_9, 128, &_7);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, paddingSize);
ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_11, 129, _8, &_7);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, (length - paddingSize));
ZEPHIR_INIT_NVAR(_12);
zephir_substr(_12, text, zephir_get_intval(&_7), 0, ZEPHIR_SUBSTR_NO_LENGTH);
if (!ZEPHIR_IS_EQUAL(_12, padding)) {
paddingSize = 0;
}
}
break;
}
if (paddingType == 3) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, (length - 1));
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, 1);
ZEPHIR_INIT_NVAR(last);
zephir_substr(last, text, zephir_get_intval(&_3), 1 , 0);
ZEPHIR_CALL_FUNCTION(&_5, "ord", &_6, 130, last);
zephir_check_call_status();
paddingSize = zephir_get_intval(_5);
break;
}
if (paddingType == 4) {
i = (length - 1);
while (1) {
_13 = i > 0;
if (_13) {
_14 = ZEPHIR_STRING_OFFSET(text, i);
_13 = _14 == 0x00;
}
_15 = _13;
if (_15) {
_15 = paddingSize < blockSize;
}
if (!(_15)) {
break;
}
paddingSize++;
i--;
}
_16 = ZEPHIR_STRING_OFFSET(text, i);
if (_16 == 0x80) {
paddingSize++;
} else {
paddingSize = 0;
}
break;
}
if (paddingType == 5) {
i = (length - 1);
while (1) {
_13 = i >= 0;
if (_13) {
_14 = ZEPHIR_STRING_OFFSET(text, i);
_13 = _14 == 0x00;
}
_15 = _13;
if (_15) {
_15 = paddingSize <= blockSize;
}
if (!(_15)) {
break;
}
paddingSize++;
i--;
}
break;
}
if (paddingType == 6) {
i = (length - 1);
while (1) {
_13 = i >= 0;
if (_13) {
_14 = ZEPHIR_STRING_OFFSET(text, i);
_13 = _14 == 0x20;
}
_15 = _13;
if (_15) {
_15 = paddingSize <= blockSize;
}
if (!(_15)) {
break;
}
paddingSize++;
i--;
}
break;
}
break;
} while(0);
_13 = (paddingSize) ? 1 : 0;
if (_13) {
_13 = paddingSize <= blockSize;
}
if (_13) {
if (paddingSize < length) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, 0);
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, (length - paddingSize));
zephir_substr(return_value, text, 0 , zephir_get_intval(&_4), 0);
RETURN_MM();
}
RETURN_MM_STRING("", 1);
} else {
paddingSize = 0;
}
}
if (!(paddingSize)) {
RETURN_CTOR(text);
}
ZEPHIR_MM_RESTORE();
}
/**
* The plural version of gettext().
* Some languages have more than one form for plural messages dependent on the count.
*
* @param string msgid1
* @param string msgid2
* @param int count
* @param array placeholders
* @param string domain
*
* @return string
*/
PHP_METHOD(Phalcon_Translate_Adapter_Gettext, nquery) {
int count, ZEPHIR_LAST_CALL_STATUS;
zval *msgid1_param = NULL, *msgid2_param = NULL, *count_param = NULL, *placeholders = NULL, *domain_param = NULL, *translation = NULL, _0$$3, _1$$4;
zval *msgid1 = NULL, *msgid2 = NULL, *domain = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 2, &msgid1_param, &msgid2_param, &count_param, &placeholders, &domain_param);
if (unlikely(Z_TYPE_P(msgid1_param) != IS_STRING && Z_TYPE_P(msgid1_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'msgid1' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(msgid1_param) == IS_STRING)) {
zephir_get_strval(msgid1, msgid1_param);
} else {
ZEPHIR_INIT_VAR(msgid1);
ZVAL_EMPTY_STRING(msgid1);
}
if (unlikely(Z_TYPE_P(msgid2_param) != IS_STRING && Z_TYPE_P(msgid2_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'msgid2' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(msgid2_param) == IS_STRING)) {
zephir_get_strval(msgid2, msgid2_param);
} else {
ZEPHIR_INIT_VAR(msgid2);
ZVAL_EMPTY_STRING(msgid2);
}
if (unlikely(Z_TYPE_P(count_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'count' must be a int") TSRMLS_CC);
RETURN_MM_NULL();
}
count = Z_LVAL_P(count_param);
if (!placeholders) {
placeholders = ZEPHIR_GLOBAL(global_null);
}
if (!domain_param) {
ZEPHIR_INIT_VAR(domain);
ZVAL_EMPTY_STRING(domain);
} else {
if (unlikely(Z_TYPE_P(domain_param) != IS_STRING && Z_TYPE_P(domain_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'domain' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(domain_param) == IS_STRING)) {
zephir_get_strval(domain, domain_param);
} else {
ZEPHIR_INIT_VAR(domain);
ZVAL_EMPTY_STRING(domain);
}
}
if (!(!(!domain) && Z_STRLEN_P(domain))) {
ZEPHIR_SINIT_VAR(_0$$3);
ZVAL_LONG(&_0$$3, count);
ZEPHIR_CALL_FUNCTION(&translation, "ngettext", NULL, 429, msgid1, msgid2, &_0$$3);
zephir_check_call_status();
} else {
ZEPHIR_SINIT_VAR(_1$$4);
ZVAL_LONG(&_1$$4, count);
ZEPHIR_CALL_FUNCTION(&translation, "dngettext", NULL, 430, domain, msgid1, msgid2, &_1$$4);
zephir_check_call_status();
}
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "replaceplaceholders", NULL, 0, translation, placeholders);
zephir_check_call_status();
RETURN_MM();
}
/**
* Encrypts a text
*
*<code>
* $encrypted = $crypt->encrypt("Ultra-secret text", "encrypt password");
*</code>
*/
PHP_METHOD(Phalcon_Crypt, encrypt) {
zend_bool _3, _4;
int ZEPHIR_LAST_CALL_STATUS, _2;
zval *text_param = NULL, *key_param = NULL, *encryptKey = NULL, *ivSize = NULL, *iv = NULL, *cipher, *mode, *blockSize = NULL, *paddingType, *padded = NULL, _0, *_1 = NULL;
zval *text = NULL, *key = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &text_param, &key_param);
if (unlikely(Z_TYPE_P(text_param) != IS_STRING && Z_TYPE_P(text_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'text' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(text_param) == IS_STRING)) {
zephir_get_strval(text, text_param);
} else {
ZEPHIR_INIT_VAR(text);
ZVAL_EMPTY_STRING(text);
}
if (!key_param) {
ZEPHIR_INIT_VAR(key);
ZVAL_EMPTY_STRING(key);
} else {
if (unlikely(Z_TYPE_P(key_param) != IS_STRING && Z_TYPE_P(key_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'key' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(key_param) == IS_STRING)) {
zephir_get_strval(key, key_param);
} else {
ZEPHIR_INIT_VAR(key);
ZVAL_EMPTY_STRING(key);
}
}
if (!((zephir_function_exists_ex(SS("mcrypt_get_iv_size") TSRMLS_CC) == SUCCESS))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "mcrypt extension is required", "phalcon/crypt.zep", 302);
return;
}
if (ZEPHIR_IS_STRING_IDENTICAL(key, "")) {
ZEPHIR_OBS_VAR(encryptKey);
zephir_read_property_this(&encryptKey, this_ptr, SL("_key"), PH_NOISY_CC);
} else {
ZEPHIR_CPY_WRT(encryptKey, key);
}
if (ZEPHIR_IS_EMPTY(encryptKey)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Encryption key cannot be empty", "phalcon/crypt.zep", 312);
return;
}
ZEPHIR_OBS_VAR(cipher);
zephir_read_property_this(&cipher, this_ptr, SL("_cipher"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(mode);
zephir_read_property_this(&mode, this_ptr, SL("_mode"), PH_NOISY_CC);
ZEPHIR_CALL_FUNCTION(&ivSize, "mcrypt_get_iv_size", NULL, 131, cipher, mode);
zephir_check_call_status();
if (ZEPHIR_LT_LONG(ivSize, zephir_fast_strlen_ev(encryptKey))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Size of key is too large for this algorithm", "phalcon/crypt.zep", 320);
return;
}
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, 2);
ZEPHIR_CALL_FUNCTION(&iv, "mcrypt_create_iv", NULL, 132, ivSize, &_0);
zephir_check_call_status();
if (Z_TYPE_P(iv) != IS_STRING) {
ZEPHIR_CALL_FUNCTION(&_1, "strval", NULL, 20, iv);
zephir_check_call_status();
ZEPHIR_CPY_WRT(iv, _1);
}
ZEPHIR_CALL_FUNCTION(&blockSize, "mcrypt_get_block_size", NULL, 133, cipher, mode);
zephir_check_call_status();
if (Z_TYPE_P(blockSize) != IS_LONG) {
_2 = zephir_get_intval(blockSize);
ZEPHIR_INIT_NVAR(blockSize);
ZVAL_LONG(blockSize, _2);
}
ZEPHIR_OBS_VAR(paddingType);
zephir_read_property_this(&paddingType, this_ptr, SL("_padding"), PH_NOISY_CC);
_3 = !ZEPHIR_IS_LONG(paddingType, 0);
if (_3) {
_4 = ZEPHIR_IS_STRING(mode, "cbc");
if (!(_4)) {
_4 = ZEPHIR_IS_STRING(mode, "ecb");
}
_3 = _4;
}
if (_3) {
ZEPHIR_CALL_METHOD(&padded, this_ptr, "_cryptpadtext", NULL, 0, text, mode, blockSize, paddingType);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(padded, text);
}
ZEPHIR_CALL_FUNCTION(&_1, "mcrypt_encrypt", NULL, 134, cipher, encryptKey, padded, mode, iv);
zephir_check_call_status();
ZEPHIR_CONCAT_VV(return_value, iv, _1);
RETURN_MM();
}
/**
* The meta-data is obtained by reading the column descriptions from the database information schema
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Strategy_Introspection, getMetaData) {
zend_bool _16$$9;
HashTable *_8;
HashPosition _7;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *model, *dependencyInjector, *schema = NULL, *table = NULL, *readConnection = NULL, *columns = NULL, *attributes = NULL, *primaryKeys = NULL, *nonPrimaryKeys = NULL, *completeTable = NULL, *numericTyped = NULL, *notNull = NULL, *fieldTypes = NULL, *automaticDefault = NULL, *identityField = NULL, *fieldBindTypes = NULL, *defaultValues = NULL, *column = NULL, *fieldName = NULL, *defaultValue = NULL, *emptyStringValues = NULL, *_0 = NULL, **_9, *_1$$3, *_2$$3, *_3$$3, *_4$$6, *_5$$6, *_6$$6, *_10$$9 = NULL, *_11$$9 = NULL, *_12$$9 = NULL, *_13$$9 = NULL, *_14$$9 = NULL, *_15$$9 = NULL, *_17$$9 = NULL, *_18$$15 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &model, &dependencyInjector);
ZEPHIR_CALL_METHOD(&schema, model, "getschema", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&table, model, "getsource", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&readConnection, model, "getreadconnection", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_0, readConnection, "tableexists", NULL, 0, table, schema);
zephir_check_call_status();
if (!(zephir_is_true(_0))) {
if (zephir_is_true(schema)) {
ZEPHIR_INIT_VAR(completeTable);
ZEPHIR_CONCAT_VSV(completeTable, schema, "'.'", table);
} else {
ZEPHIR_CPY_WRT(completeTable, table);
}
ZEPHIR_INIT_VAR(_1$$3);
object_init_ex(_1$$3, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(_2$$3);
zephir_get_class(_2$$3, model, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_3$$3);
ZEPHIR_CONCAT_SVSV(_3$$3, "Table '", completeTable, "' doesn't exist in database when dumping meta-data for ", _2$$3);
ZEPHIR_CALL_METHOD(NULL, _1$$3, "__construct", NULL, 9, _3$$3);
zephir_check_call_status();
zephir_throw_exception_debug(_1$$3, "phalcon/mvc/model/metadata/strategy/introspection.zep", 68 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_CALL_METHOD(&columns, readConnection, "describecolumns", NULL, 0, table, schema);
zephir_check_call_status();
if (!(zephir_fast_count_int(columns TSRMLS_CC))) {
if (zephir_is_true(schema)) {
ZEPHIR_INIT_NVAR(completeTable);
ZEPHIR_CONCAT_VSV(completeTable, schema, "'.'", table);
} else {
ZEPHIR_CPY_WRT(completeTable, table);
}
ZEPHIR_INIT_VAR(_4$$6);
object_init_ex(_4$$6, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(_5$$6);
zephir_get_class(_5$$6, model, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_6$$6);
ZEPHIR_CONCAT_SVSV(_6$$6, "Cannot obtain table columns for the mapped source '", completeTable, "' used in model ", _5$$6);
ZEPHIR_CALL_METHOD(NULL, _4$$6, "__construct", NULL, 9, _6$$6);
zephir_check_call_status();
zephir_throw_exception_debug(_4$$6, "phalcon/mvc/model/metadata/strategy/introspection.zep", 88 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(attributes);
array_init(attributes);
ZEPHIR_INIT_VAR(primaryKeys);
array_init(primaryKeys);
ZEPHIR_INIT_VAR(nonPrimaryKeys);
array_init(nonPrimaryKeys);
ZEPHIR_INIT_VAR(numericTyped);
array_init(numericTyped);
ZEPHIR_INIT_VAR(notNull);
array_init(notNull);
ZEPHIR_INIT_VAR(fieldTypes);
array_init(fieldTypes);
ZEPHIR_INIT_VAR(fieldBindTypes);
array_init(fieldBindTypes);
ZEPHIR_INIT_VAR(automaticDefault);
array_init(automaticDefault);
ZEPHIR_INIT_VAR(identityField);
ZVAL_BOOL(identityField, 0);
ZEPHIR_INIT_VAR(defaultValues);
array_init(defaultValues);
ZEPHIR_INIT_VAR(emptyStringValues);
array_init(emptyStringValues);
zephir_is_iterable(columns, &_8, &_7, 0, 0, "phalcon/mvc/model/metadata/strategy/introspection.zep", 165);
for (
; zend_hash_get_current_data_ex(_8, (void**) &_9, &_7) == SUCCESS
; zend_hash_move_forward_ex(_8, &_7)
) {
ZEPHIR_GET_HVALUE(column, _9);
ZEPHIR_CALL_METHOD(&fieldName, column, "getname", NULL, 0);
zephir_check_call_status();
zephir_array_append(&attributes, fieldName, PH_SEPARATE, "phalcon/mvc/model/metadata/strategy/introspection.zep", 109);
ZEPHIR_CALL_METHOD(&_10$$9, column, "isprimary", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_10$$9)) {
zephir_array_append(&primaryKeys, fieldName, PH_SEPARATE, "phalcon/mvc/model/metadata/strategy/introspection.zep", 115);
} else {
zephir_array_append(&nonPrimaryKeys, fieldName, PH_SEPARATE, "phalcon/mvc/model/metadata/strategy/introspection.zep", 117);
}
ZEPHIR_CALL_METHOD(&_11$$9, column, "isnumeric", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_11$$9)) {
zephir_array_update_zval(&numericTyped, fieldName, &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
ZEPHIR_CALL_METHOD(&_12$$9, column, "isnotnull", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_12$$9)) {
zephir_array_append(¬Null, fieldName, PH_SEPARATE, "phalcon/mvc/model/metadata/strategy/introspection.zep", 131);
}
ZEPHIR_CALL_METHOD(&_13$$9, column, "isautoincrement", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_13$$9)) {
ZEPHIR_CPY_WRT(identityField, fieldName);
}
ZEPHIR_CALL_METHOD(&_14$$9, column, "gettype", NULL, 0);
zephir_check_call_status();
zephir_array_update_zval(&fieldTypes, fieldName, &_14$$9, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(&_15$$9, column, "getbindtype", NULL, 0);
zephir_check_call_status();
zephir_array_update_zval(&fieldBindTypes, fieldName, &_15$$9, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(&defaultValue, column, "getdefault", NULL, 0);
zephir_check_call_status();
_16$$9 = Z_TYPE_P(defaultValue) != IS_NULL;
if (!(_16$$9)) {
ZEPHIR_CALL_METHOD(&_17$$9, column, "isnotnull", NULL, 0);
zephir_check_call_status();
_16$$9 = ZEPHIR_IS_FALSE_IDENTICAL(_17$$9);
}
if (_16$$9) {
ZEPHIR_CALL_METHOD(&_18$$15, column, "isautoincrement", NULL, 0);
zephir_check_call_status();
if (!(zephir_is_true(_18$$15))) {
zephir_array_update_zval(&defaultValues, fieldName, &defaultValue, PH_COPY | PH_SEPARATE);
}
}
}
zephir_create_array(return_value, 12, 0 TSRMLS_CC);
zephir_array_update_long(&return_value, 0, &attributes, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 1, &primaryKeys, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 2, &nonPrimaryKeys, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 3, ¬Null, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 4, &fieldTypes, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 5, &numericTyped, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 8, &identityField, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 9, &fieldBindTypes, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 10, &automaticDefault, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 11, &automaticDefault, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 12, &defaultValues, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 13, &emptyStringValues, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
RETURN_MM();
}
/**
* Decrypts an encrypted text
*
*<code>
* echo $crypt->decrypt($encrypted, "decrypt password");
*</code>
*/
PHP_METHOD(Phalcon_Crypt, decrypt) {
zend_bool _3;
int ZEPHIR_LAST_CALL_STATUS;
zval *text_param = NULL, *key = NULL, *decryptKey = NULL, *ivSize = NULL, *cipher, *mode, *keySize, *length, *blockSize = NULL, *paddingType, *decrypted = NULL, *_0, _1, *_2;
zval *text = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &text_param, &key);
if (unlikely(Z_TYPE_P(text_param) != IS_STRING && Z_TYPE_P(text_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'text' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(text_param) == IS_STRING)) {
zephir_get_strval(text, text_param);
} else {
ZEPHIR_INIT_VAR(text);
ZVAL_EMPTY_STRING(text);
}
if (!key) {
key = ZEPHIR_GLOBAL(global_null);
}
if (!((zephir_function_exists_ex(SS("mcrypt_get_iv_size") TSRMLS_CC) == SUCCESS))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "mcrypt extension is required", "phalcon/crypt.zep", 356);
return;
}
if (Z_TYPE_P(key) == IS_NULL) {
ZEPHIR_OBS_VAR(decryptKey);
zephir_read_property_this(&decryptKey, this_ptr, SL("_key"), PH_NOISY_CC);
} else {
ZEPHIR_CPY_WRT(decryptKey, key);
}
if (ZEPHIR_IS_EMPTY(decryptKey)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Decryption key cannot be empty", "phalcon/crypt.zep", 366);
return;
}
ZEPHIR_OBS_VAR(cipher);
zephir_read_property_this(&cipher, this_ptr, SL("_cipher"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(mode);
zephir_read_property_this(&mode, this_ptr, SL("_mode"), PH_NOISY_CC);
ZEPHIR_CALL_FUNCTION(&ivSize, "mcrypt_get_iv_size", NULL, 131, cipher, mode);
zephir_check_call_status();
ZEPHIR_INIT_VAR(keySize);
ZVAL_LONG(keySize, zephir_fast_strlen_ev(decryptKey));
if (ZEPHIR_GT(keySize, ivSize)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Size of key is too large for this algorithm", "phalcon/crypt.zep", 375);
return;
}
ZEPHIR_INIT_VAR(length);
ZVAL_LONG(length, zephir_fast_strlen_ev(text));
if (ZEPHIR_GT(keySize, length)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Size of IV is larger than text to decrypt", "phalcon/crypt.zep", 380);
return;
}
ZEPHIR_INIT_VAR(_0);
zephir_substr(_0, text, zephir_get_intval(ivSize), 0, ZEPHIR_SUBSTR_NO_LENGTH);
ZEPHIR_SINIT_VAR(_1);
ZVAL_LONG(&_1, 0);
ZEPHIR_INIT_VAR(_2);
zephir_substr(_2, text, 0 , zephir_get_intval(ivSize), 0);
ZEPHIR_CALL_FUNCTION(&decrypted, "mcrypt_decrypt", NULL, 135, cipher, decryptKey, _0, mode, _2);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&blockSize, "mcrypt_get_block_size", NULL, 133, cipher, mode);
zephir_check_call_status();
ZEPHIR_OBS_VAR(paddingType);
zephir_read_property_this(&paddingType, this_ptr, SL("_padding"), PH_NOISY_CC);
_3 = ZEPHIR_IS_STRING(mode, "cbc");
if (!(_3)) {
_3 = ZEPHIR_IS_STRING(mode, "ecb");
}
if (_3) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_cryptunpadtext", NULL, 0, decrypted, mode, blockSize, paddingType);
zephir_check_call_status();
RETURN_MM();
}
RETURN_CCTOR(decrypted);
}
/**
* Fires an event in the events manager causing that active listeners be notified about it
*
*<code>
* $eventsManager->fire('db', $connection);
*</code>
*
* @param string eventType
* @param object source
* @param mixed data
* @param boolean cancelable
* @return mixed
*/
PHP_METHOD(Phalcon_Events_Manager, fire) {
zephir_nts_static zephir_fcall_cache_entry *_2 = NULL, *_5 = NULL, *_6 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool cancelable, _4;
zval *eventType_param = NULL, *source, *data = NULL, *cancelable_param = NULL, *events, *eventParts, *type, *eventName, *event = NULL, *status = NULL, *fireEvents = NULL, *_0, *_3;
zval *eventType = NULL, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 2, &eventType_param, &source, &data, &cancelable_param);
if (unlikely(Z_TYPE_P(eventType_param) != IS_STRING && Z_TYPE_P(eventType_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'eventType' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(eventType_param) == IS_STRING)) {
zephir_get_strval(eventType, eventType_param);
} else {
ZEPHIR_INIT_VAR(eventType);
ZVAL_EMPTY_STRING(eventType);
}
if (!data) {
data = ZEPHIR_GLOBAL(global_null);
}
if (!cancelable_param) {
cancelable = 1;
} else {
cancelable = zephir_get_boolval(cancelable_param);
}
ZEPHIR_OBS_VAR(events);
zephir_read_property_this(&events, this_ptr, SL("_events"), PH_NOISY_CC);
if (Z_TYPE_P(events) != IS_ARRAY) {
RETURN_MM_NULL();
}
if (!(zephir_memnstr_str(eventType, SL(":"), "phalcon/events/manager.zep", 408))) {
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, phalcon_events_exception_ce);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SV(_1, "Invalid event type ", eventType);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_2, _1);
zephir_check_call_status();
zephir_throw_exception_debug(_0, "phalcon/events/manager.zep", 409 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(eventParts);
zephir_fast_explode_str(eventParts, SL(":"), eventType, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(type);
zephir_array_fetch_long(&type, eventParts, 0, PH_NOISY, "phalcon/events/manager.zep", 413 TSRMLS_CC);
ZEPHIR_OBS_VAR(eventName);
zephir_array_fetch_long(&eventName, eventParts, 1, PH_NOISY, "phalcon/events/manager.zep", 414 TSRMLS_CC);
ZEPHIR_INIT_VAR(status);
ZVAL_NULL(status);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_collect"), PH_NOISY_CC);
if (zephir_is_true(_3)) {
zephir_update_property_this(this_ptr, SL("_responses"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
}
ZEPHIR_INIT_VAR(event);
ZVAL_NULL(event);
ZEPHIR_OBS_VAR(fireEvents);
if (zephir_array_isset_fetch(&fireEvents, events, type, 0 TSRMLS_CC)) {
_4 = Z_TYPE_P(fireEvents) == IS_OBJECT;
if (!(_4)) {
_4 = Z_TYPE_P(fireEvents) == IS_ARRAY;
}
if (_4) {
ZEPHIR_INIT_NVAR(event);
object_init_ex(event, phalcon_events_event_ce);
ZEPHIR_CALL_METHOD(NULL, event, "__construct", &_5, eventName, source, data, (cancelable ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)));
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&status, this_ptr, "firequeue", &_6, fireEvents, event);
zephir_check_call_status();
}
}
ZEPHIR_OBS_NVAR(fireEvents);
if (zephir_array_isset_fetch(&fireEvents, events, eventType, 0 TSRMLS_CC)) {
_4 = Z_TYPE_P(fireEvents) == IS_OBJECT;
if (!(_4)) {
_4 = Z_TYPE_P(fireEvents) == IS_ARRAY;
}
if (_4) {
if (Z_TYPE_P(event) == IS_NULL) {
ZEPHIR_INIT_NVAR(event);
object_init_ex(event, phalcon_events_event_ce);
ZEPHIR_CALL_METHOD(NULL, event, "__construct", &_5, eventName, source, data, (cancelable ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)));
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&status, this_ptr, "firequeue", &_6, fireEvents, event);
zephir_check_call_status();
}
}
RETURN_CCTOR(status);
}
/**
* Returns a ClassLoader for the given Composer installation.
*
* @param string vendorPath
* @param boolean prepend [Optional] Default = true
*
* @return \Xpl\ClassLoader
*/
PHP_METHOD(Xpl_ClassLoader, composer) {
HashTable *_8, *_12, *_18$$10;
HashPosition _7, _11, _17$$10;
zephir_fcall_cache_entry *_10 = NULL, *_14 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool prepend;
zval *vendorPath_param = NULL, *prepend_param = NULL, *composerPath = NULL, *instances = NULL, *loader = NULL, *ns = NULL, *path = NULL, *namespaces = NULL, *psr4 = NULL, *classMap = NULL, *filesPath = NULL, *files = NULL, *_0, _1, *_2, *_3, *_4 = NULL, *_5, *_6, **_9, **_13, *_15, *_16$$10 = NULL, **_19$$10;
zval *vendorPath = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &vendorPath_param, &prepend_param);
if (unlikely(Z_TYPE_P(vendorPath_param) != IS_STRING && Z_TYPE_P(vendorPath_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'vendorPath' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(vendorPath_param) == IS_STRING)) {
zephir_get_strval(vendorPath, vendorPath_param);
} else {
ZEPHIR_INIT_VAR(vendorPath);
ZVAL_EMPTY_STRING(vendorPath);
}
if (!prepend_param) {
prepend = 1;
} else {
prepend = zephir_get_boolval(prepend_param);
}
ZEPHIR_INIT_VAR(_0);
ZEPHIR_SINIT_VAR(_1);
ZVAL_STRING(&_1, "/\\", 0);
zephir_fast_trim(_0, vendorPath, &_1, ZEPHIR_TRIM_RIGHT TSRMLS_CC);
ZEPHIR_INIT_VAR(_2);
ZEPHIR_CONCAT_VS(_2, _0, "/composer");
ZEPHIR_CALL_FUNCTION(&composerPath, "realpath", NULL, 47, _2);
zephir_check_call_status();
if (!(zephir_is_true(composerPath))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Composer directory does not exist", "xpl/classloader.zep", 147);
return;
}
zephir_concat_self_str(&composerPath, SL("/") TSRMLS_CC);
ZEPHIR_OBS_VAR(instances);
zephir_read_static_property_ce(&instances, xpl_classloader_ce, SL("composerInstances") TSRMLS_CC);
if (Z_TYPE_P(instances) != IS_NULL) {
ZEPHIR_OBS_VAR(loader);
if (zephir_array_isset_fetch(&loader, instances, composerPath, 0 TSRMLS_CC)) {
RETURN_CCTOR(loader);
}
} else {
ZEPHIR_INIT_NVAR(instances);
array_init(instances);
}
ZEPHIR_INIT_NVAR(loader);
object_init_ex(loader, xpl_classloader_ce);
if (zephir_has_constructor(loader TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, loader, "__construct", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_INIT_VAR(_3);
ZEPHIR_CONCAT_VS(_3, composerPath, "autoload_namespaces.php");
ZEPHIR_OBSERVE_OR_NULLIFY_PPZV(&_4);
if (zephir_require_zval_ret(&_4, _3 TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
ZEPHIR_CPY_WRT(namespaces, _4);
ZEPHIR_INIT_VAR(_5);
ZEPHIR_CONCAT_VS(_5, composerPath, "autoload_psr4.php");
ZEPHIR_OBSERVE_OR_NULLIFY_PPZV(&_4);
if (zephir_require_zval_ret(&_4, _5 TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
ZEPHIR_CPY_WRT(psr4, _4);
ZEPHIR_INIT_VAR(_6);
ZEPHIR_CONCAT_VS(_6, composerPath, "autoload_classmap.php");
ZEPHIR_OBSERVE_OR_NULLIFY_PPZV(&_4);
if (zephir_require_zval_ret(&_4, _6 TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
ZEPHIR_CPY_WRT(classMap, _4);
ZEPHIR_INIT_VAR(filesPath);
ZEPHIR_CONCAT_VS(filesPath, composerPath, "autoload_files.php");
zephir_is_iterable(namespaces, &_8, &_7, 0, 0, "xpl/classloader.zep", 171);
for (
; zephir_hash_get_current_data_ex(_8, (void**) &_9, &_7) == SUCCESS
; zephir_hash_move_forward_ex(_8, &_7)
) {
ZEPHIR_GET_HMKEY(ns, _8, _7);
ZEPHIR_GET_HVALUE(path, _9);
ZEPHIR_CALL_METHOD(NULL, loader, "set", &_10, 48, ns, path);
zephir_check_call_status();
}
zephir_is_iterable(psr4, &_12, &_11, 0, 0, "xpl/classloader.zep", 175);
for (
; zephir_hash_get_current_data_ex(_12, (void**) &_13, &_11) == SUCCESS
; zephir_hash_move_forward_ex(_12, &_11)
) {
ZEPHIR_GET_HMKEY(ns, _12, _11);
ZEPHIR_GET_HVALUE(path, _13);
ZEPHIR_CALL_METHOD(NULL, loader, "setpsr4", &_14, 49, ns, path);
zephir_check_call_status();
}
if (zephir_fast_count_int(classMap TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, loader, "addclassmap", NULL, 50, classMap);
zephir_check_call_status();
}
ZEPHIR_INIT_VAR(_15);
if (prepend) {
ZVAL_BOOL(_15, 1);
} else {
ZVAL_BOOL(_15, 0);
}
ZEPHIR_CALL_METHOD(NULL, loader, "register", NULL, 51, _15);
zephir_check_call_status();
if ((zephir_file_exists(filesPath TSRMLS_CC) == SUCCESS)) {
ZEPHIR_OBSERVE_OR_NULLIFY_PPZV(&_16$$10);
if (zephir_require_zval_ret(&_16$$10, filesPath TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
ZEPHIR_CPY_WRT(files, _16$$10);
zephir_is_iterable(files, &_18$$10, &_17$$10, 0, 0, "xpl/classloader.zep", 186);
for (
; zephir_hash_get_current_data_ex(_18$$10, (void**) &_19$$10, &_17$$10) == SUCCESS
; zephir_hash_move_forward_ex(_18$$10, &_17$$10)
) {
ZEPHIR_GET_HVALUE(path, _19$$10);
if (zephir_require_zval(path TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
}
}
ZEPHIR_CALL_METHOD(NULL, loader, "setcomposerpath", NULL, 52, composerPath);
zephir_check_call_status();
zephir_array_update_zval(&instances, composerPath, &loader, PH_COPY | PH_SEPARATE);
zephir_update_static_property_ce(xpl_classloader_ce, SL("composerInstances"), &instances TSRMLS_CC);
RETURN_CCTOR(loader);
}
/**
* Detach the listener from the events manager
*
* @param string eventType
* @param object handler
*/
PHP_METHOD(Phalcon_Events_Manager, detach) {
zephir_fcall_cache_entry *_3 = NULL, *_4 = NULL, *_8 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *eventType_param = NULL, *handler, *priorityQueue = NULL, *newPriorityQueue = NULL, *key = NULL, *data = NULL, *_0, *_1$$5 = NULL, *_2$$5 = NULL, *_5$$6, *_6$$7, *_7$$7;
zval *eventType = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &eventType_param, &handler);
if (UNEXPECTED(Z_TYPE_P(eventType_param) != IS_STRING && Z_TYPE_P(eventType_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'eventType' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(eventType_param) == IS_STRING)) {
zephir_get_strval(eventType, eventType_param);
} else {
ZEPHIR_INIT_VAR(eventType);
ZVAL_EMPTY_STRING(eventType);
}
if (Z_TYPE_P(handler) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_events_exception_ce, "Event handler must be an Object", "phalcon/events/manager.zep", 99);
return;
}
ZEPHIR_OBS_VAR(priorityQueue);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_events"), PH_NOISY_CC);
if (zephir_array_isset_fetch(&priorityQueue, _0, eventType, 0 TSRMLS_CC)) {
if (Z_TYPE_P(priorityQueue) == IS_OBJECT) {
ZEPHIR_INIT_VAR(newPriorityQueue);
object_init_ex(newPriorityQueue, spl_ce_SplPriorityQueue);
if (zephir_has_constructor(newPriorityQueue TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, newPriorityQueue, "__construct", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_INIT_VAR(_1$$5);
ZVAL_LONG(_1$$5, 1);
ZEPHIR_CALL_METHOD(NULL, newPriorityQueue, "setextractflags", NULL, 190, _1$$5);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_1$$5);
ZVAL_LONG(_1$$5, 3);
ZEPHIR_CALL_METHOD(NULL, priorityQueue, "setextractflags", NULL, 0, _1$$5);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, priorityQueue, "top", NULL, 0);
zephir_check_call_status();
while (1) {
ZEPHIR_CALL_METHOD(&_2$$5, priorityQueue, "valid", NULL, 0);
zephir_check_call_status();
if (!(zephir_is_true(_2$$5))) {
break;
}
ZEPHIR_CALL_METHOD(&data, priorityQueue, "current", &_3, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, priorityQueue, "next", &_4, 0);
zephir_check_call_status();
zephir_array_fetch_string(&_5$$6, data, SL("data"), PH_NOISY | PH_READONLY, "phalcon/events/manager.zep", 116 TSRMLS_CC);
if (!ZEPHIR_IS_IDENTICAL(_5$$6, handler)) {
zephir_array_fetch_string(&_6$$7, data, SL("data"), PH_NOISY | PH_READONLY, "phalcon/events/manager.zep", 117 TSRMLS_CC);
zephir_array_fetch_string(&_7$$7, data, SL("priority"), PH_NOISY | PH_READONLY, "phalcon/events/manager.zep", 117 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, newPriorityQueue, "insert", &_8, 191, _6$$7, _7$$7);
zephir_check_call_status();
}
}
zephir_update_property_array(this_ptr, SL("_events"), eventType, newPriorityQueue TSRMLS_CC);
} else {
ZEPHIR_CALL_FUNCTION(&key, "array_search", NULL, 192, handler, priorityQueue, ZEPHIR_GLOBAL(global_true));
zephir_check_call_status();
if (!ZEPHIR_IS_FALSE_IDENTICAL(key)) {
zephir_array_unset(&priorityQueue, key, PH_SEPARATE);
}
zephir_update_property_array(this_ptr, SL("_events"), eventType, priorityQueue TSRMLS_CC);
}
}
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(PhalconPlus_RPC_Server_AbstractServer, callByParams) {
zend_class_entry *_10, *_17;
zephir_nts_static zephir_fcall_cache_entry *_5 = NULL, *_7 = NULL, *_13 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *_3 = NULL, *_18, *_19;
zend_bool _2;
zval *service_param = NULL, *method_param = NULL, *request = NULL, *rawData, *serviceClass = NULL, *_0 = NULL, *_1, *tmp = NULL, *param, *paramClass = NULL, *_4 = NULL, *_6 = NULL, *_8 = NULL, *_9 = NULL, *_11 = NULL, *_12 = NULL, *_14, *_15, *serviceObj, *response = NULL, *e = NULL, *_16 = NULL, *_20;
zval *service = NULL, *method = NULL, *_21;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &service_param, &method_param, &request, &rawData);
if (unlikely(Z_TYPE_P(service_param) != IS_STRING && Z_TYPE_P(service_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'service' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(service_param) == IS_STRING)) {
zephir_get_strval(service, service_param);
} else {
ZEPHIR_INIT_VAR(service);
ZVAL_EMPTY_STRING(service);
}
if (unlikely(Z_TYPE_P(method_param) != IS_STRING && Z_TYPE_P(method_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'method' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(method_param) == IS_STRING)) {
zephir_get_strval(method, method_param);
} else {
ZEPHIR_INIT_VAR(method);
ZVAL_EMPTY_STRING(method);
}
ZEPHIR_INIT_VAR(serviceClass);
ZVAL_STRING(serviceClass, "", 1);
ZEPHIR_INIT_VAR(tmp);
array_init(tmp);
ZEPHIR_INIT_VAR(_1);
zephir_ucfirst(_1, service);
ZEPHIR_INIT_NVAR(serviceClass);
ZEPHIR_CONCAT_VS(serviceClass, _1, "Service");
_2 = Z_TYPE_P(request) == IS_OBJECT;
if (_2) {
_2 = zephir_instance_of_ev(request, phalconplus_base_protobuffer_ce TSRMLS_CC);
}
if (_2) {
zephir_update_property_this(this_ptr, SL("phpOnly"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
} else if (Z_TYPE_P(request) == IS_ARRAY) {
ZEPHIR_CPY_WRT(tmp, request);
ZEPHIR_INIT_VAR(param);
object_init_ex(param, zephir_get_internal_ce(SS("reflectionparameter") TSRMLS_CC));
ZEPHIR_INIT_VAR(_3);
zephir_create_array(_3, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_3, serviceClass);
zephir_array_fast_append(_3, method);
ZEPHIR_INIT_VAR(_4);
ZVAL_LONG(_4, 0);
ZEPHIR_CALL_METHOD(NULL, param, "__construct", &_5, _3, _4);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_6, param, "getclass", &_7);
zephir_check_call_status();
if (zephir_is_true(_6)) {
ZEPHIR_CALL_METHOD(&_8, param, "getclass", &_7);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(¶mClass, _8, "getname", NULL);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(request);
zephir_fetch_safe_class(_9, paramClass);
_10 = zend_fetch_class(Z_STRVAL_P(_9), Z_STRLEN_P(_9), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(request, _10);
if (zephir_has_constructor(request TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, request, "__construct", NULL);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(NULL, request, "softclone", NULL, tmp);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(_4);
object_init_ex(_4, zend_exception_get_default(TSRMLS_C));
ZEPHIR_INIT_VAR(_11);
zephir_json_encode(_11, &(_11), request, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_12);
ZEPHIR_CONCAT_SVSVSV(_12, "Service class:method definition is invalid. Detail: ", service, " : ", method, ". Request: ", _11);
ZEPHIR_CALL_METHOD(NULL, _4, "__construct", &_13, _12);
zephir_check_call_status();
zephir_throw_exception_debug(_4, "phalconplus/RPC/Server/AbstractServer.zep", 36 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_INIT_NVAR(_4);
object_init_ex(_4, zend_exception_get_default(TSRMLS_C));
ZEPHIR_INIT_NVAR(_11);
zephir_json_encode(_11, &(_11), request, 0 TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_12);
ZEPHIR_CONCAT_SV(_12, "Your input is not allowed. Request: ", _11);
ZEPHIR_CALL_METHOD(NULL, _4, "__construct", &_13, _12);
zephir_check_call_status();
zephir_throw_exception_debug(_4, "phalconplus/RPC/Server/AbstractServer.zep", 39 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
_14 = zephir_fetch_nproperty_this(this_ptr, SL("di"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "requestCheck", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_6, _14, "has", NULL, _4);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
if (zephir_is_true(_6)) {
_15 = zephir_fetch_nproperty_this(this_ptr, SL("di"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(_3);
zephir_create_array(_3, 3, 0 TSRMLS_CC);
zephir_array_fast_append(_3, serviceClass);
zephir_array_fast_append(_3, method);
zephir_array_fast_append(_3, rawData);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "requestCheck", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _15, "get", NULL, _4, _3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "requestcheck", NULL, serviceClass, method, request);
zephir_check_call_status();
}
ZEPHIR_INIT_VAR(serviceObj);
zephir_fetch_safe_class(_16, serviceClass);
_17 = zend_fetch_class(Z_STRVAL_P(_16), Z_STRLEN_P(_16), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(serviceObj, _17);
if (zephir_has_constructor(serviceObj TSRMLS_CC)) {
_15 = zephir_fetch_nproperty_this(this_ptr, SL("di"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, serviceObj, "__construct", NULL, _15);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_3);
zephir_create_array(_3, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_3, serviceObj);
zephir_array_fast_append(_3, method);
if (zephir_is_callable(_3 TSRMLS_CC)) {
/* try_start_1: */
ZEPHIR_INIT_NVAR(_4);
ZEPHIR_INIT_VAR(_18);
zephir_create_array(_18, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_18, serviceObj);
zephir_array_fast_append(_18, method);
ZEPHIR_INIT_VAR(_19);
zephir_create_array(_19, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_19, request);
ZEPHIR_CALL_USER_FUNC_ARRAY(_4, _18, _19);
zephir_check_call_status_or_jump(try_end_1);
ZEPHIR_CPY_WRT(response, _4);
try_end_1:
if (EG(exception)) {
ZEPHIR_CPY_WRT(e, EG(exception));
if (zephir_instance_of_ev(e, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) {
zend_clear_exception(TSRMLS_C);
zephir_throw_exception_debug(e, "phalconplus/RPC/Server/AbstractServer.zep", 55 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
ZEPHIR_INIT_NVAR(_4);
_20 = zephir_fetch_nproperty_this(this_ptr, SL("phpOnly"), PH_NOISY_CC);
if (ZEPHIR_IS_TRUE(_20)) {
ZEPHIR_CPY_WRT(_4, response);
} else {
ZEPHIR_CALL_METHOD(&_4, response, "toarray", NULL);
zephir_check_call_status();
}
RETURN_CCTOR(_4);
} else {
object_init_ex(_4, zend_exception_get_default(TSRMLS_C));
ZEPHIR_INIT_VAR(_21);
ZEPHIR_CONCAT_SVSV(_21, "Service:method not found. Detail: ", service, " : ", method);
ZEPHIR_CALL_METHOD(NULL, _4, "__construct", &_13, _21);
zephir_check_call_status();
zephir_throw_exception_debug(_4, "phalconplus/RPC/Server/AbstractServer.zep", 59 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
