/** * Executes the validation */ PHP_METHOD(Phalcon_Validation_Validator_File, validate) { zend_bool _1, _2, _3, _5, _6, _11, _12, _14, _20, _21, _50, _57$$16, _64$$21; zend_long ZEPHIR_LAST_CALL_STATUS; zval *validation, validation_sub, *field, field_sub, *_SERVER, *_POST, *_FILES, value, message, label, replacePairs, types, byteUnits, unit, maxSize, matches, bytes, mime, tmp, width, height, minResolution, maxResolution, minWidth, maxWidth, minHeight, maxHeight, fieldTypes, code, minResolutionArray, maxResolutionArray, _0, _4, _7, _13, _15, _16, _25, _26, _42, _49, _51, _8$$3, _9$$3, _10$$3, _17$$4, _18$$4, _19$$4, _22$$5, _23$$5, _24$$5, _27$$6, _29$$6, _30$$6, _31$$6, _32$$6, _33$$6, _34$$6, _35$$6, _36$$6, _37$$6, _38$$6, _28$$7, _39$$9, _40$$9, _41$$9, _43$$10, _44$$13, _45$$13, _46$$15, _47$$15, _48$$15, _52$$16, _53$$16, _54$$16, _61$$16, _55$$17, _56$$18, _58$$20, _59$$20, _60$$20, _62$$21, _63$$22, _65$$23, _66$$23, _67$$23; zval *this_ptr = getThis(); ZVAL_UNDEF(&validation_sub); ZVAL_UNDEF(&field_sub); ZVAL_UNDEF(&value); ZVAL_UNDEF(&message); ZVAL_UNDEF(&label); ZVAL_UNDEF(&replacePairs); ZVAL_UNDEF(&types); ZVAL_UNDEF(&byteUnits); ZVAL_UNDEF(&unit); ZVAL_UNDEF(&maxSize); ZVAL_UNDEF(&matches); ZVAL_UNDEF(&bytes); ZVAL_UNDEF(&mime); ZVAL_UNDEF(&tmp); ZVAL_UNDEF(&width); ZVAL_UNDEF(&height); ZVAL_UNDEF(&minResolution); ZVAL_UNDEF(&maxResolution); ZVAL_UNDEF(&minWidth); ZVAL_UNDEF(&maxWidth); ZVAL_UNDEF(&minHeight); ZVAL_UNDEF(&maxHeight); ZVAL_UNDEF(&fieldTypes); ZVAL_UNDEF(&code); ZVAL_UNDEF(&minResolutionArray); ZVAL_UNDEF(&maxResolutionArray); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_4); ZVAL_UNDEF(&_7); ZVAL_UNDEF(&_13); ZVAL_UNDEF(&_15); ZVAL_UNDEF(&_16); ZVAL_UNDEF(&_25); ZVAL_UNDEF(&_26); ZVAL_UNDEF(&_42); ZVAL_UNDEF(&_49); ZVAL_UNDEF(&_51); ZVAL_UNDEF(&_8$$3); ZVAL_UNDEF(&_9$$3); ZVAL_UNDEF(&_10$$3); ZVAL_UNDEF(&_17$$4); ZVAL_UNDEF(&_18$$4); ZVAL_UNDEF(&_19$$4); ZVAL_UNDEF(&_22$$5); ZVAL_UNDEF(&_23$$5); ZVAL_UNDEF(&_24$$5); ZVAL_UNDEF(&_27$$6); ZVAL_UNDEF(&_29$$6); ZVAL_UNDEF(&_30$$6); ZVAL_UNDEF(&_31$$6); ZVAL_UNDEF(&_32$$6); ZVAL_UNDEF(&_33$$6); ZVAL_UNDEF(&_34$$6); ZVAL_UNDEF(&_35$$6); ZVAL_UNDEF(&_36$$6); ZVAL_UNDEF(&_37$$6); ZVAL_UNDEF(&_38$$6); ZVAL_UNDEF(&_28$$7); ZVAL_UNDEF(&_39$$9); ZVAL_UNDEF(&_40$$9); ZVAL_UNDEF(&_41$$9); ZVAL_UNDEF(&_43$$10); ZVAL_UNDEF(&_44$$13); ZVAL_UNDEF(&_45$$13); ZVAL_UNDEF(&_46$$15); ZVAL_UNDEF(&_47$$15); ZVAL_UNDEF(&_48$$15); ZVAL_UNDEF(&_52$$16); ZVAL_UNDEF(&_53$$16); ZVAL_UNDEF(&_54$$16); ZVAL_UNDEF(&_61$$16); ZVAL_UNDEF(&_55$$17); ZVAL_UNDEF(&_56$$18); ZVAL_UNDEF(&_58$$20); ZVAL_UNDEF(&_59$$20); ZVAL_UNDEF(&_60$$20); ZVAL_UNDEF(&_62$$21); ZVAL_UNDEF(&_63$$22); ZVAL_UNDEF(&_65$$23); ZVAL_UNDEF(&_66$$23); ZVAL_UNDEF(&_67$$23); ZEPHIR_MM_GROW(); zephir_get_global(&_FILES, SL("_FILES")); zephir_get_global(&_POST, SL("_POST")); zephir_get_global(&_SERVER, SL("_SERVER")); zephir_fetch_params(1, 2, 0, &validation, &field); ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&code, this_ptr, "preparecode", NULL, 0, field); zephir_check_call_status(); zephir_array_fetch_string(&_0, _SERVER, SL("REQUEST_METHOD"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 103 TSRMLS_CC); _1 = ZEPHIR_IS_STRING(&_0, "POST"); if (_1) { _1 = ZEPHIR_IS_EMPTY(_POST); } _2 = _1; if (_2) { _2 = ZEPHIR_IS_EMPTY(_FILES); } _3 = _2; if (_3) { zephir_array_fetch_string(&_4, _SERVER, SL("CONTENT_LENGTH"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 103 TSRMLS_CC); _3 = ZEPHIR_GT_LONG(&_4, 0); } _5 = _3; if (!(_5)) { _6 = zephir_array_isset_string(&value, SL("error")); if (_6) { zephir_array_fetch_string(&_7, &value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 103 TSRMLS_CC); _6 = ZEPHIR_IS_LONG_IDENTICAL(&_7, 1); } _5 = _6; } if (_5) { ZEPHIR_INIT_VAR(&_8$$3); ZVAL_STRING(&_8$$3, "FileIniSize"); ZEPHIR_INIT_VAR(&_9$$3); ZVAL_STRING(&_9$$3, "messageIniSize"); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_8$$3, &_9$$3); zephir_check_call_status(); ZEPHIR_INIT_VAR(&replacePairs); zephir_create_array(&replacePairs, 1, 0 TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_8$$3); object_init_ex(&_8$$3, phalcon_messages_message_ce); ZEPHIR_CALL_FUNCTION(&_10$$3, "strtr", NULL, 50, &message, &replacePairs); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_9$$3); ZVAL_STRING(&_9$$3, "FileIniSize"); ZEPHIR_CALL_METHOD(NULL, &_8$$3, "__construct", NULL, 295, &_10$$3, field, &_9$$3, &code); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_8$$3); zephir_check_call_status(); RETURN_MM_BOOL(0); } _11 = !(zephir_array_isset_string(&value, SL("error"))); if (!(_11)) { _11 = !(zephir_array_isset_string(&value, SL("tmp_name"))); } _12 = _11; if (!(_12)) { zephir_array_fetch_string(&_13, &value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 119 TSRMLS_CC); _12 = !ZEPHIR_IS_LONG_IDENTICAL(&_13, 0); } _14 = _12; if (!(_14)) { zephir_array_fetch_string(&_15, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 119 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&_16, "is_uploaded_file", NULL, 228, &_15); zephir_check_call_status(); _14 = !zephir_is_true(&_16); } if (_14) { ZEPHIR_INIT_VAR(&_17$$4); ZVAL_STRING(&_17$$4, "FileEmpty"); ZEPHIR_INIT_VAR(&_18$$4); ZVAL_STRING(&_18$$4, "messageEmpty"); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_17$$4, &_18$$4); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&replacePairs); zephir_create_array(&replacePairs, 1, 0 TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_17$$4); object_init_ex(&_17$$4, phalcon_messages_message_ce); ZEPHIR_CALL_FUNCTION(&_19$$4, "strtr", NULL, 50, &message, &replacePairs); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_18$$4); ZVAL_STRING(&_18$$4, "FileEmpty"); ZEPHIR_CALL_METHOD(NULL, &_17$$4, "__construct", NULL, 295, &_19$$4, field, &_18$$4, &code); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_17$$4); zephir_check_call_status(); RETURN_MM_BOOL(0); } _20 = !(zephir_array_isset_string(&value, SL("name"))); if (!(_20)) { _20 = !(zephir_array_isset_string(&value, SL("type"))); } _21 = _20; if (!(_21)) { _21 = !(zephir_array_isset_string(&value, SL("size"))); } if (_21) { ZEPHIR_INIT_VAR(&_22$$5); ZVAL_STRING(&_22$$5, "FileValid"); ZEPHIR_INIT_VAR(&_23$$5); ZVAL_STRING(&_23$$5, "messageValid"); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_22$$5, &_23$$5); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&replacePairs); zephir_create_array(&replacePairs, 1, 0 TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_22$$5); object_init_ex(&_22$$5, phalcon_messages_message_ce); ZEPHIR_CALL_FUNCTION(&_24$$5, "strtr", NULL, 50, &message, &replacePairs); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_23$$5); ZVAL_STRING(&_23$$5, "FileValid"); ZEPHIR_CALL_METHOD(NULL, &_22$$5, "__construct", NULL, 295, &_24$$5, field, &_23$$5, &code); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_22$$5); zephir_check_call_status(); RETURN_MM_BOOL(0); } ZEPHIR_INIT_VAR(&_26); ZVAL_STRING(&_26, "maxSize"); ZEPHIR_CALL_METHOD(&_25, this_ptr, "hasoption", NULL, 0, &_26); zephir_check_call_status(); if (zephir_is_true(&_25)) { ZEPHIR_INIT_VAR(&byteUnits); zephir_create_array(&byteUnits, 9, 0 TSRMLS_CC); add_assoc_long_ex(&byteUnits, SL("B"), 0); add_assoc_long_ex(&byteUnits, SL("K"), 10); add_assoc_long_ex(&byteUnits, SL("M"), 20); add_assoc_long_ex(&byteUnits, SL("G"), 30); add_assoc_long_ex(&byteUnits, SL("T"), 40); add_assoc_long_ex(&byteUnits, SL("KB"), 10); add_assoc_long_ex(&byteUnits, SL("MB"), 20); add_assoc_long_ex(&byteUnits, SL("GB"), 30); add_assoc_long_ex(&byteUnits, SL("TB"), 40); ZEPHIR_INIT_VAR(&_27$$6); ZVAL_STRING(&_27$$6, "maxSize"); ZEPHIR_CALL_METHOD(&maxSize, this_ptr, "getoption", NULL, 0, &_27$$6); zephir_check_call_status(); ZEPHIR_INIT_VAR(&matches); ZVAL_NULL(&matches); ZEPHIR_INIT_VAR(&unit); ZVAL_STRING(&unit, "B"); if (Z_TYPE_P(&maxSize) == IS_ARRAY) { zephir_array_fetch(&_28$$7, &maxSize, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 159 TSRMLS_CC); ZEPHIR_CPY_WRT(&maxSize, &_28$$7); } ZEPHIR_INIT_NVAR(&_27$$6); ZEPHIR_INIT_VAR(&_29$$6); zephir_array_keys(&_29$$6, &byteUnits TSRMLS_CC); zephir_fast_join_str(&_27$$6, SL("|"), &_29$$6 TSRMLS_CC); ZEPHIR_INIT_VAR(&_30$$6); ZEPHIR_CONCAT_SVS(&_30$$6, "/^([0-9]+(?:\\.[0-9]+)?)(", &_27$$6, ")?$/Di"); ZEPHIR_INIT_VAR(&_31$$6); zephir_preg_match(&_31$$6, &_30$$6, &maxSize, &matches, 0, 0 , 0 TSRMLS_CC); if (zephir_array_isset_long(&matches, 2)) { ZEPHIR_OBS_NVAR(&unit); zephir_array_fetch_long(&unit, &matches, 2, PH_NOISY, "phalcon/validation/validator/file.zep", 165 TSRMLS_CC); } zephir_array_fetch_long(&_32$$6, &matches, 1, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 168 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&_33$$6, "floatval", NULL, 319, &_32$$6); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_34$$6); zephir_array_fetch(&_35$$6, &byteUnits, &unit, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 168 TSRMLS_CC); ZVAL_LONG(&_36$$6, 2); zephir_pow_function(&_34$$6, &_36$$6, &_35$$6); ZEPHIR_INIT_VAR(&bytes); mul_function(&bytes, &_33$$6, &_34$$6 TSRMLS_CC); zephir_array_fetch_string(&_37$$6, &value, SL("size"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 170 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&_33$$6, "floatval", NULL, 319, &_37$$6); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_38$$6, "floatval", NULL, 319, &bytes); zephir_check_call_status(); if (ZEPHIR_GT(&_33$$6, &_38$$6)) { ZEPHIR_INIT_VAR(&_39$$9); ZVAL_STRING(&_39$$9, "FileSize"); ZEPHIR_INIT_VAR(&_40$$9); ZVAL_STRING(&_40$$9, "messageSize"); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_39$$9, &_40$$9); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&replacePairs); zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE); zephir_array_update_string(&replacePairs, SL(":max"), &maxSize, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_39$$9); object_init_ex(&_39$$9, phalcon_messages_message_ce); ZEPHIR_CALL_FUNCTION(&_41$$9, "strtr", NULL, 50, &message, &replacePairs); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_40$$9); ZVAL_STRING(&_40$$9, "FileSize"); ZEPHIR_CALL_METHOD(NULL, &_39$$9, "__construct", NULL, 295, &_41$$9, field, &_40$$9, &code); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_39$$9); zephir_check_call_status(); RETURN_MM_BOOL(0); } } ZEPHIR_INIT_NVAR(&_26); ZVAL_STRING(&_26, "allowedTypes"); ZEPHIR_CALL_METHOD(&_42, this_ptr, "hasoption", NULL, 0, &_26); zephir_check_call_status(); if (zephir_is_true(&_42)) { ZEPHIR_INIT_VAR(&_43$$10); ZVAL_STRING(&_43$$10, "allowedTypes"); ZEPHIR_CALL_METHOD(&types, this_ptr, "getoption", NULL, 0, &_43$$10); zephir_check_call_status(); ZEPHIR_OBS_VAR(&fieldTypes); if (zephir_array_isset_fetch(&fieldTypes, &types, field, 0 TSRMLS_CC)) { ZEPHIR_CPY_WRT(&types, &fieldTypes); } if (Z_TYPE_P(&types) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'allowedTypes' must be an array", "phalcon/validation/validator/file.zep", 196); return; } if ((zephir_function_exists_ex(SL("finfo_open") TSRMLS_CC) == SUCCESS)) { ZVAL_LONG(&_44$$13, 16); ZEPHIR_CALL_FUNCTION(&tmp, "finfo_open", NULL, 225, &_44$$13); zephir_check_call_status(); zephir_array_fetch_string(&_45$$13, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 201 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 226, &tmp, &_45$$13); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(NULL, "finfo_close", NULL, 227, &tmp); zephir_check_call_status(); } else { ZEPHIR_OBS_NVAR(&mime); zephir_array_fetch_string(&mime, &value, SL("type"), PH_NOISY, "phalcon/validation/validator/file.zep", 205 TSRMLS_CC); } if (!(zephir_fast_in_array(&mime, &types TSRMLS_CC))) { ZEPHIR_INIT_VAR(&_46$$15); ZVAL_STRING(&_46$$15, "FileType"); ZEPHIR_INIT_VAR(&_47$$15); ZVAL_STRING(&_47$$15, "messageType"); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_46$$15, &_47$$15); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&replacePairs); zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_46$$15); zephir_fast_join_str(&_46$$15, SL(", "), &types TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":types"), &_46$$15, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_46$$15); object_init_ex(&_46$$15, phalcon_messages_message_ce); ZEPHIR_CALL_FUNCTION(&_48$$15, "strtr", NULL, 50, &message, &replacePairs); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_47$$15); ZVAL_STRING(&_47$$15, "FileType"); ZEPHIR_CALL_METHOD(NULL, &_46$$15, "__construct", NULL, 295, &_48$$15, field, &_47$$15, &code); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_46$$15); zephir_check_call_status(); RETURN_MM_BOOL(0); } } ZEPHIR_INIT_NVAR(&_26); ZVAL_STRING(&_26, "minResolution"); ZEPHIR_CALL_METHOD(&_49, this_ptr, "hasoption", NULL, 0, &_26); zephir_check_call_status(); _50 = zephir_is_true(&_49); if (!(_50)) { ZEPHIR_INIT_NVAR(&_26); ZVAL_STRING(&_26, "maxResolution"); ZEPHIR_CALL_METHOD(&_51, this_ptr, "hasoption", NULL, 0, &_26); zephir_check_call_status(); _50 = zephir_is_true(&_51); } if (_50) { zephir_array_fetch_string(&_52$$16, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 226 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", NULL, 237, &_52$$16); zephir_check_call_status(); ZEPHIR_OBS_VAR(&width); zephir_array_fetch_long(&width, &tmp, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 227 TSRMLS_CC); ZEPHIR_OBS_VAR(&height); zephir_array_fetch_long(&height, &tmp, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 228 TSRMLS_CC); ZEPHIR_INIT_VAR(&_54$$16); ZVAL_STRING(&_54$$16, "minResolution"); ZEPHIR_CALL_METHOD(&_53$$16, this_ptr, "hasoption", NULL, 0, &_54$$16); zephir_check_call_status(); if (zephir_is_true(&_53$$16)) { ZEPHIR_INIT_VAR(&_55$$17); ZVAL_STRING(&_55$$17, "minResolution"); ZEPHIR_CALL_METHOD(&minResolution, this_ptr, "getoption", NULL, 0, &_55$$17); zephir_check_call_status(); if (Z_TYPE_P(&minResolution) == IS_ARRAY) { zephir_array_fetch(&_56$$18, &minResolution, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 233 TSRMLS_CC); ZEPHIR_CPY_WRT(&minResolution, &_56$$18); } ZEPHIR_INIT_VAR(&minResolutionArray); zephir_fast_explode_str(&minResolutionArray, SL("x"), &minResolution, LONG_MAX TSRMLS_CC); ZEPHIR_OBS_VAR(&minWidth); zephir_array_fetch_long(&minWidth, &minResolutionArray, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 236 TSRMLS_CC); ZEPHIR_OBS_VAR(&minHeight); zephir_array_fetch_long(&minHeight, &minResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 237 TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(&minWidth); ZVAL_LONG(&minWidth, 1); ZEPHIR_INIT_NVAR(&minHeight); ZVAL_LONG(&minHeight, 1); } _57$$16 = ZEPHIR_LT(&width, &minWidth); if (!(_57$$16)) { _57$$16 = ZEPHIR_LT(&height, &minHeight); } if (_57$$16) { ZEPHIR_INIT_VAR(&_58$$20); ZVAL_STRING(&_58$$20, "FileMinResolution"); ZEPHIR_INIT_VAR(&_59$$20); ZVAL_STRING(&_59$$20, "messageMinResolution"); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_58$$20, &_59$$20); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&replacePairs); zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE); zephir_array_update_string(&replacePairs, SL(":min"), &minResolution, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_58$$20); object_init_ex(&_58$$20, phalcon_messages_message_ce); ZEPHIR_CALL_FUNCTION(&_60$$20, "strtr", NULL, 50, &message, &replacePairs); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_59$$20); ZVAL_STRING(&_59$$20, "FileMinResolution"); ZEPHIR_CALL_METHOD(NULL, &_58$$20, "__construct", NULL, 295, &_60$$20, field, &_59$$20, &code); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_58$$20); zephir_check_call_status(); RETURN_MM_BOOL(0); } ZEPHIR_INIT_NVAR(&_54$$16); ZVAL_STRING(&_54$$16, "maxResolution"); ZEPHIR_CALL_METHOD(&_61$$16, this_ptr, "hasoption", NULL, 0, &_54$$16); zephir_check_call_status(); if (zephir_is_true(&_61$$16)) { ZEPHIR_INIT_VAR(&_62$$21); ZVAL_STRING(&_62$$21, "maxResolution"); ZEPHIR_CALL_METHOD(&maxResolution, this_ptr, "getoption", NULL, 0, &_62$$21); zephir_check_call_status(); if (Z_TYPE_P(&maxResolution) == IS_ARRAY) { zephir_array_fetch(&_63$$22, &maxResolution, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 263 TSRMLS_CC); ZEPHIR_CPY_WRT(&maxResolution, &_63$$22); } ZEPHIR_INIT_VAR(&maxResolutionArray); zephir_fast_explode_str(&maxResolutionArray, SL("x"), &maxResolution, LONG_MAX TSRMLS_CC); ZEPHIR_OBS_VAR(&maxWidth); zephir_array_fetch_long(&maxWidth, &maxResolutionArray, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 266 TSRMLS_CC); ZEPHIR_OBS_VAR(&maxHeight); zephir_array_fetch_long(&maxHeight, &maxResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 267 TSRMLS_CC); _64$$21 = ZEPHIR_GT(&width, &maxWidth); if (!(_64$$21)) { _64$$21 = ZEPHIR_GT(&height, &maxHeight); } if (_64$$21) { ZEPHIR_INIT_VAR(&_65$$23); ZVAL_STRING(&_65$$23, "FileMaxResolution"); ZEPHIR_INIT_VAR(&_66$$23); ZVAL_STRING(&_66$$23, "messageMaxResolution"); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_65$$23, &_66$$23); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&replacePairs); zephir_create_array(&replacePairs, 2, 0 TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE); zephir_array_update_string(&replacePairs, SL(":max"), &maxResolution, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_65$$23); object_init_ex(&_65$$23, phalcon_messages_message_ce); ZEPHIR_CALL_FUNCTION(&_67$$23, "strtr", NULL, 50, &message, &replacePairs); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_66$$23); ZVAL_STRING(&_66$$23, "FileMaxResolution"); ZEPHIR_CALL_METHOD(NULL, &_65$$23, "__construct", NULL, 295, &_67$$23, field, &_66$$23, &code); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_65$$23); zephir_check_call_status(); RETURN_MM_BOOL(0); } } } RETURN_MM_BOOL(1); }
/** * Renders a view * * @param string path * @param array params */ PHP_METHOD(Phalcon_Mvc_View_Simple, render) { zend_bool _3$$12; zend_long ZEPHIR_LAST_CALL_STATUS; zval *path_param = NULL, *params = NULL, *cache = NULL, *key = NULL, *lifetime = NULL, *cacheOptions = NULL, *content = NULL, *viewParams = NULL, *mergedParams = NULL, *_1, *_0$$3 = NULL, *_2$$12 = NULL, *_4$$12 = NULL; zval *path = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &path_param, ¶ms); if (UNEXPECTED(Z_TYPE_P(path_param) != IS_STRING && Z_TYPE_P(path_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'path' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(path_param) == IS_STRING)) { zephir_get_strval(path, path_param); } else { ZEPHIR_INIT_VAR(path); ZVAL_EMPTY_STRING(path); } if (!params) { params = ZEPHIR_GLOBAL(global_null); } ZEPHIR_CALL_METHOD(&cache, this_ptr, "getcache", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(cache) == IS_OBJECT) { ZEPHIR_CALL_METHOD(&_0$$3, cache, "isstarted", NULL, 0); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(_0$$3)) { ZEPHIR_INIT_VAR(key); ZVAL_NULL(key); ZEPHIR_INIT_VAR(lifetime); ZVAL_NULL(lifetime); ZEPHIR_OBS_VAR(cacheOptions); zephir_read_property_this(&cacheOptions, this_ptr, SL("_cacheOptions"), PH_NOISY_CC); if (Z_TYPE_P(cacheOptions) == IS_ARRAY) { ZEPHIR_OBS_NVAR(key); zephir_array_isset_string_fetch(&key, cacheOptions, SS("key"), 0 TSRMLS_CC); ZEPHIR_OBS_NVAR(lifetime); zephir_array_isset_string_fetch(&lifetime, cacheOptions, SS("lifetime"), 0 TSRMLS_CC); } if (Z_TYPE_P(key) == IS_NULL) { ZEPHIR_INIT_NVAR(key); zephir_md5(key, path); } ZEPHIR_CALL_METHOD(&content, cache, "start", NULL, 0, key, lifetime); zephir_check_call_status(); if (Z_TYPE_P(content) != IS_NULL) { zephir_update_property_this(getThis(), SL("_content"), content TSRMLS_CC); RETURN_CCTOR(content); } } } ZEPHIR_INIT_VAR(_1); zephir_create_symbol_table(TSRMLS_C); ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 134); zephir_check_call_status(); ZEPHIR_OBS_VAR(viewParams); zephir_read_property_this(&viewParams, this_ptr, SL("_viewParams"), PH_NOISY_CC); if (Z_TYPE_P(params) == IS_ARRAY) { if (Z_TYPE_P(viewParams) == IS_ARRAY) { ZEPHIR_INIT_VAR(mergedParams); zephir_fast_array_merge(mergedParams, &(viewParams), &(params) TSRMLS_CC); } else { ZEPHIR_CPY_WRT(mergedParams, params); } } else { ZEPHIR_CPY_WRT(mergedParams, viewParams); } ZEPHIR_CALL_METHOD(NULL, this_ptr, "_internalrender", NULL, 412, path, mergedParams); zephir_check_call_status(); if (Z_TYPE_P(cache) == IS_OBJECT) { ZEPHIR_CALL_METHOD(&_2$$12, cache, "isstarted", NULL, 0); zephir_check_call_status(); _3$$12 = zephir_is_true(_2$$12); if (_3$$12) { ZEPHIR_CALL_METHOD(&_4$$12, cache, "isfresh", NULL, 0); zephir_check_call_status(); _3$$12 = zephir_is_true(_4$$12); } if (_3$$12) { ZEPHIR_CALL_METHOD(NULL, cache, "save", NULL, 0); zephir_check_call_status(); } else { ZEPHIR_CALL_METHOD(NULL, cache, "stop", NULL, 0); zephir_check_call_status(); } } ZEPHIR_CALL_FUNCTION(NULL, "ob_end_clean", NULL, 136); zephir_check_call_status(); RETURN_MM_MEMBER(getThis(), "_content"); }
/** * The plural version of gettext(). * Some languages have more than one form for plural messages dependent on the count. */ PHP_METHOD(Phalcon_Translate_Adapter_Gettext, nquery) { zend_long 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 (UNEXPECTED(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 (EXPECTED(Z_TYPE_P(msgid1_param) == IS_STRING)) { zephir_get_strval(msgid1, msgid1_param); } else { ZEPHIR_INIT_VAR(msgid1); ZVAL_EMPTY_STRING(msgid1); } if (UNEXPECTED(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 (EXPECTED(Z_TYPE_P(msgid2_param) == IS_STRING)) { zephir_get_strval(msgid2, msgid2_param); } else { ZEPHIR_INIT_VAR(msgid2); ZVAL_EMPTY_STRING(msgid2); } if (UNEXPECTED(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 (UNEXPECTED(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 (EXPECTED(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, 470, 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, 471, 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(); }
/** * Matches a user submitted path with a previously defined route. * Assigns and returns an array of defaults on a successful match. * * @param string $path Path used to match against this routing map * @return array|false An array of assigned values or a false on a mismatch */ PHP_METHOD(Yaf_Route_Rewrite, route) { zephir_nts_static zephir_fcall_cache_entry *_3 = NULL, *_6 = NULL; zend_bool _0, _1; int ZEPHIR_LAST_CALL_STATUS; zval *request, *requestUri = NULL, *baseuri = NULL, *path = NULL, *values = NULL, *_2 = NULL, _4 = zval_used_for_init, *_5 = NULL, *_7, *_8, *_9, *_10; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &request); ZEPHIR_CALL_METHOD(&requestUri, request, "getrequesturi", NULL); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&baseuri, request, "getbaseuri", NULL); zephir_check_call_status(); _0 = !ZEPHIR_IS_STRING(requestUri, ""); if (_0) { _0 = !ZEPHIR_IS_STRING(baseuri, ""); } _1 = _0; if (_1) { ZEPHIR_CALL_FUNCTION(&_2, "stripos", &_3, requestUri, baseuri); zephir_check_call_status(); _1 = !ZEPHIR_IS_FALSE_IDENTICAL(_2); } if (_1) { ZEPHIR_SINIT_VAR(_4); ZVAL_LONG(&_4, zephir_fast_strlen_ev(baseuri)); ZEPHIR_INIT_VAR(path); zephir_substr(path, requestUri, zephir_get_intval(&_4), 0, ZEPHIR_SUBSTR_NO_LENGTH); } else { ZEPHIR_CPY_WRT(path, requestUri); } ZEPHIR_INIT_NVAR(path); ZEPHIR_CALL_FUNCTION(&_5, "urldecode", &_6, path); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_4); ZVAL_STRING(&_4, "/", 0); zephir_fast_trim(path, _5, &_4, ZEPHIR_TRIM_BOTH TSRMLS_CC); ZEPHIR_CALL_METHOD(&values, this_ptr, "_match", NULL, path); zephir_check_call_status(); if (Z_TYPE_P(values) == IS_NULL) { RETURN_MM_BOOL(0); } _7 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC); if (zephir_array_isset_string(_7, SS("module"))) { _8 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC); zephir_array_fetch_string(&_9, _8, SL("module"), PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 77 TSRMLS_CC); ZEPHIR_CALL_METHOD(NULL, request, "setmodulename", NULL, _9); zephir_check_call_status(); } _8 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC); if (zephir_array_isset_string(_8, SS("controller"))) { _10 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC); zephir_array_fetch_string(&_9, _10, SL("controller"), PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 81 TSRMLS_CC); ZEPHIR_CALL_METHOD(NULL, request, "setcontrollername", NULL, _9); zephir_check_call_status(); } _8 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC); if (zephir_array_isset_string(_8, SS("action"))) { _10 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC); zephir_array_fetch_string(&_9, _10, SL("action"), PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 85 TSRMLS_CC); ZEPHIR_CALL_METHOD(NULL, request, "setactionname", NULL, _9); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(NULL, request, "setparam", NULL, values); zephir_check_call_status(); RETURN_MM_BOOL(1); }
/** * Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php * * @return array */ PHP_METHOD(Phalcon_Mvc_View_Simple, _loadTemplateEngines) { HashTable *_2$$5; HashPosition _1$$5; zval *engines = NULL, *dependencyInjector = NULL, *registeredEngines = NULL, *arguments = NULL, *extension = NULL, *engineService = NULL, *engineObject = NULL, *_0$$4, **_3$$5, *_5$$13 = NULL, *_6$$13 = NULL; zephir_fcall_cache_entry *_4 = NULL, *_7 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); ZEPHIR_OBS_VAR(engines); zephir_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY_CC); if (ZEPHIR_IS_FALSE_IDENTICAL(engines)) { ZEPHIR_OBS_VAR(dependencyInjector); zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); ZEPHIR_INIT_NVAR(engines); array_init(engines); ZEPHIR_OBS_VAR(registeredEngines); zephir_read_property_this(®isteredEngines, this_ptr, SL("_registeredEngines"), PH_NOISY_CC); if (Z_TYPE_P(registeredEngines) != IS_ARRAY) { ZEPHIR_INIT_VAR(_0$$4); object_init_ex(_0$$4, phalcon_mvc_view_engine_php_ce); ZEPHIR_CALL_METHOD(NULL, _0$$4, "__construct", NULL, 391, this_ptr, dependencyInjector); zephir_check_call_status(); zephir_array_update_string(&engines, SL(".phtml"), &_0$$4, PH_COPY | PH_SEPARATE); } else { if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_view_exception_ce, "A dependency injector container is required to obtain the application services", "phalcon/mvc/view/simple.zep", 159); return; } ZEPHIR_INIT_VAR(arguments); zephir_create_array(arguments, 2, 0 TSRMLS_CC); zephir_array_fast_append(arguments, this_ptr); zephir_array_fast_append(arguments, dependencyInjector); zephir_is_iterable(registeredEngines, &_2$$5, &_1$$5, 0, 0, "phalcon/mvc/view/simple.zep", 191); for ( ; zend_hash_get_current_data_ex(_2$$5, (void**) &_3$$5, &_1$$5) == SUCCESS ; zend_hash_move_forward_ex(_2$$5, &_1$$5) ) { ZEPHIR_GET_HMKEY(extension, _2$$5, _1$$5); ZEPHIR_GET_HVALUE(engineService, _3$$5); if (Z_TYPE_P(engineService) == IS_OBJECT) { if (zephir_instance_of_ev(engineService, zend_ce_closure TSRMLS_CC)) { ZEPHIR_INIT_NVAR(engineObject); ZEPHIR_CALL_USER_FUNC_ARRAY(engineObject, engineService, arguments); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(engineObject, engineService); } } else { if (Z_TYPE_P(engineService) == IS_STRING) { ZEPHIR_CALL_METHOD(&engineObject, dependencyInjector, "getshared", &_4, 0, engineService, arguments); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(_5$$13); object_init_ex(_5$$13, phalcon_mvc_view_exception_ce); ZEPHIR_INIT_LNVAR(_6$$13); ZEPHIR_CONCAT_SV(_6$$13, "Invalid template engine registration for extension: ", extension); ZEPHIR_CALL_METHOD(NULL, _5$$13, "__construct", &_7, 9, _6$$13); zephir_check_call_status(); zephir_throw_exception_debug(_5$$13, "phalcon/mvc/view/simple.zep", 185 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } } zephir_array_update_zval(&engines, extension, &engineObject, PH_COPY | PH_SEPARATE); } } zephir_update_property_this(getThis(), SL("_engines"), engines TSRMLS_CC); } else { ZEPHIR_OBS_NVAR(engines); zephir_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY_CC); } RETURN_CCTOR(engines); }
/** * Changes the fetching mode affecting Phalcon\Db\Result\Pdo::fetch() * *<code> * //Return array with integer indexes * $result->setFetchMode(\Phalcon\Db::FETCH_NUM); * * //Return associative array without integer indexes * $result->setFetchMode(\Phalcon\Db::FETCH_ASSOC); * * //Return associative array together with integer indexes * $result->setFetchMode(\Phalcon\Db::FETCH_BOTH); * * //Return an object * $result->setFetchMode(\Phalcon\Db::FETCH_OBJ); *</code> */ PHP_METHOD(Phalcon_Db_Result_Pdo, setFetchMode) { zval *fetchMode_param = NULL, *colNoOrClassNameOrObject = NULL, *ctorargs = NULL, *pdoStatement = NULL, *_9 = NULL, *_10, *_0$$3 = NULL, *_1$$3, *_2$$4, *_3$$5 = NULL, *_4$$5, *_5$$6, *_6$$7 = NULL, *_7$$7, *_8$$8, *_11$$9; int fetchMode, ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 2, &fetchMode_param, &colNoOrClassNameOrObject, &ctorargs); fetchMode = zephir_get_intval(fetchMode_param); if (!colNoOrClassNameOrObject) { colNoOrClassNameOrObject = ZEPHIR_GLOBAL(global_null); } if (!ctorargs) { ctorargs = ZEPHIR_GLOBAL(global_null); } ZEPHIR_OBS_VAR(pdoStatement); zephir_read_property_this(&pdoStatement, this_ptr, SL("_pdoStatement"), PH_NOISY_CC); if (fetchMode == 8) { ZEPHIR_INIT_VAR(_1$$3); ZVAL_LONG(_1$$3, fetchMode); ZEPHIR_CALL_METHOD(&_0$$3, pdoStatement, "setfetchmode", NULL, 0, _1$$3, colNoOrClassNameOrObject, ctorargs); zephir_check_call_status(); if (zephir_is_true(_0$$3)) { ZEPHIR_INIT_ZVAL_NREF(_2$$4); ZVAL_LONG(_2$$4, fetchMode); zephir_update_property_this(this_ptr, SL("_fetchMode"), _2$$4 TSRMLS_CC); RETURN_MM_BOOL(1); } RETURN_MM_BOOL(0); } if (fetchMode == 9) { ZEPHIR_INIT_VAR(_4$$5); ZVAL_LONG(_4$$5, fetchMode); ZEPHIR_CALL_METHOD(&_3$$5, pdoStatement, "setfetchmode", NULL, 0, _4$$5, colNoOrClassNameOrObject); zephir_check_call_status(); if (zephir_is_true(_3$$5)) { ZEPHIR_INIT_ZVAL_NREF(_5$$6); ZVAL_LONG(_5$$6, fetchMode); zephir_update_property_this(this_ptr, SL("_fetchMode"), _5$$6 TSRMLS_CC); RETURN_MM_BOOL(1); } RETURN_MM_BOOL(0); } if (fetchMode == 7) { ZEPHIR_INIT_VAR(_7$$7); ZVAL_LONG(_7$$7, fetchMode); ZEPHIR_CALL_METHOD(&_6$$7, pdoStatement, "setfetchmode", NULL, 0, _7$$7, colNoOrClassNameOrObject); zephir_check_call_status(); if (zephir_is_true(_6$$7)) { ZEPHIR_INIT_ZVAL_NREF(_8$$8); ZVAL_LONG(_8$$8, fetchMode); zephir_update_property_this(this_ptr, SL("_fetchMode"), _8$$8 TSRMLS_CC); RETURN_MM_BOOL(1); } RETURN_MM_BOOL(0); } ZEPHIR_INIT_VAR(_10); ZVAL_LONG(_10, fetchMode); ZEPHIR_CALL_METHOD(&_9, pdoStatement, "setfetchmode", NULL, 0, _10); zephir_check_call_status(); if (zephir_is_true(_9)) { ZEPHIR_INIT_ZVAL_NREF(_11$$9); ZVAL_LONG(_11$$9, fetchMode); zephir_update_property_this(this_ptr, SL("_fetchMode"), _11$$9 TSRMLS_CC); RETURN_MM_BOOL(1); } RETURN_MM_BOOL(0); }
/** * Reconfigure the route adding a new pattern and a set of paths * * @param string pattern * @param array paths */ PHP_METHOD(Test_Router_Route, reConfigure) { int _0, ZEPHIR_LAST_CALL_STATUS; zval *pattern, *paths = NULL, *moduleName = NULL, *controllerName = NULL, *actionName = NULL, *parts, *routePaths = NULL, *realClassName = NULL, *namespaceName, *pcrePattern = NULL, *compiledPattern = NULL, *extracted = NULL, *_1 = NULL, *_2; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &pattern, &paths); if (!paths) { paths = ZEPHIR_GLOBAL(global_null); } if (Z_TYPE_P(pattern) != IS_STRING) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(test_router_exception_ce, "The pattern must be string", "test/router/route.zep", 270); return; } if (Z_TYPE_P(paths) != IS_NULL) { if (Z_TYPE_P(paths) == IS_STRING) { ZEPHIR_INIT_VAR(moduleName); ZVAL_NULL(moduleName); ZEPHIR_INIT_VAR(controllerName); ZVAL_NULL(controllerName); ZEPHIR_INIT_VAR(actionName); ZVAL_NULL(actionName); ZEPHIR_INIT_VAR(parts); zephir_fast_explode_str(parts, SL("::"), paths, LONG_MAX TSRMLS_CC); do { _0 = zephir_fast_count_int(parts TSRMLS_CC); if (_0 == 3) { ZEPHIR_OBS_NVAR(moduleName); zephir_array_fetch_long(&moduleName, parts, 0, PH_NOISY, "test/router/route.zep", 286 TSRMLS_CC); ZEPHIR_OBS_NVAR(controllerName); zephir_array_fetch_long(&controllerName, parts, 1, PH_NOISY, "test/router/route.zep", 287 TSRMLS_CC); ZEPHIR_OBS_NVAR(actionName); zephir_array_fetch_long(&actionName, parts, 2, PH_NOISY, "test/router/route.zep", 288 TSRMLS_CC); break; } if (_0 == 2) { ZEPHIR_OBS_NVAR(controllerName); zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "test/router/route.zep", 291 TSRMLS_CC); ZEPHIR_OBS_NVAR(actionName); zephir_array_fetch_long(&actionName, parts, 1, PH_NOISY, "test/router/route.zep", 292 TSRMLS_CC); break; } if (_0 == 1) { ZEPHIR_OBS_NVAR(controllerName); zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "test/router/route.zep", 295 TSRMLS_CC); break; } } while(0); ZEPHIR_INIT_VAR(routePaths); array_init(routePaths); if (Z_TYPE_P(moduleName) != IS_NULL) { zephir_array_update_string(&routePaths, SL("module"), &moduleName, PH_COPY | PH_SEPARATE); } if (Z_TYPE_P(controllerName) != IS_NULL) { if (zephir_memnstr_str(controllerName, SL("\\"), "test/router/route.zep", 310)) { ZEPHIR_INIT_VAR(realClassName); zephir_get_class_ns(realClassName, controllerName, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(namespaceName); zephir_get_ns_class(namespaceName, controllerName, 0 TSRMLS_CC); if (zephir_is_true(namespaceName)) { zephir_array_update_string(&routePaths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE); } } else { ZEPHIR_CPY_WRT(realClassName, controllerName); } ZEPHIR_INIT_VAR(_1); zephir_uncamelize(_1, realClassName); zephir_array_update_string(&routePaths, SL("controller"), &_1, PH_COPY | PH_SEPARATE); } if (Z_TYPE_P(actionName) != IS_NULL) { zephir_array_update_string(&routePaths, SL("action"), &actionName, PH_COPY | PH_SEPARATE); } } else { ZEPHIR_CPY_WRT(routePaths, paths); } } else { ZEPHIR_INIT_NVAR(routePaths); array_init(routePaths); } if (Z_TYPE_P(routePaths) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(test_router_exception_ce, "The route contains invalid paths", "test/router/route.zep", 342); return; } if (!(zephir_start_with_str(pattern, SL("#")))) { if (zephir_memnstr_str(pattern, SL("{"), "test/router/route.zep", 348)) { ZEPHIR_CALL_METHOD(&extracted, this_ptr, "extractnamedparams", NULL, pattern); zephir_check_call_status(); ZEPHIR_OBS_VAR(pcrePattern); zephir_array_fetch_long(&pcrePattern, extracted, 0, PH_NOISY, "test/router/route.zep", 351 TSRMLS_CC); ZEPHIR_INIT_NVAR(_1); zephir_array_fetch_long(&_2, extracted, 1, PH_NOISY | PH_READONLY, "test/router/route.zep", 352 TSRMLS_CC); zephir_fast_array_merge(_1, &(routePaths), &(_2) TSRMLS_CC); ZEPHIR_CPY_WRT(routePaths, _1); } else { ZEPHIR_CPY_WRT(pcrePattern, pattern); } ZEPHIR_CALL_METHOD(&compiledPattern, this_ptr, "compilepattern", NULL, pcrePattern); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(compiledPattern, pattern); } zephir_update_property_this(this_ptr, SL("_pattern"), pattern TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_compiledPattern"), compiledPattern TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_paths"), routePaths TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Generates random text in accordance with the template * * <code> * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Bob * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Jon * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hello my name is a Bob * </code> */ PHP_METHOD(Phalcon_Text, dynamic) { int ZEPHIR_LAST_CALL_STATUS; zephir_fcall_cache_entry *_1 = NULL, *_5 = NULL, *_8 = NULL; zval *text_param = NULL, *leftDelimiter_param = NULL, *rightDelimiter_param = NULL, *separator_param = NULL, *ldS = NULL, *rdS = NULL, *result = NULL, *pattern = NULL, *_0 = NULL, *_2 = NULL, *_3$$3, *_6$$4 = NULL, *_7$$4 = NULL; zval *text = NULL, *leftDelimiter = NULL, *rightDelimiter = NULL, *separator = NULL, *_4$$3; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 3, &text_param, &leftDelimiter_param, &rightDelimiter_param, &separator_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 (!leftDelimiter_param) { ZEPHIR_INIT_VAR(leftDelimiter); ZVAL_STRING(leftDelimiter, "{", 1); } else { if (unlikely(Z_TYPE_P(leftDelimiter_param) != IS_STRING && Z_TYPE_P(leftDelimiter_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'leftDelimiter' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(leftDelimiter_param) == IS_STRING)) { zephir_get_strval(leftDelimiter, leftDelimiter_param); } else { ZEPHIR_INIT_VAR(leftDelimiter); ZVAL_EMPTY_STRING(leftDelimiter); } } if (!rightDelimiter_param) { ZEPHIR_INIT_VAR(rightDelimiter); ZVAL_STRING(rightDelimiter, "}", 1); } else { if (unlikely(Z_TYPE_P(rightDelimiter_param) != IS_STRING && Z_TYPE_P(rightDelimiter_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'rightDelimiter' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(rightDelimiter_param) == IS_STRING)) { zephir_get_strval(rightDelimiter, rightDelimiter_param); } else { ZEPHIR_INIT_VAR(rightDelimiter); ZVAL_EMPTY_STRING(rightDelimiter); } } if (!separator_param) { ZEPHIR_INIT_VAR(separator); ZVAL_STRING(separator, "|", 1); } else { if (unlikely(Z_TYPE_P(separator_param) != IS_STRING && Z_TYPE_P(separator_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'separator' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(separator_param) == IS_STRING)) { zephir_get_strval(separator, separator_param); } else { ZEPHIR_INIT_VAR(separator); ZVAL_EMPTY_STRING(separator); } } ZEPHIR_CALL_FUNCTION(&_0, "substr_count", &_1, 420, text, leftDelimiter); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_2, "substr_count", &_1, 420, text, rightDelimiter); zephir_check_call_status(); if (!ZEPHIR_IS_IDENTICAL(_0, _2)) { ZEPHIR_INIT_VAR(_3$$3); object_init_ex(_3$$3, spl_ce_RuntimeException); ZEPHIR_INIT_VAR(_4$$3); ZEPHIR_CONCAT_SVS(_4$$3, "Syntax error in string \"", text, "\""); ZEPHIR_CALL_METHOD(NULL, _3$$3, "__construct", NULL, 421, _4$$3); zephir_check_call_status(); zephir_throw_exception_debug(_3$$3, "phalcon/text.zep", 261 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_CALL_FUNCTION(&ldS, "preg_quote", &_5, 422, leftDelimiter); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&rdS, "preg_quote", &_5, 422, rightDelimiter); zephir_check_call_status(); ZEPHIR_INIT_VAR(pattern); ZEPHIR_CONCAT_SVSVVSVS(pattern, "/", ldS, "([^", ldS, rdS, "]+)", rdS, "/"); ZEPHIR_CPY_WRT(result, text); while (1) { if (!(zephir_memnstr(result, leftDelimiter, "phalcon/text.zep", 269))) { break; } ZEPHIR_INIT_NVAR(_6$$4); ZEPHIR_INIT_NVAR(_6$$4); zephir_create_closure_ex(_6$$4, NULL, phalcon_0__closure_ce, SS("__invoke") TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&_7$$4, "preg_replace_callback", &_8, 423, pattern, _6$$4, result); zephir_check_call_status(); ZEPHIR_CPY_WRT(result, _7$$4); } RETURN_CCTOR(result); }
/** * Executes the validation */ PHP_METHOD(Phalcon_Validation_Validator_Callback, validate) { zend_bool _1$$3; zend_long ZEPHIR_LAST_CALL_STATUS; zval *field = NULL; zval *validation, *field_param = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *code = NULL, *callback = NULL, *returnedValue = NULL, *data = NULL, *_0, *_2$$6 = NULL, *_3$$6 = NULL, *_4$$6; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &validation, &field_param); if (UNEXPECTED(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(field_param) == IS_STRING)) { zephir_get_strval(field, field_param); } else { ZEPHIR_INIT_VAR(field); ZVAL_EMPTY_STRING(field); } ZEPHIR_INIT_VAR(_0); ZVAL_STRING(_0, "callback", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&callback, this_ptr, "getoption", NULL, 0, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (zephir_is_callable(callback TSRMLS_CC)) { ZEPHIR_CALL_METHOD(&data, validation, "getentity", NULL, 0); zephir_check_call_status(); if (ZEPHIR_IS_EMPTY(data)) { ZEPHIR_CALL_METHOD(&data, validation, "getdata", NULL, 0); zephir_check_call_status(); } ZEPHIR_CALL_FUNCTION(&returnedValue, "call_user_func", NULL, 403, callback, data); zephir_check_call_status(); _1$$3 = Z_TYPE_P(returnedValue) == IS_OBJECT; if (_1$$3) { _1$$3 = zephir_instance_of_ev(returnedValue, phalcon_validation_validator_ce TSRMLS_CC); } if (Z_TYPE_P(returnedValue) == IS_BOOL) { if (!(zephir_is_true(returnedValue))) { ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field); zephir_check_call_status(); ZEPHIR_INIT_VAR(_2$$6); ZVAL_STRING(_2$$6, "Callback", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _2$$6); zephir_check_temp_parameter(_2$$6); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&code, this_ptr, "preparecode", NULL, 0, field); zephir_check_call_status(); ZEPHIR_INIT_VAR(replacePairs); zephir_create_array(replacePairs, 1, 0 TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2$$6); object_init_ex(_2$$6, phalcon_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_3$$6, "strtr", NULL, 27, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_VAR(_4$$6); ZVAL_STRING(_4$$6, "Callback", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _2$$6, "__construct", NULL, 470, _3$$6, field, _4$$6, code); zephir_check_temp_parameter(_4$$6); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _2$$6); zephir_check_call_status(); RETURN_MM_BOOL(0); } RETURN_MM_BOOL(1); } else if (_1$$3) { ZEPHIR_RETURN_CALL_METHOD(returnedValue, "validate", NULL, 0, validation, field); zephir_check_call_status(); RETURN_MM(); } ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_validator_exception_ce, "Callback must return boolean or Phalcon\\Validation\\Validator object", "phalcon/validation/validator/callback.zep", 114); return; } RETURN_MM_BOOL(1); }
/** * Executes the validation */ PHP_METHOD(Phalcon_Validation_Validator_StringLength, validate) { zend_bool _1, _3; zephir_fcall_cache_entry *_8 = NULL, *_10 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *field = NULL; zval *validation, *field_param = NULL, *isSetMin = NULL, *isSetMax = NULL, *value = NULL, *length = NULL, *message = NULL, *minimum = NULL, *maximum = NULL, *label = NULL, *replacePairs = NULL, *_0 = NULL, *_2 = NULL, *_4$$8, *_5$$9 = NULL, *_7$$9 = NULL, *_9$$9, *_6$$10, *_11$$11, *_12$$12 = NULL, *_14$$12 = NULL, *_15$$12, *_13$$13; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &validation, &field_param); if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(field_param) == IS_STRING)) { zephir_get_strval(field, field_param); } else { ZEPHIR_INIT_VAR(field); ZVAL_EMPTY_STRING(field); } ZEPHIR_INIT_VAR(_0); ZVAL_STRING(_0, "min", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&isSetMin, this_ptr, "issetoption", NULL, 0, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "max", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&isSetMax, this_ptr, "issetoption", NULL, 0, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); _1 = !zephir_is_true(isSetMin); if (_1) { _1 = !zephir_is_true(isSetMax); } if (_1) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "A minimum or maximum must be set", "phalcon/validation/validator/stringlength.zep", 62); return; } ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_2, this_ptr, "issetoption", NULL, 0, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); _3 = zephir_is_true(_2); if (_3) { _3 = ZEPHIR_IS_EMPTY(value); } if (_3) { RETURN_MM_BOOL(1); } ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "label", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (ZEPHIR_IS_EMPTY(label)) { ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field); zephir_check_call_status(); } if ((zephir_function_exists_ex(SS("mb_strlen") TSRMLS_CC) == SUCCESS)) { ZEPHIR_CALL_FUNCTION(&length, "mb_strlen", NULL, 357, value); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(length); ZVAL_LONG(length, zephir_fast_strlen_ev(value)); } if (zephir_is_true(isSetMax)) { ZEPHIR_INIT_VAR(_4$$8); ZVAL_STRING(_4$$8, "max", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&maximum, this_ptr, "getoption", NULL, 0, _4$$8); zephir_check_temp_parameter(_4$$8); zephir_check_call_status(); if (ZEPHIR_GT(length, maximum)) { ZEPHIR_INIT_VAR(_5$$9); ZVAL_STRING(_5$$9, "messageMaximum", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _5$$9); zephir_check_temp_parameter(_5$$9); zephir_check_call_status(); ZEPHIR_INIT_VAR(replacePairs); zephir_create_array(replacePairs, 2, 0 TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE); zephir_array_update_string(&replacePairs, SL(":max"), &maximum, PH_COPY | PH_SEPARATE); if (ZEPHIR_IS_EMPTY(message)) { ZEPHIR_INIT_VAR(_6$$10); ZVAL_STRING(_6$$10, "TooLong", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _6$$10); zephir_check_temp_parameter(_6$$10); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_5$$9); object_init_ex(_5$$9, phalcon_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_7$$9, "strtr", &_8, 55, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_VAR(_9$$9); ZVAL_STRING(_9$$9, "TooLong", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _5$$9, "__construct", &_10, 435, _7$$9, field, _9$$9); zephir_check_temp_parameter(_9$$9); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _5$$9); zephir_check_call_status(); RETURN_MM_BOOL(0); } } if (zephir_is_true(isSetMin)) { ZEPHIR_INIT_VAR(_11$$11); ZVAL_STRING(_11$$11, "min", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&minimum, this_ptr, "getoption", NULL, 0, _11$$11); zephir_check_temp_parameter(_11$$11); zephir_check_call_status(); if (ZEPHIR_LT(length, minimum)) { ZEPHIR_INIT_VAR(_12$$12); ZVAL_STRING(_12$$12, "messageMinimum", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _12$$12); zephir_check_temp_parameter(_12$$12); zephir_check_call_status(); ZEPHIR_INIT_NVAR(replacePairs); zephir_create_array(replacePairs, 2, 0 TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE); zephir_array_update_string(&replacePairs, SL(":min"), &minimum, PH_COPY | PH_SEPARATE); if (ZEPHIR_IS_EMPTY(message)) { ZEPHIR_INIT_VAR(_13$$13); ZVAL_STRING(_13$$13, "TooShort", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _13$$13); zephir_check_temp_parameter(_13$$13); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_12$$12); object_init_ex(_12$$12, phalcon_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_14$$12, "strtr", &_8, 55, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_VAR(_15$$12); ZVAL_STRING(_15$$12, "TooShort", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _12$$12, "__construct", &_10, 435, _14$$12, field, _15$$12); zephir_check_temp_parameter(_15$$12); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _12$$12); zephir_check_call_status(); RETURN_MM_BOOL(0); } } RETURN_MM_BOOL(1); }
/** * Generates a random string based on the given type. Type is one of the RANDOM_* constants * * <code> * echo Phalcon\Text::random(Phalcon\Text::RANDOM_ALNUM); //"aloiwkqz" * </code> */ PHP_METHOD(Phalcon_Text, random) { zephir_fcall_cache_entry *_3 = NULL, *_18 = NULL; long length; zval *type_param = NULL, *length_param = NULL, *pool = NULL, *str = NULL, _0$$3 = zval_used_for_init, _1$$3 = zval_used_for_init, *_2$$3 = NULL, *_4$$3 = NULL, _5$$4 = zval_used_for_init, _6$$4 = zval_used_for_init, *_7$$4 = NULL, *_8$$4 = NULL, _9$$5, _10$$5, _11$$6, _12$$6, _13$$7 = zval_used_for_init, _14$$7 = zval_used_for_init, *_15$$7 = NULL, *_16$$7 = NULL, *_17$$7 = NULL, *_19$$8, _20$$8 = zval_used_for_init, _21$$8 = zval_used_for_init; int type, ZEPHIR_LAST_CALL_STATUS, end = 0; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 2, &type_param, &length_param); if (!type_param) { type = 0; } else { type = zephir_get_intval(type_param); } if (!length_param) { length = 8; } else { length = zephir_get_intval(length_param); } ZEPHIR_INIT_VAR(str); ZVAL_STRING(str, "", 1); do { if (type == 1) { ZEPHIR_SINIT_VAR(_0$$3); ZVAL_STRING(&_0$$3, "a", 0); ZEPHIR_SINIT_VAR(_1$$3); ZVAL_STRING(&_1$$3, "z", 0); ZEPHIR_CALL_FUNCTION(&_2$$3, "range", &_3, 416, &_0$$3, &_1$$3); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_0$$3); ZVAL_STRING(&_0$$3, "A", 0); ZEPHIR_SINIT_NVAR(_1$$3); ZVAL_STRING(&_1$$3, "Z", 0); ZEPHIR_CALL_FUNCTION(&_4$$3, "range", &_3, 416, &_0$$3, &_1$$3); zephir_check_call_status(); ZEPHIR_INIT_VAR(pool); zephir_fast_array_merge(pool, &(_2$$3), &(_4$$3) TSRMLS_CC); break; } if (type == 2) { ZEPHIR_SINIT_VAR(_5$$4); ZVAL_LONG(&_5$$4, 0); ZEPHIR_SINIT_VAR(_6$$4); ZVAL_LONG(&_6$$4, 9); ZEPHIR_CALL_FUNCTION(&_7$$4, "range", &_3, 416, &_5$$4, &_6$$4); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_5$$4); ZVAL_STRING(&_5$$4, "a", 0); ZEPHIR_SINIT_NVAR(_6$$4); ZVAL_STRING(&_6$$4, "f", 0); ZEPHIR_CALL_FUNCTION(&_8$$4, "range", &_3, 416, &_5$$4, &_6$$4); zephir_check_call_status(); ZEPHIR_INIT_NVAR(pool); zephir_fast_array_merge(pool, &(_7$$4), &(_8$$4) TSRMLS_CC); break; } if (type == 3) { ZEPHIR_SINIT_VAR(_9$$5); ZVAL_LONG(&_9$$5, 0); ZEPHIR_SINIT_VAR(_10$$5); ZVAL_LONG(&_10$$5, 9); ZEPHIR_CALL_FUNCTION(&pool, "range", &_3, 416, &_9$$5, &_10$$5); zephir_check_call_status(); break; } if (type == 4) { ZEPHIR_SINIT_VAR(_11$$6); ZVAL_LONG(&_11$$6, 1); ZEPHIR_SINIT_VAR(_12$$6); ZVAL_LONG(&_12$$6, 9); ZEPHIR_CALL_FUNCTION(&pool, "range", &_3, 416, &_11$$6, &_12$$6); zephir_check_call_status(); break; } ZEPHIR_SINIT_VAR(_13$$7); ZVAL_LONG(&_13$$7, 0); ZEPHIR_SINIT_VAR(_14$$7); ZVAL_LONG(&_14$$7, 9); ZEPHIR_CALL_FUNCTION(&_15$$7, "range", &_3, 416, &_13$$7, &_14$$7); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_13$$7); ZVAL_STRING(&_13$$7, "a", 0); ZEPHIR_SINIT_NVAR(_14$$7); ZVAL_STRING(&_14$$7, "z", 0); ZEPHIR_CALL_FUNCTION(&_16$$7, "range", &_3, 416, &_13$$7, &_14$$7); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_13$$7); ZVAL_STRING(&_13$$7, "A", 0); ZEPHIR_SINIT_NVAR(_14$$7); ZVAL_STRING(&_14$$7, "Z", 0); ZEPHIR_CALL_FUNCTION(&_17$$7, "range", &_3, 416, &_13$$7, &_14$$7); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&pool, "array_merge", &_18, 417, _15$$7, _16$$7, _17$$7); zephir_check_call_status(); break; } while(0); end = (zephir_fast_count_int(pool TSRMLS_CC) - 1); while (1) { if (!(zephir_fast_strlen_ev(str) < length)) { break; } ZEPHIR_SINIT_NVAR(_20$$8); ZVAL_LONG(&_20$$8, 0); ZEPHIR_SINIT_NVAR(_21$$8); ZVAL_LONG(&_21$$8, end); zephir_array_fetch_long(&_19$$8, pool, zephir_mt_rand(zephir_get_intval(&_20$$8), zephir_get_intval(&_21$$8) TSRMLS_CC), PH_NOISY | PH_READONLY, "phalcon/text.zep", 126 TSRMLS_CC); zephir_concat_self(&str, _19$$8 TSRMLS_CC); } RETURN_CCTOR(str); }
/** * Logs messages to the internal logger. Appends logs to the logger */ PHP_METHOD(Phalcon_Logger_Adapter, log) { zend_bool _0, _1$$4; zend_long ZEPHIR_LAST_CALL_STATUS; zval *context = NULL; zval *type, *message = NULL, *context_param = NULL, *timestamp = NULL, *toggledMessage = NULL, *toggledType = NULL, *_2, *_3$$8, *_4$$9; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 2, &type, &message, &context_param); if (!message) { message = ZEPHIR_GLOBAL(global_null); } if (!context_param) { ZEPHIR_INIT_VAR(context); array_init(context); } else { context = context_param; } _0 = Z_TYPE_P(type) == IS_STRING; if (_0) { _0 = Z_TYPE_P(message) == IS_LONG; } if (_0) { ZEPHIR_CPY_WRT(toggledMessage, type); ZEPHIR_CPY_WRT(toggledType, message); } else { _1$$4 = Z_TYPE_P(type) == IS_STRING; if (_1$$4) { _1$$4 = Z_TYPE_P(message) == IS_NULL; } if (_1$$4) { ZEPHIR_CPY_WRT(toggledMessage, type); ZEPHIR_CPY_WRT(toggledType, message); } else { ZEPHIR_CPY_WRT(toggledMessage, message); ZEPHIR_CPY_WRT(toggledType, type); } } if (Z_TYPE_P(toggledType) == IS_NULL) { ZEPHIR_INIT_NVAR(toggledType); ZVAL_LONG(toggledType, 7); } _2 = zephir_fetch_nproperty_this(this_ptr, SL("_logLevel"), PH_NOISY_CC); if (ZEPHIR_GE(_2, toggledType)) { ZEPHIR_INIT_VAR(timestamp); zephir_time(timestamp); _3$$8 = zephir_fetch_nproperty_this(this_ptr, SL("_transaction"), PH_NOISY_CC); if (zephir_is_true(_3$$8)) { ZEPHIR_INIT_VAR(_4$$9); object_init_ex(_4$$9, phalcon_logger_item_ce); ZEPHIR_CALL_METHOD(NULL, _4$$9, "__construct", NULL, 23, toggledMessage, toggledType, timestamp, context); zephir_check_call_status(); zephir_update_property_array_append(this_ptr, SL("_queue"), _4$$9 TSRMLS_CC); } else { ZEPHIR_CALL_METHOD(NULL, this_ptr, "loginternal", NULL, 0, toggledMessage, toggledType, timestamp, context); zephir_check_call_status(); } } RETURN_THIS(); }
/** * 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, 176); 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, 463, _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, 463, _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, 463, _9); zephir_check_call_status(); _10 = zephir_fetch_nproperty_this(this_ptr, SL("_locale"), PH_NOISY_CC); ZEPHIR_SINIT_VAR(_11); ZVAL_LONG(&_11, 6); ZEPHIR_CALL_FUNCTION(NULL, "setlocale", NULL, 442, &_11, _10); zephir_check_call_status(); RETURN_MM_MEMBER(this_ptr, "_locale"); }
/** * Gets the column name in PostgreSQL */ PHP_METHOD(Phalcon_Db_Dialect_Postgresql, getColumnDefinition) { zephir_nts_static zephir_fcall_cache_entry *_6 = NULL; HashTable *_3; HashPosition _2; int ZEPHIR_LAST_CALL_STATUS; zval *column, *size = NULL, *columnType = NULL, *columnSql, *typeValues = NULL, *_0 = NULL, *_1 = NULL, *value = NULL, *valueSql, **_4, _5 = zval_used_for_init, _7 = zval_used_for_init, *_8, *_9 = NULL, *_10 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &column); ZEPHIR_CALL_METHOD(&size, column, "getsize", NULL); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&columnType, column, "gettype", NULL); zephir_check_call_status(); ZEPHIR_INIT_VAR(columnSql); ZVAL_STRING(columnSql, "", 1); if (Z_TYPE_P(columnType) == IS_STRING) { zephir_concat_self(&columnSql, columnType TSRMLS_CC); ZEPHIR_CALL_METHOD(&columnType, column, "gettypereference", NULL); zephir_check_call_status(); } do { if (ZEPHIR_IS_LONG(columnType, 0)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("INT") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(columnType, 1)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("DATE") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(columnType, 2)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("CHARACTER VARYING") TSRMLS_CC); } ZEPHIR_INIT_VAR(_0); ZEPHIR_CONCAT_SVS(_0, "(", size, ")"); zephir_concat_self(&columnSql, _0 TSRMLS_CC); break; } if (ZEPHIR_IS_LONG(columnType, 3)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("NUMERIC") TSRMLS_CC); } ZEPHIR_CALL_METHOD(&_1, column, "getscale", NULL); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_0); ZEPHIR_CONCAT_SVSVS(_0, "(", size, ",", _1, ")"); zephir_concat_self(&columnSql, _0 TSRMLS_CC); break; } if (ZEPHIR_IS_LONG(columnType, 4)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("TIMESTAMP") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(columnType, 5)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("CHARACTER") TSRMLS_CC); } ZEPHIR_INIT_LNVAR(_0); ZEPHIR_CONCAT_SVS(_0, "(", size, ")"); zephir_concat_self(&columnSql, _0 TSRMLS_CC); break; } if (ZEPHIR_IS_LONG(columnType, 6)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("TEXT") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(columnType, 7)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("FLOAT") TSRMLS_CC); } break; } if (ZEPHIR_IS_LONG(columnType, 8)) { if (ZEPHIR_IS_EMPTY(columnSql)) { zephir_concat_self_str(&columnSql, SL("SMALLINT(1)") TSRMLS_CC); } break; } if (ZEPHIR_IS_EMPTY(columnSql)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Unrecognized PostgreSQL data type", "phalcon/db/dialect/postgresql.zep", 116); return; } ZEPHIR_CALL_METHOD(&typeValues, column, "gettypevalues", NULL); zephir_check_call_status(); if (!(ZEPHIR_IS_EMPTY(typeValues))) { if (Z_TYPE_P(typeValues) == IS_ARRAY) { ZEPHIR_INIT_VAR(valueSql); ZVAL_STRING(valueSql, "", 1); zephir_is_iterable(typeValues, &_3, &_2, 0, 0, "phalcon/db/dialect/postgresql.zep", 127); for ( ; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS ; zephir_hash_move_forward_ex(_3, &_2) ) { ZEPHIR_GET_HVALUE(value, _4); ZEPHIR_SINIT_NVAR(_5); ZVAL_STRING(&_5, "\"", 0); ZEPHIR_CALL_FUNCTION(&_1, "addcslashes", &_6, value, &_5); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_0); ZEPHIR_CONCAT_SVS(_0, "\"", _1, "\", "); zephir_concat_self(&valueSql, _0 TSRMLS_CC); } ZEPHIR_SINIT_NVAR(_5); ZVAL_LONG(&_5, 0); ZEPHIR_SINIT_VAR(_7); ZVAL_LONG(&_7, -2); ZEPHIR_INIT_VAR(_8); zephir_substr(_8, valueSql, 0 , -2 , 0); ZEPHIR_INIT_VAR(_9); ZEPHIR_CONCAT_SVS(_9, "(", _8, ")"); zephir_concat_self(&columnSql, _9 TSRMLS_CC); } else { ZEPHIR_SINIT_NVAR(_7); ZVAL_STRING(&_7, "\"", 0); ZEPHIR_CALL_FUNCTION(&_10, "addcslashes", &_6, typeValues, &_7); zephir_check_call_status(); ZEPHIR_INIT_LNVAR(_9); ZEPHIR_CONCAT_SVS(_9, "(\"", _10, "\")"); zephir_concat_self(&columnSql, _9 TSRMLS_CC); } } } while(0); RETURN_CCTOR(columnSql); }
/** * Changes the fetching mode affecting Phalcon\Db\Result\Pdo::fetch() * *<code> * //Return array with integer indexes * $result->setFetchMode(Phalcon\Db::FETCH_NUM); * * //Return associative array without integer indexes * $result->setFetchMode(Phalcon\Db::FETCH_ASSOC); * * //Return associative array together with integer indexes * $result->setFetchMode(Phalcon\Db::FETCH_BOTH); * * //Return an object * $result->setFetchMode(Phalcon\Db::FETCH_OBJ); *</code> */ PHP_METHOD(Phalcon_Db_Result_Pdo, setFetchMode) { zval *fetchMode_param = NULL, *colNoOrClassNameOrObject = NULL, *ctorargs = NULL, *pdoStatement, *_0 = NULL, *_1 = NULL, *_2; int fetchMode, ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 2, &fetchMode_param, &colNoOrClassNameOrObject, &ctorargs); fetchMode = zephir_get_intval(fetchMode_param); if (!colNoOrClassNameOrObject) { colNoOrClassNameOrObject = ZEPHIR_GLOBAL(global_null); } if (!ctorargs) { ctorargs = ZEPHIR_GLOBAL(global_null); } ZEPHIR_OBS_VAR(pdoStatement); zephir_read_property_this(&pdoStatement, this_ptr, SL("_pdoStatement"), PH_NOISY_CC); if (((fetchMode & 7)) == 7) { ZEPHIR_INIT_VAR(_1); ZVAL_LONG(_1, fetchMode); ZEPHIR_CALL_METHOD(&_0, pdoStatement, "setfetchmode", NULL, 0, _1, colNoOrClassNameOrObject); zephir_check_call_status(); if (zephir_is_true(_0)) { ZEPHIR_INIT_ZVAL_NREF(_2); ZVAL_LONG(_2, fetchMode); zephir_update_property_this(this_ptr, SL("_fetchMode"), _2 TSRMLS_CC); RETURN_MM_BOOL(1); } RETURN_MM_BOOL(0); } if (((fetchMode & 8)) == 8) { ZEPHIR_INIT_NVAR(_1); ZVAL_LONG(_1, fetchMode); ZEPHIR_CALL_METHOD(&_0, pdoStatement, "setfetchmode", NULL, 0, _1, colNoOrClassNameOrObject, ctorargs); zephir_check_call_status(); if (zephir_is_true(_0)) { ZEPHIR_INIT_ZVAL_NREF(_2); ZVAL_LONG(_2, fetchMode); zephir_update_property_this(this_ptr, SL("_fetchMode"), _2 TSRMLS_CC); RETURN_MM_BOOL(1); } RETURN_MM_BOOL(0); } if (((fetchMode & 9)) == 9) { ZEPHIR_INIT_NVAR(_1); ZVAL_LONG(_1, fetchMode); ZEPHIR_CALL_METHOD(&_0, pdoStatement, "setfetchmode", NULL, 0, _1, colNoOrClassNameOrObject); zephir_check_call_status(); if (zephir_is_true(_0)) { ZEPHIR_INIT_ZVAL_NREF(_2); ZVAL_LONG(_2, fetchMode); zephir_update_property_this(this_ptr, SL("_fetchMode"), _2 TSRMLS_CC); RETURN_MM_BOOL(1); } RETURN_MM_BOOL(0); } ZEPHIR_INIT_NVAR(_1); ZVAL_LONG(_1, fetchMode); ZEPHIR_CALL_METHOD(&_0, pdoStatement, "setfetchmode", NULL, 0, _1); zephir_check_call_status(); if (zephir_is_true(_0)) { ZEPHIR_INIT_ZVAL_NREF(_2); ZVAL_LONG(_2, fetchMode); zephir_update_property_this(this_ptr, SL("_fetchMode"), _2 TSRMLS_CC); RETURN_MM_BOOL(1); } RETURN_MM_BOOL(0); }
/** * Handles routing information received from command-line arguments * * @param array arguments */ PHP_METHOD(Phalcon_Cli_Router, handle) { zval *_16 = NULL; zval *_6 = NULL, *_11 = NULL; zephir_nts_static zephir_fcall_cache_entry *_5 = NULL, *_19 = NULL; int ZEPHIR_LAST_CALL_STATUS; HashTable *_3, *_8; HashPosition _2, _7; zend_bool _0; zval *arguments = NULL, *moduleName = NULL, *taskName = NULL, *actionName = NULL, *params = NULL, *route = NULL, *parts = NULL, *pattern = NULL, *routeFound = NULL, *matches, *paths = NULL, *beforeMatch = NULL, *converters = NULL, *converter = NULL, *part = NULL, *position = NULL, *matchPosition = NULL, *strParams, *_1, **_4, **_9, *_10 = NULL, *_12, *_13, *_14, *_15, _17, *_18 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &arguments); if (!arguments) { arguments = ZEPHIR_GLOBAL(global_null); } ZEPHIR_INIT_VAR(routeFound); ZVAL_BOOL(routeFound, 0); ZEPHIR_INIT_VAR(parts); array_init(parts); ZEPHIR_INIT_VAR(params); array_init(params); ZEPHIR_INIT_VAR(matches); ZVAL_NULL(matches); zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_matchedRoute"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC); if (Z_TYPE_P(arguments) != IS_ARRAY) { _0 = Z_TYPE_P(arguments) != IS_STRING; if (_0) { _0 = Z_TYPE_P(arguments) != IS_NULL; } if (_0) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Arguments must be an array or string", "phalcon/cli/router.zep", 223); return; } _1 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC); zephir_is_iterable(_1, &_3, &_2, 0, 1, "phalcon/cli/router.zep", 323); for ( ; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS ; zephir_hash_move_backwards_ex(_3, &_2) ) { ZEPHIR_GET_HVALUE(route, _4); ZEPHIR_CALL_METHOD(&pattern, route, "getcompiledpattern", NULL); zephir_check_call_status(); if (zephir_memnstr_str(pattern, SL("^"), "phalcon/cli/router.zep", 233)) { Z_SET_ISREF_P(matches); ZEPHIR_CALL_FUNCTION(&routeFound, "preg_match", &_5, pattern, arguments, matches); Z_UNSET_ISREF_P(matches); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(routeFound); ZVAL_BOOL(routeFound, ZEPHIR_IS_EQUAL(pattern, arguments)); } if (zephir_is_true(routeFound)) { ZEPHIR_CALL_METHOD(&beforeMatch, route, "getbeforematch", NULL); zephir_check_call_status(); if (Z_TYPE_P(beforeMatch) != IS_NULL) { if (!(zephir_is_callable(beforeMatch TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Before-Match callback is not callable in matched route", "phalcon/cli/router.zep", 251); return; } ZEPHIR_INIT_NVAR(routeFound); ZEPHIR_INIT_NVAR(_6); zephir_create_array(_6, 3, 0 TSRMLS_CC); zephir_array_fast_append(_6, arguments); zephir_array_fast_append(_6, route); zephir_array_fast_append(_6, this_ptr); ZEPHIR_CALL_USER_FUNC_ARRAY(routeFound, beforeMatch, _6); zephir_check_call_status(); } } if (zephir_is_true(routeFound)) { ZEPHIR_CALL_METHOD(&paths, route, "getpaths", NULL); zephir_check_call_status(); ZEPHIR_CPY_WRT(parts, paths); if (Z_TYPE_P(matches) == IS_ARRAY) { ZEPHIR_CALL_METHOD(&converters, route, "getconverters", NULL); zephir_check_call_status(); zephir_is_iterable(paths, &_8, &_7, 0, 0, "phalcon/cli/router.zep", 312); for ( ; zephir_hash_get_current_data_ex(_8, (void**) &_9, &_7) == SUCCESS ; zephir_hash_move_forward_ex(_8, &_7) ) { ZEPHIR_GET_HMKEY(part, _8, _7); ZEPHIR_GET_HVALUE(position, _9); ZEPHIR_OBS_NVAR(matchPosition); if (zephir_array_isset_fetch(&matchPosition, matches, position, 0 TSRMLS_CC)) { if (Z_TYPE_P(converters) == IS_ARRAY) { ZEPHIR_OBS_NVAR(converter); if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_10); ZEPHIR_INIT_NVAR(_6); zephir_create_array(_6, 1, 0 TSRMLS_CC); zephir_array_fast_append(_6, matchPosition); ZEPHIR_CALL_USER_FUNC_ARRAY(_10, converter, _6); zephir_check_call_status(); zephir_array_update_zval(&parts, part, &_10, PH_COPY | PH_SEPARATE); continue; } } zephir_array_update_zval(&parts, part, &matchPosition, PH_COPY | PH_SEPARATE); } else { if (Z_TYPE_P(converters) == IS_ARRAY) { ZEPHIR_OBS_NVAR(converter); if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_10); ZEPHIR_INIT_NVAR(_11); zephir_create_array(_11, 1, 0 TSRMLS_CC); zephir_array_fast_append(_11, position); ZEPHIR_CALL_USER_FUNC_ARRAY(_10, converter, _11); zephir_check_call_status(); zephir_array_update_zval(&parts, part, &_10, PH_COPY | PH_SEPARATE); } } } } zephir_update_property_this(this_ptr, SL("_matches"), matches TSRMLS_CC); } zephir_update_property_this(this_ptr, SL("_matchedRoute"), route TSRMLS_CC); break; } } if (zephir_is_true(routeFound)) { zephir_update_property_this(this_ptr, SL("_wasMatched"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } else { zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC); _12 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_module"), _12 TSRMLS_CC); _13 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultTask"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_task"), _13 TSRMLS_CC); _14 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_action"), _14 TSRMLS_CC); _15 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultParams"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_params"), _15 TSRMLS_CC); RETURN_THIS(); } } else { ZEPHIR_CPY_WRT(parts, arguments); } ZEPHIR_INIT_VAR(moduleName); ZVAL_NULL(moduleName); ZEPHIR_INIT_VAR(taskName); ZVAL_NULL(taskName); ZEPHIR_INIT_VAR(actionName); ZVAL_NULL(actionName); ZEPHIR_OBS_NVAR(moduleName); if (zephir_array_isset_string_fetch(&moduleName, parts, SS("module"), 0 TSRMLS_CC)) { zephir_array_unset_string(&parts, SS("module"), PH_SEPARATE); } else { ZEPHIR_OBS_NVAR(moduleName); zephir_read_property_this(&moduleName, this_ptr, SL("_defaultModule"), PH_NOISY_CC); } ZEPHIR_OBS_NVAR(taskName); if (zephir_array_isset_string_fetch(&taskName, parts, SS("task"), 0 TSRMLS_CC)) { zephir_array_unset_string(&parts, SS("task"), PH_SEPARATE); } else { ZEPHIR_OBS_NVAR(taskName); zephir_read_property_this(&taskName, this_ptr, SL("_defaultTask"), PH_NOISY_CC); } ZEPHIR_OBS_NVAR(actionName); if (zephir_array_isset_string_fetch(&actionName, parts, SS("action"), 0 TSRMLS_CC)) { zephir_array_unset_string(&parts, SS("action"), PH_SEPARATE); } else { ZEPHIR_OBS_NVAR(actionName); zephir_read_property_this(&actionName, this_ptr, SL("_defaultAction"), PH_NOISY_CC); } if (zephir_is_true(routeFound)) { ZEPHIR_OBS_NVAR(params); if (zephir_array_isset_string_fetch(¶ms, parts, SS("params"), 0 TSRMLS_CC)) { if (Z_TYPE_P(params) != IS_ARRAY) { zephir_get_strval(_16, params); ZEPHIR_SINIT_VAR(_17); ZVAL_LONG(&_17, 1); ZEPHIR_INIT_VAR(strParams); zephir_substr(strParams, _16, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); if (zephir_is_true(strParams)) { ZEPHIR_INIT_NVAR(params); ZEPHIR_CALL_CE_STATIC(&_18, phalcon_cli_router_route_ce, "getdelimiter", &_19); zephir_check_call_status(); zephir_fast_explode(params, _18, strParams, LONG_MAX TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(params); array_init(params); } } zephir_array_unset_string(&parts, SS("params"), PH_SEPARATE); } if (zephir_fast_count_int(params TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_10); zephir_fast_array_merge(_10, &(params), &(parts) TSRMLS_CC); ZEPHIR_CPY_WRT(params, _10); } else { ZEPHIR_CPY_WRT(params, parts); } } else { ZEPHIR_CPY_WRT(params, parts); } zephir_update_property_this(this_ptr, SL("_module"), moduleName TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_task"), taskName TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_action"), actionName TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_params"), params TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Moves internal resultset cursor to another position letting us to fetch a certain row * *<code> * $result = $connection->query("SELECT * FROM robots ORDER BY name"); * $result->dataSeek(2); // Move to third row on result * $row = $result->fetch(); // Fetch third row *</code> */ PHP_METHOD(Phalcon_Db_Result_Pdo, dataSeek) { int ZEPHIR_LAST_CALL_STATUS; zval *number_param = NULL, *connection = NULL, *pdo = NULL, *sqlStatement = NULL, *bindParams = NULL, *statement = NULL, *_0$$4 = NULL, *_1$$4; long number; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &number_param); number = zephir_get_intval(number_param); { pdo_stmt_t *stmt; long n; ZEPHIR_OBS_VAR(connection); zephir_read_property_this(&connection, this_ptr, SL("_connection"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&pdo, connection, "getinternalhandler", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_VAR(sqlStatement); zephir_read_property_this(&sqlStatement, this_ptr, SL("_sqlStatement"), PH_NOISY_CC); ZEPHIR_OBS_VAR(bindParams); zephir_read_property_this(&bindParams, this_ptr, SL("_bindParams"), PH_NOISY_CC); 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) { _1$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_bindTypes"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&_0$$4, connection, "executeprepared", NULL, 0, statement, bindParams, _1$$4); zephir_check_call_status(); ZEPHIR_CPY_WRT(statement, _0$$4); } } else { ZEPHIR_CALL_METHOD(&statement, pdo, "query", NULL, 0, sqlStatement); zephir_check_call_status(); } zephir_update_property_this(this_ptr, SL("_pdoStatement"), statement TSRMLS_CC); /** * This a fetch scroll to reach the desired position, however with a big number of records * maybe it may be very slow */ stmt = (pdo_stmt_t*) zend_object_store_get_object(statement TSRMLS_CC); if (!stmt->dbh) { ZEPHIR_MM_RESTORE(); RETURN_FALSE; } n = -1; number--; while (n != number) { if (!stmt->methods->fetcher(stmt, PDO_FETCH_ORI_NEXT, 0 TSRMLS_CC)) { ZEPHIR_MM_RESTORE(); RETURN_NULL(); } n++; } } ZEPHIR_MM_RESTORE(); }
/** * Executes the validation */ PHP_METHOD(Phalcon_Validation_Validator_Regex, validate) { zend_bool failed = 0; int ZEPHIR_LAST_CALL_STATUS; zval *field = NULL; zval *validation, *field_param = NULL, *matches = NULL, *message = NULL, *value = NULL, *label = NULL, *replacePairs = NULL, *code = NULL, *pattern = NULL, *_0 = NULL, *_1$$3, *_2$$4, *_3$$6 = NULL, *_8$$6 = NULL, *_9$$6, *_4$$7, *_5$$9, *_6$$10, *_7$$11; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &validation, &field_param); if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(field_param) == IS_STRING)) { zephir_get_strval(field, field_param); } else { ZEPHIR_INIT_VAR(field); ZVAL_EMPTY_STRING(field); } ZEPHIR_INIT_VAR(matches); ZVAL_NULL(matches); ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field); zephir_check_call_status(); ZEPHIR_INIT_VAR(_0); ZVAL_STRING(_0, "pattern", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&pattern, this_ptr, "getoption", NULL, 0, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (Z_TYPE_P(pattern) == IS_ARRAY) { zephir_array_fetch(&_1$$3, pattern, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 81 TSRMLS_CC); ZEPHIR_CPY_WRT(pattern, _1$$3); } ZEPHIR_INIT_NVAR(_0); zephir_preg_match(_0, pattern, value, matches, 0, 0 , 0 TSRMLS_CC); if (zephir_is_true(_0)) { zephir_array_fetch_long(&_2$$4, matches, 0, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 85 TSRMLS_CC); failed = !ZEPHIR_IS_EQUAL(_2$$4, value); } else { failed = 1; } if (failed == 1) { ZEPHIR_INIT_VAR(_3$$6); ZVAL_STRING(_3$$6, "label", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _3$$6); zephir_check_temp_parameter(_3$$6); zephir_check_call_status(); if (Z_TYPE_P(label) == IS_ARRAY) { zephir_array_fetch(&_4$$7, label, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 94 TSRMLS_CC); ZEPHIR_CPY_WRT(label, _4$$7); } if (ZEPHIR_IS_EMPTY(label)) { ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_3$$6); ZVAL_STRING(_3$$6, "message", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _3$$6); zephir_check_temp_parameter(_3$$6); zephir_check_call_status(); if (Z_TYPE_P(message) == IS_ARRAY) { zephir_array_fetch(&_5$$9, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 102 TSRMLS_CC); ZEPHIR_CPY_WRT(message, _5$$9); } ZEPHIR_INIT_VAR(replacePairs); zephir_create_array(replacePairs, 1, 0 TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE); if (ZEPHIR_IS_EMPTY(message)) { ZEPHIR_INIT_VAR(_6$$10); ZVAL_STRING(_6$$10, "Regex", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _6$$10); zephir_check_temp_parameter(_6$$10); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_3$$6); ZVAL_STRING(_3$$6, "code", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&code, this_ptr, "getoption", NULL, 0, _3$$6); zephir_check_temp_parameter(_3$$6); zephir_check_call_status(); if (Z_TYPE_P(code) == IS_ARRAY) { zephir_array_fetch(&_7$$11, code, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 111 TSRMLS_CC); ZEPHIR_CPY_WRT(code, _7$$11); } ZEPHIR_INIT_NVAR(_3$$6); object_init_ex(_3$$6, phalcon_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_8$$6, "strtr", NULL, 26, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_VAR(_9$$6); ZVAL_STRING(_9$$6, "Regex", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _3$$6, "__construct", NULL, 465, _8$$6, field, _9$$6, code); zephir_check_temp_parameter(_9$$6); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _3$$6); zephir_check_call_status(); RETURN_MM_BOOL(0); } RETURN_MM_BOOL(1); }
/** * Extracts parameters from a string * * @param string pattern */ PHP_METHOD(Test_Router_Route, extractNamedParams) { zephir_nts_static zephir_fcall_cache_entry *_4 = NULL; long _0, _6, _23; zend_bool notValid = 0, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18; int tmp, cursor, cursorVar, marker, bracketCount = 0, parenthesesCount = 0, foundPattern = 0, intermediate = 0, numberMatches = 0, ZEPHIR_LAST_CALL_STATUS; char ch; zval *pattern_param = NULL, *matches, _1 = zval_used_for_init, _2 = zval_used_for_init, *_3 = NULL, *_19 = NULL, *_21 = NULL, *_24 = NULL; zval *pattern = NULL, *route, *item = NULL, *variable = NULL, *regexp = NULL, *_5 = NULL, *_20 = NULL, *_22 = NULL, *_25 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &pattern_param); zephir_get_strval(pattern, pattern_param); if (zephir_fast_strlen_ev(pattern) <= 0) { RETURN_MM_BOOL(0); } ZEPHIR_INIT_VAR(matches); array_init(matches); ZEPHIR_INIT_VAR(route); ZVAL_EMPTY_STRING(route); for (_0 = 0; _0 < Z_STRLEN_P(pattern); _0++) { cursor = _0; ch = ZEPHIR_STRING_OFFSET(pattern, _0); if (parenthesesCount == 0) { if (ch == '{') { if (bracketCount == 0) { marker = (cursor + 1); intermediate = 0; notValid = 0; } bracketCount++; } else { if (ch == '}') { bracketCount--; if (intermediate > 0) { if (bracketCount == 0) { numberMatches++; ZEPHIR_INIT_NVAR(variable); ZVAL_EMPTY_STRING(variable); ZEPHIR_INIT_NVAR(regexp); ZVAL_EMPTY_STRING(regexp); ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, marker); ZEPHIR_SINIT_NVAR(_2); ZVAL_LONG(&_2, (cursor - marker)); ZEPHIR_CALL_FUNCTION(&_3, "substr", &_4, pattern, &_1, &_2); zephir_check_call_status(); zephir_get_strval(_5, _3); ZEPHIR_CPY_WRT(item, _5); for (_6 = 0; _6 < Z_STRLEN_P(item); _6++) { cursorVar = _6; ch = ZEPHIR_STRING_OFFSET(item, _6); if (ch == '\0') { break; } _7 = cursorVar == 0; if (_7) { _8 = ch >= 'a'; if (_8) { _8 = ch <= 'z'; } _9 = _8; if (!(_9)) { _10 = ch >= 'A'; if (_10) { _10 = ch <= 'Z'; } _9 = _10; } _7 = !_9; } if (_7) { notValid = 1; break; } _11 = ch >= 'a'; if (_11) { _11 = ch <= 'z'; } _12 = _11; if (!(_12)) { _13 = ch >= 'A'; if (_13) { _13 = ch <= 'Z'; } _12 = _13; } _14 = _12; if (!(_14)) { _15 = ch >= '0'; if (_15) { _15 = ch <= '9'; } _14 = _15; } _16 = _14; if (!(_16)) { _16 = ch == '-'; } _17 = _16; if (!(_17)) { _17 = ch == '_'; } _18 = _17; if (!(_18)) { _18 = ch == ':'; } if (_18) { if (ch == ':') { ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, 0); ZEPHIR_SINIT_NVAR(_2); ZVAL_LONG(&_2, cursorVar); ZEPHIR_CALL_FUNCTION(&_19, "substr", &_4, item, &_1, &_2); zephir_check_call_status(); zephir_get_strval(_20, _19); ZEPHIR_CPY_WRT(variable, _20); ZEPHIR_SINIT_NVAR(_1); ZVAL_LONG(&_1, (cursorVar + 1)); ZEPHIR_CALL_FUNCTION(&_21, "substr", &_4, item, &_1); zephir_check_call_status(); zephir_get_strval(_22, _21); ZEPHIR_CPY_WRT(regexp, _22); break; } } else { notValid = 1; break; } } if (!(notValid)) { tmp = numberMatches; _7 = zephir_is_true(variable); if (_7) { _7 = zephir_is_true(regexp); } if (_7) { foundPattern = 0; for (_23 = 0; _23 < Z_STRLEN_P(regexp); _23++) { ch = ZEPHIR_STRING_OFFSET(regexp, _23); if (ch == '\0') { break; } if (!(foundPattern)) { if (ch == '(') { foundPattern = 1; } } else { if (ch == ')') { foundPattern = 2; break; } } } if (foundPattern != 2) { zephir_concat_self_str(&route, "(", sizeof("(")-1 TSRMLS_CC); zephir_concat_self(&route, regexp TSRMLS_CC); zephir_concat_self_str(&route, ")", sizeof(")")-1 TSRMLS_CC); } else { zephir_concat_self(&route, regexp TSRMLS_CC); } ZEPHIR_INIT_NVAR(_24); ZVAL_LONG(_24, tmp); zephir_array_update_zval(&matches, variable, &_24, PH_COPY | PH_SEPARATE); } else { zephir_concat_self_str(&route, "([^/]*)", sizeof("([^/]*)")-1 TSRMLS_CC); ZEPHIR_INIT_NVAR(_24); ZVAL_LONG(_24, tmp); zephir_array_update_zval(&matches, item, &_24, PH_COPY | PH_SEPARATE); } } else { ZEPHIR_INIT_LNVAR(_25); ZEPHIR_CONCAT_SVS(_25, "{", item, "}"); zephir_concat_self(&route, _25 TSRMLS_CC); } continue; } } } } } if (bracketCount == 0) { if (ch == '(') { parenthesesCount++; } else { if (ch == ')') { parenthesesCount--; if (parenthesesCount == 0) { numberMatches++; } } } } if (bracketCount > 0) { intermediate++; } else { zephir_concat_self_char(&route, ch TSRMLS_CC); } } array_init_size(return_value, 3); zephir_array_fast_append(return_value, route); zephir_array_fast_append(return_value, matches); RETURN_MM(); }
/** * Stores cached content into the file backend and stops the frontend * * @param int|string keyName * @param string content * @param long lifetime * @param boolean stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_Xcache, save) { zephir_fcall_cache_entry *_1 = NULL; int ZEPHIR_LAST_CALL_STATUS; zend_bool stopBuffer; zval *keyName = NULL, *content = NULL, *lifetime = NULL, *stopBuffer_param = NULL, *lastKey = NULL, *frontend, *cachedContent = NULL, *preparedContent = NULL, *tmp, *tt1 = NULL, *success = NULL, *isBuffering = NULL, *options, *keys = NULL, *specialKey, *_0; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 4, &keyName, &content, &lifetime, &stopBuffer_param); if (!keyName) { keyName = ZEPHIR_GLOBAL(global_null); } if (!content) { content = ZEPHIR_GLOBAL(global_null); } if (!lifetime) { lifetime = ZEPHIR_GLOBAL(global_null); } if (!stopBuffer_param) { stopBuffer = 1; } else { stopBuffer = zephir_get_boolval(stopBuffer_param); } if (!(zephir_is_true(keyName))) { ZEPHIR_OBS_VAR(lastKey); zephir_read_property_this(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC); } else { _0 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC); ZEPHIR_INIT_NVAR(lastKey); ZEPHIR_CONCAT_SVV(lastKey, "_PHCX", _0, keyName); } if (!(zephir_is_true(lastKey))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache must be started first", "phalcon/cache/backend/xcache.zep", 119); return; } ZEPHIR_OBS_VAR(frontend); zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); if (!(zephir_is_true(content))) { ZEPHIR_CALL_METHOD(&cachedContent, frontend, "getcontent", NULL, 0); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(cachedContent, content); } if (!(zephir_is_numeric(cachedContent))) { ZEPHIR_CALL_METHOD(&preparedContent, frontend, "beforestore", NULL, 0, cachedContent); zephir_check_call_status(); } if (!(zephir_is_true(lifetime))) { ZEPHIR_OBS_VAR(tmp); zephir_read_property_this(&tmp, this_ptr, SL("_lastLifetime"), PH_NOISY_CC); if (!(zephir_is_true(tmp))) { ZEPHIR_CALL_METHOD(&tt1, frontend, "getlifetime", NULL, 0); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(tt1, tmp); } } else { ZEPHIR_CPY_WRT(tt1, lifetime); } if (zephir_is_numeric(cachedContent)) { ZEPHIR_CALL_FUNCTION(&success, "xcache_set", &_1, 85, lastKey, cachedContent, tt1); zephir_check_call_status(); } else { ZEPHIR_CALL_FUNCTION(&success, "xcache_set", &_1, 85, lastKey, preparedContent, tt1); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&isBuffering, frontend, "isbuffering", NULL, 0); zephir_check_call_status(); if (stopBuffer == 1) { ZEPHIR_CALL_METHOD(NULL, frontend, "stop", NULL, 0); zephir_check_call_status(); } if (ZEPHIR_IS_TRUE_IDENTICAL(isBuffering)) { zend_print_zval(cachedContent, 0); } if (0) { zephir_update_property_this(this_ptr, SL("_started"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC); } else { zephir_update_property_this(this_ptr, SL("_started"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } if (zephir_is_true(success)) { ZEPHIR_OBS_VAR(options); zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC); ZEPHIR_OBS_VAR(specialKey); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY_CC); if (!(zephir_array_isset_string_fetch(&specialKey, _0, SS("statsKey"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/xcache.zep", 169); return; } ZEPHIR_CALL_FUNCTION(&keys, "xcache_get", NULL, 84, specialKey); zephir_check_call_status(); if (Z_TYPE_P(keys) != IS_ARRAY) { ZEPHIR_INIT_NVAR(keys); array_init(keys); } zephir_array_update_zval(&keys, lastKey, &tt1, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_FUNCTION(NULL, "xcache_set", &_1, 85, specialKey, keys); zephir_check_call_status(); } ZEPHIR_MM_RESTORE(); }
/** * Applies a format to a message before sending it to the log * * @param string $message * @param int $type * @param int $timestamp * @param array $context * * @return string */ PHP_METHOD(Phalcon_Logger_Formatter_Firephp, format) { HashTable *_7$$4; HashPosition _6$$4; zval *_18; zend_bool _11, _14; int type, timestamp, ZEPHIR_LAST_CALL_STATUS; zval *message_param = NULL, *type_param = NULL, *timestamp_param = NULL, *context = NULL, *meta = NULL, *body = NULL, *backtrace = NULL, *encoded = NULL, *len = NULL, *lastTrace = NULL, *_1 = NULL, *_2, *_3, *_9, *_10, *_12, *_13, *_15, *_0$$3 = NULL, *param$$4 = NULL, *backtraceItem$$4 = NULL, *key$$4 = NULL, **_8$$4, *_4$$5, *_5$$6, *_16$$11, *_17$$11; zval *message = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 3, 1, &message_param, &type_param, ×tamp_param, &context); zephir_get_strval(message, message_param); type = zephir_get_intval(type_param); timestamp = zephir_get_intval(timestamp_param); if (!context) { context = ZEPHIR_GLOBAL(global_null); } if (Z_TYPE_P(context) == IS_ARRAY) { ZEPHIR_CALL_METHOD(&_0$$3, this_ptr, "interpolate", NULL, 0, message, context); zephir_check_call_status(); zephir_get_strval(message, _0$$3); } ZEPHIR_INIT_VAR(meta); zephir_create_array(meta, 1, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_2); ZVAL_LONG(_2, type); ZEPHIR_CALL_METHOD(&_1, this_ptr, "gettypestring", NULL, 0, _2); zephir_check_call_status(); zephir_array_update_string(&meta, SL("Type"), &_1, PH_COPY | PH_SEPARATE); _3 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC); if (zephir_is_true(_3)) { ZEPHIR_INIT_VAR(param$$4); ZVAL_LONG(param$$4, 2); ZEPHIR_CALL_FUNCTION(&backtrace, "debug_backtrace", NULL, 160, param$$4); zephir_check_call_status(); ZEPHIR_MAKE_REF(backtrace); ZEPHIR_CALL_FUNCTION(&lastTrace, "end", NULL, 178, backtrace); ZEPHIR_UNREF(backtrace); zephir_check_call_status(); if (zephir_array_isset_string(lastTrace, SS("file"))) { zephir_array_fetch_string(&_4$$5, lastTrace, SL("file"), PH_NOISY | PH_READONLY, "phalcon/logger/formatter/firephp.zep", 128 TSRMLS_CC); zephir_array_update_string(&meta, SL("File"), &_4$$5, PH_COPY | PH_SEPARATE); } if (zephir_array_isset_string(lastTrace, SS("line"))) { zephir_array_fetch_string(&_5$$6, lastTrace, SL("line"), PH_NOISY | PH_READONLY, "phalcon/logger/formatter/firephp.zep", 132 TSRMLS_CC); zephir_array_update_string(&meta, SL("Line"), &_5$$6, PH_COPY | PH_SEPARATE); } zephir_is_iterable(backtrace, &_7$$4, &_6$$4, 1, 0, "phalcon/logger/formatter/firephp.zep", 141); for ( ; zephir_hash_get_current_data_ex(_7$$4, (void**) &_8$$4, &_6$$4) == SUCCESS ; zephir_hash_move_forward_ex(_7$$4, &_6$$4) ) { ZEPHIR_GET_HMKEY(key$$4, _7$$4, _6$$4); ZEPHIR_GET_HVALUE(backtraceItem$$4, _8$$4); zephir_array_unset_string(&backtraceItem$$4, SS("object"), PH_SEPARATE); zephir_array_unset_string(&backtraceItem$$4, SS("args"), PH_SEPARATE); zephir_array_update_zval(&backtrace, key$$4, &backtraceItem$$4, PH_COPY | PH_SEPARATE); } zend_hash_destroy(_7$$4); FREE_HASHTABLE(_7$$4); } _9 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC); if (zephir_is_true(_9)) { zephir_array_update_string(&meta, SL("Label"), &message, PH_COPY | PH_SEPARATE); } _10 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC); _11 = !zephir_is_true(_10); if (_11) { _12 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC); _11 = !zephir_is_true(_12); } _13 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC); _14 = zephir_is_true(_13); if (_14) { _15 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC); _14 = !zephir_is_true(_15); } if (_11) { ZEPHIR_CPY_WRT(body, message); } else if (_14) { ZEPHIR_INIT_NVAR(body); ZVAL_STRING(body, "", 1); } else { ZEPHIR_INIT_NVAR(body); array_init(body); _16$$11 = zephir_fetch_nproperty_this(this_ptr, SL("_showBacktrace"), PH_NOISY_CC); if (zephir_is_true(_16$$11)) { zephir_array_update_string(&body, SL("backtrace"), &backtrace, PH_COPY | PH_SEPARATE); } _17$$11 = zephir_fetch_nproperty_this(this_ptr, SL("_enableLabels"), PH_NOISY_CC); if (!(zephir_is_true(_17$$11))) { zephir_array_update_string(&body, SL("message"), &message, PH_COPY | PH_SEPARATE); } } ZEPHIR_INIT_VAR(_18); zephir_create_array(_18, 2, 0 TSRMLS_CC); zephir_array_fast_append(_18, meta); zephir_array_fast_append(_18, body); ZEPHIR_INIT_VAR(encoded); zephir_json_encode(encoded, &(encoded), _18, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(len); ZVAL_LONG(len, zephir_fast_strlen_ev(encoded)); ZEPHIR_CONCAT_VSVS(return_value, len, "|", encoded, "|"); RETURN_MM(); }
/** * Phalcon\Session\Adapter\Memcache constructor */ PHP_METHOD(Phalcon_Session_Adapter_Memcache, __construct) { zephir_fcall_cache_entry *_14 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *options_param = NULL, *lifetime = NULL, *_3, *_4, *_6, *_8 = NULL, *_0$$3, *_1$$4, *_2$$5; zval *options = NULL, *_5, *_7, *_9, *_10, *_11, *_12, *_13; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &options_param); if (!options_param) { ZEPHIR_INIT_VAR(options); array_init(options); } else { zephir_get_arrval(options, options_param); } if (!(zephir_array_isset_string(options, SS("host")))) { ZEPHIR_INIT_VAR(_0$$3); ZVAL_STRING(_0$$3, "127.0.0.1", 1); zephir_array_update_string(&options, SL("host"), &_0$$3, PH_COPY | PH_SEPARATE); } if (!(zephir_array_isset_string(options, SS("port")))) { ZEPHIR_INIT_VAR(_1$$4); ZVAL_LONG(_1$$4, 11211); zephir_array_update_string(&options, SL("port"), &_1$$4, PH_COPY | PH_SEPARATE); } if (!(zephir_array_isset_string(options, SS("persistent")))) { ZEPHIR_INIT_VAR(_2$$5); ZVAL_LONG(_2$$5, 0); zephir_array_update_string(&options, SL("persistent"), &_2$$5, PH_COPY | PH_SEPARATE); } ZEPHIR_OBS_VAR(lifetime); if (zephir_array_isset_string_fetch(&lifetime, options, SS("lifetime"), 0 TSRMLS_CC)) { zephir_update_property_this(this_ptr, SL("_lifetime"), lifetime TSRMLS_CC); } ZEPHIR_INIT_VAR(_3); object_init_ex(_3, phalcon_cache_backend_memcache_ce); ZEPHIR_INIT_VAR(_4); object_init_ex(_4, phalcon_cache_frontend_data_ce); ZEPHIR_INIT_VAR(_5); zephir_create_array(_5, 1, 0 TSRMLS_CC); ZEPHIR_OBS_VAR(_6); zephir_read_property_this(&_6, this_ptr, SL("_lifetime"), PH_NOISY_CC); zephir_array_update_string(&_5, SL("lifetime"), &_6, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(NULL, _4, "__construct", NULL, 313, _5); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, _3, "__construct", NULL, 316, _4, options); zephir_check_call_status(); zephir_update_property_this(this_ptr, SL("_memcache"), _3 TSRMLS_CC); ZEPHIR_INIT_VAR(_7); zephir_create_array(_7, 2, 0 TSRMLS_CC); zephir_array_fast_append(_7, this_ptr); ZEPHIR_INIT_VAR(_8); ZVAL_STRING(_8, "open", 1); zephir_array_fast_append(_7, _8); ZEPHIR_INIT_VAR(_9); zephir_create_array(_9, 2, 0 TSRMLS_CC); zephir_array_fast_append(_9, this_ptr); ZEPHIR_INIT_NVAR(_8); ZVAL_STRING(_8, "close", 1); zephir_array_fast_append(_9, _8); ZEPHIR_INIT_VAR(_10); zephir_create_array(_10, 2, 0 TSRMLS_CC); zephir_array_fast_append(_10, this_ptr); ZEPHIR_INIT_NVAR(_8); ZVAL_STRING(_8, "read", 1); zephir_array_fast_append(_10, _8); ZEPHIR_INIT_VAR(_11); zephir_create_array(_11, 2, 0 TSRMLS_CC); zephir_array_fast_append(_11, this_ptr); ZEPHIR_INIT_NVAR(_8); ZVAL_STRING(_8, "write", 1); zephir_array_fast_append(_11, _8); ZEPHIR_INIT_VAR(_12); zephir_create_array(_12, 2, 0 TSRMLS_CC); zephir_array_fast_append(_12, this_ptr); ZEPHIR_INIT_NVAR(_8); ZVAL_STRING(_8, "destroy", 1); zephir_array_fast_append(_12, _8); ZEPHIR_INIT_VAR(_13); zephir_create_array(_13, 2, 0 TSRMLS_CC); zephir_array_fast_append(_13, this_ptr); ZEPHIR_INIT_NVAR(_8); ZVAL_STRING(_8, "gc", 1); zephir_array_fast_append(_13, _8); ZEPHIR_CALL_FUNCTION(NULL, "session_set_save_handler", NULL, 410, _7, _9, _10, _11, _12, _13); zephir_check_call_status(); ZEPHIR_CALL_PARENT(NULL, phalcon_session_adapter_memcache_ce, this_ptr, "__construct", &_14, 411, options); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); }
/** * @todo this method can be write differently with (P< style match * Matches a user submitted path with parts defined by a map. Assigns and * returns an array of variables on a successful match. * * @param string $path Path used to match against this routing map * @return array|false An array of assigned values or a false on a mismatch */ PHP_METHOD(Yaf_Route_Rewrite, _match) { zephir_nts_static zephir_fcall_cache_entry *_27 = NULL, *_33 = NULL; zend_bool _12, _28, _32; HashTable *_7, *_22, *_35; HashPosition _6, _21, _34; int staticCount, pathStaticCount, ZEPHIR_LAST_CALL_STATUS; zval *path_param = NULL, *values, *matchedPath = NULL, *parts, *variables, *wildcardData, *name = NULL, *part = NULL, *pos = NULL, *pathMatch, *count = NULL, *i = NULL, *varr = NULL, *pathPart = NULL, *tmpReturn = NULL, *_0, *_1 = NULL, *_2 = NULL, *_3, _4 = zval_used_for_init, _5 = zval_used_for_init, **_8, _9 = zval_used_for_init, _10 = zval_used_for_init, *_11 = NULL, _13 = zval_used_for_init, _14 = zval_used_for_init, *_15 = NULL, _16 = zval_used_for_init, _17 = zval_used_for_init, *_18 = NULL, _19 = zval_used_for_init, *_20 = NULL, **_23, *_24 = NULL, *_25, *_26, *_29 = NULL, *_30, *_31 = NULL, **_36; zval *path = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &path_param); zephir_get_strval(path, path_param); staticCount = 0; pathStaticCount = 0; ZEPHIR_INIT_VAR(values); array_init(values); ZEPHIR_INIT_VAR(matchedPath); ZVAL_STRING(matchedPath, "", 1); ZEPHIR_INIT_VAR(parts); array_init(parts); ZEPHIR_INIT_VAR(variables); array_init(variables); ZEPHIR_INIT_VAR(wildcardData); array_init(wildcardData); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_route"), PH_NOISY_CC); if (!ZEPHIR_IS_STRING_IDENTICAL(_0, "")) { ZEPHIR_INIT_VAR(_1); ZEPHIR_INIT_VAR(_2); _3 = zephir_fetch_nproperty_this(this_ptr, SL("_route"), PH_NOISY_CC); ZEPHIR_SINIT_VAR(_4); ZVAL_STRING(&_4, "/", 0); zephir_fast_trim(_2, _3, &_4, ZEPHIR_TRIM_BOTH TSRMLS_CC); ZEPHIR_SINIT_VAR(_5); ZVAL_STRING(&_5, "/", 0); zephir_fast_explode(_1, &_5, _2, LONG_MAX TSRMLS_CC); zephir_is_iterable(_1, &_7, &_6, 0, 0, "yaf/Route/rewrite.zep", 135); for ( ; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS ; zephir_hash_move_forward_ex(_7, &_6) ) { ZEPHIR_GET_HMKEY(pos, _7, _6); ZEPHIR_GET_HVALUE(part, _8); ZEPHIR_SINIT_NVAR(_9); ZVAL_LONG(&_9, 0); ZEPHIR_SINIT_NVAR(_10); ZVAL_LONG(&_10, 1); ZEPHIR_INIT_NVAR(_11); zephir_substr(_11, part, 0 , 1 , 0); _12 = ZEPHIR_IS_STRING(_11, ":"); if (_12) { ZEPHIR_SINIT_NVAR(_13); ZVAL_LONG(&_13, 1); ZEPHIR_SINIT_NVAR(_14); ZVAL_LONG(&_14, 1); ZEPHIR_INIT_NVAR(_15); zephir_substr(_15, part, 1 , 1 , 0); _12 = !ZEPHIR_IS_STRING(_15, ":"); } if (_12) { ZEPHIR_SINIT_NVAR(_16); ZVAL_LONG(&_16, 1); ZEPHIR_INIT_NVAR(name); zephir_substr(name, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); zephir_array_update_zval(&parts, pos, &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE); zephir_array_update_zval(&variables, pos, &name, PH_COPY | PH_SEPARATE); } else { ZEPHIR_SINIT_NVAR(_16); ZVAL_LONG(&_16, 0); ZEPHIR_SINIT_NVAR(_17); ZVAL_LONG(&_17, 1); ZEPHIR_INIT_NVAR(_18); zephir_substr(_18, part, 0 , 1 , 0); if (ZEPHIR_IS_STRING(_18, ":")) { ZEPHIR_SINIT_NVAR(_19); ZVAL_LONG(&_19, 1); ZEPHIR_INIT_NVAR(_20); zephir_substr(_20, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_CPY_WRT(part, _20); } zephir_array_update_zval(&parts, pos, &part, PH_COPY | PH_SEPARATE); if (!ZEPHIR_IS_STRING_IDENTICAL(part, "*")) { staticCount++; } } } } if (!ZEPHIR_IS_STRING_IDENTICAL(path, "")) { ZEPHIR_INIT_VAR(pathMatch); ZEPHIR_SINIT_NVAR(_4); ZVAL_STRING(&_4, "/", 0); zephir_fast_explode(pathMatch, &_4, path, LONG_MAX TSRMLS_CC); zephir_is_iterable(pathMatch, &_22, &_21, 0, 0, "yaf/Route/rewrite.zep", 193); for ( ; zephir_hash_get_current_data_ex(_22, (void**) &_23, &_21) == SUCCESS ; zephir_hash_move_forward_ex(_22, &_21) ) { ZEPHIR_GET_HMKEY(pos, _22, _21); ZEPHIR_GET_HVALUE(pathPart, _23); if (!(zephir_array_key_exists(parts, pos TSRMLS_CC))) { RETURN_MM_BOOL(0); } ZEPHIR_INIT_LNVAR(_24); ZEPHIR_CONCAT_VS(_24, pathPart, "/"); zephir_concat_self(&matchedPath, _24 TSRMLS_CC); zephir_array_fetch(&_25, parts, pos, PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 150 TSRMLS_CC); if (ZEPHIR_IS_STRING(_25, "*")) { ZEPHIR_INIT_NVAR(count); ZVAL_LONG(count, zephir_fast_count_int(pathMatch TSRMLS_CC)); ZEPHIR_CPY_WRT(i, pos); while (1) { if (!(ZEPHIR_LT(i, count))) { break; } zephir_array_fetch(&_26, pathMatch, i, PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 154 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&varr, "urldecode", &_27, _26); zephir_check_call_status(); _12 = !(zephir_array_isset(wildcardData, varr)); if (_12) { _3 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC); _12 = !(zephir_array_isset(_3, varr)); } _28 = _12; if (_28) { _28 = !(zephir_array_isset(values, varr)); } if (_28) { ZEPHIR_INIT_LNVAR(_29); if (zephir_array_isset_long(pathMatch, (zephir_get_numberval(i) + 1))) { zephir_array_fetch_long(&_30, pathMatch, (zephir_get_numberval(i) + 1), PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 157 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&_29, "urldecode", &_27, _30); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(_29); ZVAL_NULL(_29); } zephir_array_update_zval(&wildcardData, varr, &_29, PH_COPY | PH_SEPARATE); } ZEPHIR_INIT_NVAR(_1); ZVAL_LONG(_1, 2); ZEPHIR_ADD_ASSIGN(i, _1); } ZEPHIR_INIT_NVAR(matchedPath); ZEPHIR_SINIT_NVAR(_5); ZVAL_STRING(&_5, "/", 0); zephir_fast_join(matchedPath, &_5, pathMatch TSRMLS_CC); break; } if (zephir_array_isset(variables, pos)) { ZEPHIR_OBS_NVAR(name); zephir_array_fetch(&name, variables, pos, PH_NOISY, "yaf/Route/rewrite.zep", 165 TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(name); ZVAL_NULL(name); } ZEPHIR_CALL_FUNCTION(&_31, "urldecode", &_27, pathPart); zephir_check_call_status(); ZEPHIR_CPY_WRT(pathPart, _31); ZEPHIR_OBS_NVAR(part); zephir_array_fetch(&part, parts, pos, PH_NOISY, "yaf/Route/rewrite.zep", 167 TSRMLS_CC); ZEPHIR_SINIT_NVAR(_9); ZVAL_LONG(&_9, 0); ZEPHIR_SINIT_NVAR(_10); ZVAL_LONG(&_10, 2); ZEPHIR_INIT_NVAR(_2); zephir_substr(_2, part, 0 , 2 , 0); if (ZEPHIR_IS_STRING_IDENTICAL(_2, "@@")) { ZEPHIR_SINIT_NVAR(_13); ZVAL_LONG(&_13, 1); ZEPHIR_INIT_NVAR(_11); zephir_substr(_11, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_CPY_WRT(part, _11); } _28 = Z_TYPE_P(name) == IS_NULL; if (_28) { _28 = !ZEPHIR_IS_EQUAL(part, pathPart); } if (_28) { RETURN_MM_BOOL(0); } _32 = Z_TYPE_P(part) != IS_NULL; if (_32) { ZEPHIR_INIT_LNVAR(_29); ZEPHIR_CONCAT_VSSS(_29, part, "#^", "$#", "iu"); ZEPHIR_CALL_FUNCTION(&_31, "preg_match", &_33, _29, pathPart); zephir_check_call_status(); _32 = !zephir_is_true(_31); } if (_32) { RETURN_MM_BOOL(0); } if (Z_TYPE_P(name) != IS_NULL) { zephir_array_update_zval(&values, name, &pathPart, PH_COPY | PH_SEPARATE); } else { pathStaticCount++; } } } if (staticCount != pathStaticCount) { RETURN_MM_BOOL(0); } ZEPHIR_INIT_VAR(tmpReturn); zephir_add_function_ex(tmpReturn, values, wildcardData TSRMLS_CC); zephir_is_iterable(variables, &_35, &_34, 0, 0, "yaf/Route/rewrite.zep", 212); for ( ; zephir_hash_get_current_data_ex(_35, (void**) &_36, &_34) == SUCCESS ; zephir_hash_move_forward_ex(_35, &_34) ) { ZEPHIR_GET_HVALUE(varr, _36); if (!(zephir_array_key_exists(tmpReturn, varr TSRMLS_CC))) { RETURN_MM_BOOL(0); } } _12 = Z_TYPE_P(values) == IS_NULL; if (_12) { _12 = Z_TYPE_P(wildcardData) == IS_NULL; } _32 = _12; if (_32) { _32 = staticCount != 0; } if (_32) { _3 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC); ZEPHIR_INIT_LNVAR(_24); zephir_add_function_ex(_24, tmpReturn, _3 TSRMLS_CC); ZEPHIR_CPY_WRT(tmpReturn, _24); } RETURN_CCTOR(tmpReturn); }
/** * Phalcon\Di\FactoryDefault constructor */ PHP_METHOD(Phalcon_Di_FactoryDefault, __construct) { zval *_2 = NULL, *_3 = NULL, *_4 = NULL, *_5 = NULL; zval *_1; int ZEPHIR_LAST_CALL_STATUS; zephir_fcall_cache_entry *_0 = NULL, *_6 = NULL; ZEPHIR_MM_GROW(); ZEPHIR_CALL_PARENT(NULL, phalcon_di_factorydefault_ce, this_ptr, "__construct", &_0, 77); zephir_check_call_status(); ZEPHIR_INIT_VAR(_1); zephir_create_array(_1, 21, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_VAR(_3); ZVAL_STRING(_3, "router", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_VAR(_4); ZVAL_STRING(_4, "Phalcon\\Mvc\\Router", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_VAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("router"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "dispatcher", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Mvc\\Dispatcher", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("dispatcher"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "url", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Mvc\\Url", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("url"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "modelsManager", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Mvc\\Model\\Manager", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("modelsManager"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "modelsMetadata", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Mvc\\Model\\MetaData\\Memory", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("modelsMetadata"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "response", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Http\\Response", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("response"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "cookies", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Http\\Response\\Cookies", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("cookies"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "request", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Http\\Request", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("request"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "filter", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Filter", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("filter"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "escaper", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Escaper", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("escaper"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "security", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Security", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("security"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "crypt", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Crypt", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("crypt"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "annotations", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Annotations\\Adapter\\Memory", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("annotations"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "flash", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Flash\\Direct", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("flash"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "flashSession", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Flash\\Session", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("flashSession"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "tag", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Tag", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("tag"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "session", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Session\\Adapter\\Files", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("session"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "sessionBag", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Session\\Bag", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("sessionBag"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "eventsManager", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Events\\Manager", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("eventsManager"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "transactionManager", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Mvc\\Model\\Transaction\\Manager", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("transactionManager"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_service_ce); ZEPHIR_INIT_NVAR(_3); ZVAL_STRING(_3, "assets", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "Phalcon\\Assets\\Manager", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_NVAR(_5); ZVAL_BOOL(_5, 1); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, 65, _3, _4, _5); zephir_check_temp_parameter(_3); zephir_check_temp_parameter(_4); zephir_check_call_status(); zephir_array_update_string(&_1, SL("assets"), &_2, PH_COPY | PH_SEPARATE); zephir_update_property_this(this_ptr, SL("_services"), _1 TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Tries to render the view with every engine registered in the component * * @param string path * @param array params */ PHP_METHOD(Phalcon_Mvc_View_Simple, _internalRender) { HashTable *_4; HashPosition _3; zend_bool notExists = 0, mustClean = 0, _7$$8, _10$$8; zephir_fcall_cache_entry *_13 = NULL, *_16 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *path_param = NULL, *params, *eventsManager = NULL, *engines = NULL, *extension = NULL, *engine = NULL, *viewEnginePath = NULL, *viewsDirPath = NULL, *_2, **_5, *_0$$4 = NULL, *_1$$4, *_6$$6 = NULL, _8$$8 = zval_used_for_init, *_9$$8 = NULL, *_11$$12 = NULL, *_12$$12 = NULL, *_14$$11 = NULL, *_15$$14 = NULL, *_17$$15, *_18$$15, *_19$$16; zval *path = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &path_param, ¶ms); if (UNEXPECTED(Z_TYPE_P(path_param) != IS_STRING && Z_TYPE_P(path_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'path' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(path_param) == IS_STRING)) { zephir_get_strval(path, path_param); } else { ZEPHIR_INIT_VAR(path); ZVAL_EMPTY_STRING(path); } ZEPHIR_OBS_VAR(eventsManager); zephir_read_property_this(&eventsManager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (Z_TYPE_P(eventsManager) == IS_OBJECT) { zephir_update_property_this(getThis(), SL("_activeRenderPath"), path TSRMLS_CC); } if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(_1$$4); ZVAL_STRING(_1$$4, "view:beforeRender", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_0$$4, eventsManager, "fire", NULL, 0, _1$$4, this_ptr); zephir_check_temp_parameter(_1$$4); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(_0$$4)) { RETURN_MM_NULL(); } } notExists = 1; mustClean = 1; _2 = zephir_fetch_nproperty_this(this_ptr, SL("_viewsDir"), PH_NOISY_CC); ZEPHIR_INIT_VAR(viewsDirPath); ZEPHIR_CONCAT_VV(viewsDirPath, _2, path); ZEPHIR_CALL_METHOD(&engines, this_ptr, "_loadtemplateengines", NULL, 0); zephir_check_call_status(); zephir_is_iterable(engines, &_4, &_3, 0, 0, "phalcon/mvc/view/simple.zep", 282); for ( ; zend_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS ; zend_hash_move_forward_ex(_4, &_3) ) { ZEPHIR_GET_HMKEY(extension, _4, _3); ZEPHIR_GET_HVALUE(engine, _5); ZEPHIR_INIT_LNVAR(_6$$6); ZEPHIR_CONCAT_VV(_6$$6, viewsDirPath, extension); if ((zephir_file_exists(_6$$6 TSRMLS_CC) == SUCCESS)) { ZEPHIR_INIT_NVAR(viewEnginePath); ZEPHIR_CONCAT_VV(viewEnginePath, viewsDirPath, extension); } else { _7$$8 = zephir_is_true(extension); if (_7$$8) { ZEPHIR_SINIT_NVAR(_8$$8); ZVAL_LONG(&_8$$8, -zephir_fast_strlen_ev(extension)); ZEPHIR_INIT_NVAR(_9$$8); zephir_substr(_9$$8, viewsDirPath, zephir_get_intval(&_8$$8), 0, ZEPHIR_SUBSTR_NO_LENGTH); _7$$8 = ZEPHIR_IS_EQUAL(_9$$8, extension); } _10$$8 = _7$$8; if (_10$$8) { _10$$8 = (zephir_file_exists(viewsDirPath TSRMLS_CC) == SUCCESS); } if (_10$$8) { ZEPHIR_CPY_WRT(viewEnginePath, viewsDirPath); } else { ZEPHIR_INIT_NVAR(viewEnginePath); ZVAL_STRING(viewEnginePath, "", 1); } } if (zephir_is_true(viewEnginePath)) { if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_NVAR(_12$$12); ZVAL_STRING(_12$$12, "view:beforeRenderView", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_11$$12, eventsManager, "fire", &_13, 0, _12$$12, this_ptr, viewEnginePath); zephir_check_temp_parameter(_12$$12); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(_11$$12)) { continue; } } ZEPHIR_INIT_NVAR(_14$$11); if (mustClean) { ZVAL_BOOL(_14$$11, 1); } else { ZVAL_BOOL(_14$$11, 0); } ZEPHIR_CALL_METHOD(NULL, engine, "render", NULL, 0, viewEnginePath, params, _14$$11); zephir_check_call_status(); notExists = 0; if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_NVAR(_15$$14); ZVAL_STRING(_15$$14, "view:afterRenderView", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_16, 0, _15$$14, this_ptr); zephir_check_temp_parameter(_15$$14); zephir_check_call_status(); } break; } } if (notExists == 1) { ZEPHIR_INIT_VAR(_17$$15); object_init_ex(_17$$15, phalcon_mvc_view_exception_ce); ZEPHIR_INIT_VAR(_18$$15); ZEPHIR_CONCAT_SVS(_18$$15, "View '", viewsDirPath, "' was not found in the views directory"); ZEPHIR_CALL_METHOD(NULL, _17$$15, "__construct", NULL, 9, _18$$15); zephir_check_call_status(); zephir_throw_exception_debug(_17$$15, "phalcon/mvc/view/simple.zep", 283 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(_19$$16); ZVAL_STRING(_19$$16, "view:afterRender", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _19$$16, this_ptr); zephir_check_temp_parameter(_19$$16); zephir_check_call_status(); } ZEPHIR_MM_RESTORE(); }
/** * Executes the validation */ PHP_METHOD(Phalcon_Validation_Validator_Numericality, validate) { zend_bool _2; int ZEPHIR_LAST_CALL_STATUS; zval *field = NULL; zval *validation, *field_param = NULL, *value = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *_0 = NULL, *_1 = NULL, *_3, _4, *_5$$4 = NULL, *_7$$4 = NULL, *_8$$4, *_6$$6; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &validation, &field_param); if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(field_param) == IS_STRING)) { zephir_get_strval(field, field_param); } else { ZEPHIR_INIT_VAR(field); ZVAL_EMPTY_STRING(field); } ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field); zephir_check_call_status(); ZEPHIR_INIT_VAR(_1); ZVAL_STRING(_1, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_0, this_ptr, "issetoption", NULL, 0, _1); zephir_check_temp_parameter(_1); zephir_check_call_status(); _2 = zephir_is_true(_0); if (_2) { _2 = ZEPHIR_IS_EMPTY(value); } if (_2) { RETURN_MM_BOOL(1); } ZEPHIR_INIT_VAR(_3); ZEPHIR_INIT_NVAR(_1); ZEPHIR_SINIT_VAR(_4); ZVAL_STRING(&_4, "/^-?\\d+\\.?\\d*$/", 0); zephir_preg_match(_1, &_4, value, _3, 0, 0 , 0 TSRMLS_CC); if (!(zephir_is_true(_1))) { ZEPHIR_INIT_VAR(_5$$4); ZVAL_STRING(_5$$4, "label", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _5$$4); zephir_check_temp_parameter(_5$$4); zephir_check_call_status(); if (ZEPHIR_IS_EMPTY(label)) { ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_5$$4); ZVAL_STRING(_5$$4, "message", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _5$$4); zephir_check_temp_parameter(_5$$4); zephir_check_call_status(); ZEPHIR_INIT_VAR(replacePairs); zephir_create_array(replacePairs, 1, 0 TSRMLS_CC); zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE); if (ZEPHIR_IS_EMPTY(message)) { ZEPHIR_INIT_VAR(_6$$6); ZVAL_STRING(_6$$6, "Numericality", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _6$$6); zephir_check_temp_parameter(_6$$6); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_5$$4); object_init_ex(_5$$4, phalcon_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_7$$4, "strtr", NULL, 55, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_VAR(_8$$4); ZVAL_STRING(_8$$4, "Numericality", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _5$$4, "__construct", NULL, 434, _7$$4, field, _8$$4); zephir_check_temp_parameter(_8$$4); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _5$$4); zephir_check_call_status(); RETURN_MM_BOOL(0); } RETURN_MM_BOOL(1); }
/** * Returns a slice of the resultset to show in the pagination */ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilder, getPaginate) { int numberPage, before, ZEPHIR_LAST_CALL_STATUS; zval *originalBuilder, *builder, *totalBuilder, *totalPages, *limit, *number, *query = NULL, *page, *items = NULL, *totalQuery = NULL, *result = NULL, *row = NULL, *rowcount, *next = NULL, *_0, *_1 = NULL, *_2, _3, _4, *_5; ZEPHIR_MM_GROW(); ZEPHIR_OBS_VAR(originalBuilder); zephir_read_property_this(&originalBuilder, this_ptr, SL("_builder"), PH_NOISY_CC); ZEPHIR_INIT_VAR(builder); if (zephir_clone(builder, originalBuilder TSRMLS_CC) == FAILURE) { RETURN_MM(); } ZEPHIR_INIT_VAR(totalBuilder); if (zephir_clone(totalBuilder, builder TSRMLS_CC) == FAILURE) { RETURN_MM(); } ZEPHIR_OBS_VAR(limit); zephir_read_property_this(&limit, this_ptr, SL("_limitRows"), PH_NOISY_CC); ZEPHIR_OBS_VAR(_0); zephir_read_property_this(&_0, this_ptr, SL("_page"), PH_NOISY_CC); numberPage = zephir_get_intval(_0); if (!(numberPage)) { numberPage = 1; } ZEPHIR_INIT_VAR(number); ZVAL_LONG(number, (zephir_get_numberval(limit) * ((numberPage - 1)))); if (ZEPHIR_LT(number, limit)) { ZEPHIR_CALL_METHOD(NULL, builder, "limit", NULL, 0, limit); zephir_check_call_status(); } else { ZEPHIR_CALL_METHOD(NULL, builder, "limit", NULL, 0, limit, number); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&query, builder, "getquery", NULL, 0); zephir_check_call_status(); if (numberPage == 1) { before = 1; } else { before = (numberPage - 1); } ZEPHIR_CALL_METHOD(&items, query, "execute", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(_1); ZVAL_STRING(_1, "COUNT(*) [rowcount]", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, totalBuilder, "columns", NULL, 0, _1); zephir_check_temp_parameter(_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_1); ZVAL_NULL(_1); ZEPHIR_CALL_METHOD(NULL, totalBuilder, "orderby", NULL, 0, _1); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&totalQuery, totalBuilder, "getquery", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&result, totalQuery, "execute", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&row, result, "getfirst", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_VAR(_2); zephir_read_property(&_2, row, SL("rowcount"), PH_NOISY_CC); ZEPHIR_INIT_VAR(rowcount); ZVAL_LONG(rowcount, zephir_get_intval(_2)); ZEPHIR_SINIT_VAR(_3); div_function(&_3, rowcount, limit TSRMLS_CC); ZEPHIR_SINIT_VAR(_4); ZVAL_DOUBLE(&_4, zephir_ceil(&_3 TSRMLS_CC)); ZEPHIR_INIT_VAR(totalPages); ZVAL_LONG(totalPages, zephir_get_intval(&_4)); if (ZEPHIR_GT_LONG(totalPages, numberPage)) { ZEPHIR_INIT_VAR(next); ZVAL_LONG(next, (numberPage + 1)); } else { ZEPHIR_CPY_WRT(next, totalPages); } ZEPHIR_INIT_VAR(page); object_init(page); zephir_update_property_zval(page, SL("items"), items TSRMLS_CC); ZEPHIR_INIT_ZVAL_NREF(_5); ZVAL_LONG(_5, 1); zephir_update_property_zval(page, SL("first"), _5 TSRMLS_CC); ZEPHIR_INIT_ZVAL_NREF(_5); ZVAL_LONG(_5, before); zephir_update_property_zval(page, SL("before"), _5 TSRMLS_CC); ZEPHIR_INIT_ZVAL_NREF(_5); ZVAL_LONG(_5, numberPage); zephir_update_property_zval(page, SL("current"), _5 TSRMLS_CC); zephir_update_property_zval(page, SL("last"), totalPages TSRMLS_CC); zephir_update_property_zval(page, SL("next"), next TSRMLS_CC); zephir_update_property_zval(page, SL("total_pages"), totalPages TSRMLS_CC); zephir_update_property_zval(page, SL("total_items"), rowcount TSRMLS_CC); _5 = zephir_fetch_nproperty_this(this_ptr, SL("_limitRows"), PH_NOISY_CC); zephir_update_property_zval(page, SL("limit"), _5 TSRMLS_CC); RETURN_CCTOR(page); }
/** * Returns an array of prepared attributes for Phalcon\Tag helpers * according to the element parameters * * @param array attributes * @param boolean useChecked * @return array */ PHP_METHOD(Phalcon_Forms_Element, prepareAttributes) { int ZEPHIR_LAST_CALL_STATUS; zend_bool useChecked; zval *attributes = NULL, *useChecked_param = NULL, *value = NULL, *name = NULL, *widgetAttributes = NULL, *mergedAttributes = NULL, *defaultAttributes = NULL, *currentValue = NULL, *_0$$10, *_1$$12; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 2, &attributes, &useChecked_param); if (!attributes) { attributes = ZEPHIR_GLOBAL(global_null); } if (!useChecked_param) { useChecked = 0; } else { useChecked = zephir_get_boolval(useChecked_param); } ZEPHIR_OBS_VAR(name); zephir_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC); if (Z_TYPE_P(attributes) != IS_ARRAY) { ZEPHIR_INIT_VAR(widgetAttributes); array_init(widgetAttributes); } else { ZEPHIR_CPY_WRT(widgetAttributes, attributes); } zephir_array_update_long(&widgetAttributes, 0, &name, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY); ZEPHIR_OBS_VAR(defaultAttributes); zephir_read_property_this(&defaultAttributes, this_ptr, SL("_attributes"), PH_NOISY_CC); if (Z_TYPE_P(defaultAttributes) == IS_ARRAY) { ZEPHIR_INIT_VAR(mergedAttributes); zephir_fast_array_merge(mergedAttributes, &(defaultAttributes), &(widgetAttributes) TSRMLS_CC); } else { ZEPHIR_CPY_WRT(mergedAttributes, widgetAttributes); } ZEPHIR_CALL_METHOD(&value, this_ptr, "getvalue", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(value) != IS_NULL) { if (useChecked) { if (zephir_array_isset_string_fetch(¤tValue, mergedAttributes, SS("value"), 1 TSRMLS_CC)) { if (ZEPHIR_IS_EQUAL(currentValue, value)) { ZEPHIR_INIT_VAR(_0$$10); ZVAL_STRING(_0$$10, "checked", 1); zephir_array_update_string(&mergedAttributes, SL("checked"), &_0$$10, PH_COPY | PH_SEPARATE); } } else { if (zephir_is_true(value)) { ZEPHIR_INIT_VAR(_1$$12); ZVAL_STRING(_1$$12, "checked", 1); zephir_array_update_string(&mergedAttributes, SL("checked"), &_1$$12, PH_COPY | PH_SEPARATE); } zephir_array_update_string(&mergedAttributes, SL("value"), &value, PH_COPY | PH_SEPARATE); } } else { zephir_array_update_string(&mergedAttributes, SL("value"), &value, PH_COPY | PH_SEPARATE); } } RETURN_CCTOR(mergedAttributes); }
/** * Phalcon\Mvc\Model\MetaData\Memcache constructor * * @param array options */ PHP_METHOD(Phalcon_Mvc_Model_MetaData_Memcache, __construct) { int ZEPHIR_LAST_CALL_STATUS; zval *_2; zval *options = NULL, *ttl, *_0 = NULL, *_1, *_3, *_4; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &options); if (!options) { ZEPHIR_CPY_WRT(options, ZEPHIR_GLOBAL(global_null)); } else { ZEPHIR_SEPARATE_PARAM(options); } if (Z_TYPE_P(options) != IS_ARRAY) { ZEPHIR_INIT_NVAR(options); array_init(options); } if (!(zephir_array_isset_string(options, SS("host")))) { ZEPHIR_INIT_VAR(_0); ZVAL_STRING(_0, "127.0.0.1", 1); zephir_array_update_string(&options, SL("host"), &_0, PH_COPY | PH_SEPARATE); } if (!(zephir_array_isset_string(options, SS("port")))) { ZEPHIR_INIT_NVAR(_0); ZVAL_LONG(_0, 11211); zephir_array_update_string(&options, SL("port"), &_0, PH_COPY | PH_SEPARATE); } if (!(zephir_array_isset_string(options, SS("persistent")))) { ZEPHIR_INIT_NVAR(_0); ZVAL_LONG(_0, 0); zephir_array_update_string(&options, SL("persistent"), &_0, PH_COPY | PH_SEPARATE); } if (!(zephir_array_isset_string(options, SS("statsKey")))) { ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "_PHCM_MM", 1); zephir_array_update_string(&options, SL("statsKey"), &_0, PH_COPY | PH_SEPARATE); } if (zephir_array_isset_string_fetch(&ttl, options, SS("lifetime"), 1 TSRMLS_CC)) { zephir_update_property_this(this_ptr, SL("_ttl"), ttl TSRMLS_CC); } ZEPHIR_INIT_NVAR(_0); object_init_ex(_0, phalcon_cache_backend_memcache_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("_ttl"), PH_NOISY_CC); zephir_array_update_string(&_2, SL("lifetime"), &_3, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 318, _2); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 321, _1, options); zephir_check_call_status(); zephir_update_property_this(this_ptr, SL("_memcache"), _0 TSRMLS_CC); ZEPHIR_INIT_VAR(_4); array_init(_4); zephir_update_property_this(this_ptr, SL("_metaData"), _4 TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Initialize the metadata for certain table */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, _initialize) { zephir_fcall_cache_entry *_2 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *model, *key, *table, *schema, *strategy = NULL, *className = NULL, *metaData = NULL, *data = NULL, *modelMetadata = NULL, *modelColumnMap = NULL, *dependencyInjector = NULL, *keyName = NULL, *prefixKey = NULL, *_3, *_0$$8, *_1$$8; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 4, 0, &model, &key, &table, &schema); ZEPHIR_INIT_VAR(strategy); ZVAL_NULL(strategy); ZEPHIR_INIT_VAR(className); zephir_get_class(className, model, 0 TSRMLS_CC); if (Z_TYPE_P(key) != IS_NULL) { ZEPHIR_OBS_VAR(metaData); zephir_read_property_this(&metaData, this_ptr, SL("_metaData"), PH_NOISY_CC); if (!(zephir_array_isset(metaData, key))) { ZEPHIR_INIT_VAR(prefixKey); ZEPHIR_CONCAT_SV(prefixKey, "meta-", key); ZEPHIR_CALL_METHOD(&data, this_ptr, "read", NULL, 0, prefixKey); zephir_check_call_status(); if (Z_TYPE_P(data) != IS_NULL) { zephir_update_property_array(this_ptr, SL("_metaData"), key, data TSRMLS_CC); } else { if ((zephir_method_exists_ex(model, SS("metadata") TSRMLS_CC) == SUCCESS)) { ZEPHIR_CALL_METHOD(&modelMetadata, model, "metadata", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(modelMetadata) != IS_ARRAY) { ZEPHIR_INIT_VAR(_0$$8); object_init_ex(_0$$8, phalcon_mvc_model_exception_ce); ZEPHIR_INIT_VAR(_1$$8); ZEPHIR_CONCAT_SV(_1$$8, "Invalid meta-data for model ", className); ZEPHIR_CALL_METHOD(NULL, _0$$8, "__construct", NULL, 9, _1$$8); zephir_check_call_status(); zephir_throw_exception_debug(_0$$8, "phalcon/mvc/model/metadata.zep", 122 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } } else { ZEPHIR_OBS_VAR(dependencyInjector); zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&strategy, this_ptr, "getstrategy", &_2, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&modelMetadata, strategy, "getmetadata", NULL, 0, model, dependencyInjector); zephir_check_call_status(); } zephir_update_property_array(this_ptr, SL("_metaData"), key, modelMetadata TSRMLS_CC); ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, prefixKey, modelMetadata); zephir_check_call_status(); } } } if (!(ZEPHIR_GLOBAL(orm).column_renaming)) { RETURN_MM_NULL(); } ZEPHIR_INIT_VAR(keyName); zephir_fast_strtolower(keyName, className); _3 = zephir_fetch_nproperty_this(this_ptr, SL("_columnMap"), PH_NOISY_CC); if (zephir_array_isset(_3, keyName)) { RETURN_MM_NULL(); } ZEPHIR_INIT_NVAR(prefixKey); ZEPHIR_CONCAT_SV(prefixKey, "map-", keyName); ZEPHIR_CALL_METHOD(&data, this_ptr, "read", NULL, 0, prefixKey); zephir_check_call_status(); if (Z_TYPE_P(data) != IS_NULL) { zephir_update_property_array(this_ptr, SL("_columnMap"), keyName, data TSRMLS_CC); RETURN_MM_NULL(); } if (Z_TYPE_P(strategy) != IS_OBJECT) { ZEPHIR_OBS_NVAR(dependencyInjector); zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&strategy, this_ptr, "getstrategy", &_2, 0); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&modelColumnMap, strategy, "getcolumnmaps", NULL, 0, model, dependencyInjector); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("_columnMap"), keyName, modelColumnMap TSRMLS_CC); ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, prefixKey, modelColumnMap); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); }