/** * Returns an array of Phalcon\Db\Column objects describing a table * * <code>print_r($connection->describeColumns("posts")); ?></code> * * @param string $table * @param string $schema * @return Phalcon\Db\Column[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Oracle, describeColumns) { zval *table, *schema = NULL, *columns, *dialect, *sql = NULL, *fetch_num; zval *describe = NULL, *old_column = NULL, *field = NULL, *definition = NULL; zval *column_size = NULL, *column_precision = NULL, *column_scale = NULL; zval *column_type = NULL, *attribute = NULL, *column_name = NULL; zval *column = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &table, &schema); if (!schema) { schema = PHALCON_GLOBAL(z_null); } PHALCON_INIT_VAR(columns); array_init(columns); PHALCON_OBS_VAR(dialect); phalcon_read_property_this(&dialect, this_ptr, SL("_dialect"), PH_NOISY TSRMLS_CC); PHALCON_CALL_METHOD(&sql, dialect, "describecolumns", table, schema); /** * We're using FETCH_NUM to fetch the columns */ PHALCON_INIT_VAR(fetch_num); ZVAL_LONG(fetch_num, PDO_FETCH_NUM); PHALCON_CALL_METHOD(&describe, this_ptr, "fetchall", sql, fetch_num); /** * 0:column_name, 1:data_type, 2:data_length, 3:data_precision, 4:data_scale, * 5:nullable, 6:constraint_type, 7:default, 8:position; */ PHALCON_INIT_VAR(old_column); phalcon_is_iterable(describe, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(field); PHALCON_INIT_NVAR(definition); array_init_size(definition, 1); add_assoc_long_ex(definition, SS("bindType"), 2); PHALCON_OBS_NVAR(column_size); phalcon_array_fetch_long(&column_size, field, 2, PH_NOISY); PHALCON_OBS_NVAR(column_precision); phalcon_array_fetch_long(&column_precision, field, 3, PH_NOISY); PHALCON_OBS_NVAR(column_scale); phalcon_array_fetch_long(&column_scale, field, 4, PH_NOISY); PHALCON_OBS_NVAR(column_type); phalcon_array_fetch_long(&column_type, field, 1, PH_NOISY); /** * Check the column type to get the correct Phalcon type */ while (1) { /** * Integer */ if (phalcon_memnstr_str(column_type, SL("NUMBER"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DECIMAL, PH_COPY); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY); phalcon_array_update_string(&definition, SL("size"), column_precision, PH_COPY); phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_COPY); if (phalcon_is_numeric(column_precision)) { phalcon_array_update_string_long(&definition, SL("bytes"), Z_LVAL_P(column_precision) * 8, PH_COPY); } else { phalcon_array_update_string_long(&definition, SL("size"), 30, PH_COPY); phalcon_array_update_string_long(&definition, SL("bytes"), 80, PH_COPY); } if (phalcon_is_numeric(column_scale)) { phalcon_array_update_string(&definition, SL("scale"), column_scale, PH_COPY); } else { phalcon_array_update_string_long(&definition, SL("scale"), 6, PH_COPY); } break; } /** * Tinyint(1) is boolean */ if (phalcon_memnstr_str(column_type, SL("TINYINT(1)"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_BOOLEAN, PH_COPY); phalcon_array_update_string_long(&definition, SL("bindType"), 5, PH_COPY); break; } /** * Smallint/Bigint/Integers/Int are int */ if (phalcon_memnstr_str(column_type, SL("INTEGER"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_INTEGER, PH_COPY); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY); phalcon_array_update_string(&definition, SL("size"), column_precision, PH_COPY); phalcon_array_update_string_long(&definition, SL("bindType"), 1, PH_COPY); phalcon_array_update_string_long(&definition, SL("bytes"), 32, PH_COPY); break; } /** * Float/Smallfloats/Decimals are float */ if (phalcon_memnstr_str(column_type, SL("FLOAT"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_FLOAT, PH_COPY); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY); phalcon_array_update_string(&definition, SL("size"), column_size, PH_COPY); phalcon_array_update_string(&definition, SL("scale"), column_scale, PH_COPY); phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_COPY); break; } /** * Date */ if (phalcon_memnstr_str(column_type, SL("TIMESTAMP"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DATE, PH_COPY); break; } /** * Text */ if (phalcon_memnstr_str(column_type, SL("RAW"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_TEXT, PH_COPY); break; } /** * Text */ if (phalcon_memnstr_str(column_type, SL("BLOB"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_TEXT, PH_COPY); break; } /** * Text */ if (phalcon_memnstr_str(column_type, SL("CLOB"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_TEXT, PH_COPY); break; } /** * Chars2 are string */ if (phalcon_memnstr_str(column_type, SL("VARCHAR2"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_VARCHAR, PH_COPY); phalcon_array_update_string(&definition, SL("size"), column_size, PH_COPY); break; } /** * Chars are chars */ if (phalcon_memnstr_str(column_type, SL("CHAR"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_CHAR, PH_COPY); phalcon_array_update_string(&definition, SL("size"), column_size, PH_COPY); break; } /** * Text are varchars */ if (phalcon_memnstr_str(column_type, SL("text"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_TEXT, PH_COPY); break; } /** * By default is string */ phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_VARCHAR, PH_COPY); break; } if (Z_TYPE_P(old_column) == IS_NULL) { phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_COPY); } else { phalcon_array_update_string(&definition, SL("after"), old_column, PH_COPY); } /** * Check if the field is primary key */ PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_long(&attribute, field, 6, PH_NOISY); if (PHALCON_IS_STRING(attribute, "P")) { phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_COPY); } /** * Check if the column allows null values */ PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_long(&attribute, field, 5, PH_NOISY); if (PHALCON_IS_STRING(attribute, "N")) { phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_COPY); } PHALCON_OBS_NVAR(column_name); phalcon_array_fetch_long(&column_name, field, 0, PH_NOISY); /** * If the column set the default values, get it */ PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_long(&attribute, field, 7, PH_NOISY); if (!PHALCON_IS_EMPTY(attribute)) { phalcon_array_update_string(&definition, SL("default"), attribute, PH_COPY); } /** * Create a Phalcon\Db\Column to abstract the column */ PHALCON_INIT_NVAR(column); object_init_ex(column, phalcon_db_column_ce); PHALCON_CALL_METHOD(NULL, column, "__construct", column_name, definition); phalcon_array_append(&columns, column, PH_COPY); PHALCON_CPY_WRT(old_column, column_name); zend_hash_move_forward_ex(ah0, &hp0); } RETURN_CTOR(columns); }
/* {{{ proto boolean XMLReader::XML(string source [, string encoding [, int options]]) Sets the string that the XMLReader will parse. */ PHP_METHOD(xmlreader, XML) { zval *id; size_t source_len = 0, encoding_len = 0; zend_long options = 0; xmlreader_object *intern = NULL; char *source, *uri = NULL, *encoding = NULL; int resolved_path_len, ret = 0; char *directory=NULL, resolved_path[MAXPATHLEN]; xmlParserInputBufferPtr inputbfr; xmlTextReaderPtr reader; if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s!l", &source, &source_len, &encoding, &encoding_len, &options) == FAILURE) { return; } id = getThis(); if (id != NULL && ! instanceof_function(Z_OBJCE_P(id), xmlreader_class_entry)) { id = NULL; } if (id != NULL) { intern = Z_XMLREADER_P(id); xmlreader_free_resources(intern); } if (!source_len) { php_error_docref(NULL, E_WARNING, "Empty string supplied as input"); RETURN_FALSE; } inputbfr = xmlParserInputBufferCreateMem(source, source_len, XML_CHAR_ENCODING_NONE); if (inputbfr != NULL) { /* Get the URI of the current script so that we can set the base directory in libxml */ #if HAVE_GETCWD directory = VCWD_GETCWD(resolved_path, MAXPATHLEN); #elif HAVE_GETWD directory = VCWD_GETWD(resolved_path); #endif if (directory) { resolved_path_len = strlen(resolved_path); if (resolved_path[resolved_path_len - 1] != DEFAULT_SLASH) { resolved_path[resolved_path_len] = DEFAULT_SLASH; resolved_path[++resolved_path_len] = '\0'; } uri = (char *) xmlCanonicPath((const xmlChar *) resolved_path); } reader = xmlNewTextReader(inputbfr, uri); if (reader != NULL) { #if LIBXML_VERSION >= 20628 ret = xmlTextReaderSetup(reader, NULL, uri, encoding, options); #endif if (ret == 0) { if (id == NULL) { object_init_ex(return_value, xmlreader_class_entry); intern = Z_XMLREADER_P(return_value); } else { RETVAL_TRUE; } intern->input = inputbfr; intern->ptr = reader; if (uri) { xmlFree(uri); } return; } } } if (uri) { xmlFree(uri); } if (inputbfr) { xmlFreeParserInputBuffer(inputbfr); } php_error_docref(NULL, E_WARNING, "Unable to load source data"); RETURN_FALSE; }
/** * 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 *field = NULL; zval *validation, *field_param = NULL, *_SERVER, *_POST, *_FILES, *value = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *types = NULL, *byteUnits = NULL, *unit = NULL, *maxSize = NULL, *matches = NULL, *bytes = NULL, *mime = NULL, *tmp = NULL, *width = NULL, *height = NULL, *minResolution = NULL, *maxResolution = NULL, *minWidth = NULL, *maxWidth = NULL, *minHeight = NULL, *maxHeight = NULL, *fieldTypes = NULL, *code = NULL, *minResolutionArray = NULL, *maxResolutionArray = NULL, *_0, *_4, *_7, *_13, *_15, *_16 = NULL, *_25 = NULL, *_26 = NULL, *_42 = NULL, *_49 = NULL, *_51 = NULL, *_8$$3 = NULL, *_9$$3 = NULL, *_10$$3 = NULL, *_17$$4 = NULL, *_18$$4 = NULL, *_19$$4 = NULL, *_22$$5 = NULL, *_23$$5 = NULL, *_24$$5 = NULL, *_27$$6 = NULL, *_29$$6, *_30$$6, *_31$$6, *_32$$6, *_33$$6 = NULL, *_34$$6, *_35$$6, _36$$6, *_37$$6, *_38$$6 = NULL, *_28$$7, *_39$$9 = NULL, *_40$$9 = NULL, *_41$$9 = NULL, *_43$$10, _44$$13, *_45$$13, *_46$$15 = NULL, *_47$$15 = NULL, *_48$$15 = NULL, *_52$$16, *_53$$16 = NULL, *_54$$16 = NULL, *_61$$16 = NULL, *_55$$17, *_56$$18, *_58$$20 = NULL, *_59$$20 = NULL, *_60$$20 = NULL, *_62$$21, *_63$$22, *_65$$23 = NULL, *_66$$23 = NULL, *_67$$23 = NULL; ZEPHIR_MM_GROW(); zephir_get_global(&_FILES, SS("_FILES") TSRMLS_CC); zephir_get_global(&_POST, SS("_POST") TSRMLS_CC); zephir_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC); 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_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", 112 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", 112 TSRMLS_CC); _3 = ZEPHIR_GT_LONG(_4, 0); } _5 = _3; if (!(_5)) { _6 = zephir_array_isset_string(value, SS("error")); if (_6) { zephir_array_fetch_string(&_7, value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 112 TSRMLS_CC); _6 = ZEPHIR_IS_LONG_IDENTICAL(_7, 1); } _5 = _6; } if (_5) { ZEPHIR_INIT_VAR(_8$$3); ZVAL_STRING(_8$$3, "FileIniSize", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_VAR(_9$$3); ZVAL_STRING(_9$$3, "messageIniSize", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _8$$3, _9$$3); zephir_check_temp_parameter(_8$$3); zephir_check_temp_parameter(_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_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_10$$3, "strtr", NULL, 27, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_9$$3); ZVAL_STRING(_9$$3, "FileIniSize", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _8$$3, "__construct", NULL, 470, _10$$3, field, _9$$3, code); zephir_check_temp_parameter(_9$$3); 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, SS("error"))); if (!(_11)) { _11 = !(zephir_array_isset_string(value, SS("tmp_name"))); } _12 = _11; if (!(_12)) { zephir_array_fetch_string(&_13, value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 128 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", 128 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&_16, "is_uploaded_file", NULL, 247, _15); zephir_check_call_status(); _14 = !zephir_is_true(_16); } if (_14) { ZEPHIR_INIT_VAR(_17$$4); ZVAL_STRING(_17$$4, "FileEmpty", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_VAR(_18$$4); ZVAL_STRING(_18$$4, "messageEmpty", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _17$$4, _18$$4); zephir_check_temp_parameter(_17$$4); zephir_check_temp_parameter(_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_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_19$$4, "strtr", NULL, 27, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_18$$4); ZVAL_STRING(_18$$4, "FileEmpty", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _17$$4, "__construct", NULL, 470, _19$$4, field, _18$$4, code); zephir_check_temp_parameter(_18$$4); 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, SS("name"))); if (!(_20)) { _20 = !(zephir_array_isset_string(value, SS("type"))); } _21 = _20; if (!(_21)) { _21 = !(zephir_array_isset_string(value, SS("size"))); } if (_21) { ZEPHIR_INIT_VAR(_22$$5); ZVAL_STRING(_22$$5, "FileValid", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_VAR(_23$$5); ZVAL_STRING(_23$$5, "messageValid", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _22$$5, _23$$5); zephir_check_temp_parameter(_22$$5); zephir_check_temp_parameter(_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_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_24$$5, "strtr", NULL, 27, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_23$$5); ZVAL_STRING(_23$$5, "FileValid", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _22$$5, "__construct", NULL, 470, _24$$5, field, _23$$5, code); zephir_check_temp_parameter(_23$$5); 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_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_25, this_ptr, "hasoption", NULL, 0, _26); zephir_check_temp_parameter(_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, SS("B"), 0); add_assoc_long_ex(byteUnits, SS("K"), 10); add_assoc_long_ex(byteUnits, SS("M"), 20); add_assoc_long_ex(byteUnits, SS("G"), 30); add_assoc_long_ex(byteUnits, SS("T"), 40); add_assoc_long_ex(byteUnits, SS("KB"), 10); add_assoc_long_ex(byteUnits, SS("MB"), 20); add_assoc_long_ex(byteUnits, SS("GB"), 30); add_assoc_long_ex(byteUnits, SS("TB"), 40); ZEPHIR_INIT_VAR(_27$$6); ZVAL_STRING(_27$$6, "maxSize", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&maxSize, this_ptr, "getoption", NULL, 0, _27$$6); zephir_check_temp_parameter(_27$$6); zephir_check_call_status(); ZEPHIR_INIT_VAR(matches); ZVAL_NULL(matches); ZEPHIR_INIT_VAR(unit); ZVAL_STRING(unit, "B", 1); if (Z_TYPE_P(maxSize) == IS_ARRAY) { zephir_array_fetch(&_28$$7, maxSize, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 168 TSRMLS_CC); ZEPHIR_CPY_WRT(maxSize, _28$$7); } ZEPHIR_INIT_NVAR(_27$$6); ZEPHIR_INIT_VAR(_29$$6); ZEPHIR_INIT_VAR(_30$$6); zephir_array_keys(_30$$6, byteUnits TSRMLS_CC); zephir_fast_join_str(_29$$6, SL("|"), _30$$6 TSRMLS_CC); ZEPHIR_INIT_VAR(_31$$6); ZEPHIR_CONCAT_SVS(_31$$6, "/^([0-9]+(?:\\.[0-9]+)?)(", _29$$6, ")?$/Di"); zephir_preg_match(_27$$6, _31$$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", 174 TSRMLS_CC); } zephir_array_fetch_long(&_32$$6, matches, 1, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 177 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&_33$$6, "floatval", NULL, 323, _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", 177 TSRMLS_CC); ZEPHIR_SINIT_VAR(_36$$6); 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", 179 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&_33$$6, "floatval", NULL, 323, _37$$6); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_38$$6, "floatval", NULL, 323, bytes); zephir_check_call_status(); if (ZEPHIR_GT(_33$$6, _38$$6)) { ZEPHIR_INIT_VAR(_39$$9); ZVAL_STRING(_39$$9, "FileSize", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_VAR(_40$$9); ZVAL_STRING(_40$$9, "messageSize", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _39$$9, _40$$9); zephir_check_temp_parameter(_39$$9); zephir_check_temp_parameter(_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_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_41$$9, "strtr", NULL, 27, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_40$$9); ZVAL_STRING(_40$$9, "FileSize", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _39$$9, "__construct", NULL, 470, _41$$9, field, _40$$9, code); zephir_check_temp_parameter(_40$$9); 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_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_42, this_ptr, "hasoption", NULL, 0, _26); zephir_check_temp_parameter(_26); zephir_check_call_status(); if (zephir_is_true(_42)) { ZEPHIR_INIT_VAR(_43$$10); ZVAL_STRING(_43$$10, "allowedTypes", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&types, this_ptr, "getoption", NULL, 0, _43$$10); zephir_check_temp_parameter(_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", 205); return; } if ((zephir_function_exists_ex(SS("finfo_open") TSRMLS_CC) == SUCCESS)) { ZEPHIR_SINIT_VAR(_44$$13); ZVAL_LONG(&_44$$13, 16); ZEPHIR_CALL_FUNCTION(&tmp, "finfo_open", NULL, 244, &_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", 210 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 245, tmp, _45$$13); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(NULL, "finfo_close", NULL, 246, 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", 214 TSRMLS_CC); } if (!(zephir_fast_in_array(mime, types TSRMLS_CC))) { ZEPHIR_INIT_VAR(_46$$15); ZVAL_STRING(_46$$15, "FileType", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_VAR(_47$$15); ZVAL_STRING(_47$$15, "messageType", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _46$$15, _47$$15); zephir_check_temp_parameter(_46$$15); zephir_check_temp_parameter(_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_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_48$$15, "strtr", NULL, 27, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_47$$15); ZVAL_STRING(_47$$15, "FileType", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _46$$15, "__construct", NULL, 470, _48$$15, field, _47$$15, code); zephir_check_temp_parameter(_47$$15); 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_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_49, this_ptr, "hasoption", NULL, 0, _26); zephir_check_temp_parameter(_26); zephir_check_call_status(); _50 = zephir_is_true(_49); if (!(_50)) { ZEPHIR_INIT_NVAR(_26); ZVAL_STRING(_26, "maxResolution", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_51, this_ptr, "hasoption", NULL, 0, _26); zephir_check_temp_parameter(_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", 235 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", NULL, 255, _52$$16); zephir_check_call_status(); ZEPHIR_OBS_VAR(width); zephir_array_fetch_long(&width, tmp, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 236 TSRMLS_CC); ZEPHIR_OBS_VAR(height); zephir_array_fetch_long(&height, tmp, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 237 TSRMLS_CC); ZEPHIR_INIT_VAR(_54$$16); ZVAL_STRING(_54$$16, "minResolution", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_53$$16, this_ptr, "hasoption", NULL, 0, _54$$16); zephir_check_temp_parameter(_54$$16); zephir_check_call_status(); if (zephir_is_true(_53$$16)) { ZEPHIR_INIT_VAR(_55$$17); ZVAL_STRING(_55$$17, "minResolution", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&minResolution, this_ptr, "getoption", NULL, 0, _55$$17); zephir_check_temp_parameter(_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", 242 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", 245 TSRMLS_CC); ZEPHIR_OBS_VAR(minHeight); zephir_array_fetch_long(&minHeight, minResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 246 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_TEMP_PARAM_COPY); ZEPHIR_INIT_VAR(_59$$20); ZVAL_STRING(_59$$20, "messageMinResolution", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _58$$20, _59$$20); zephir_check_temp_parameter(_58$$20); zephir_check_temp_parameter(_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_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_60$$20, "strtr", NULL, 27, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_59$$20); ZVAL_STRING(_59$$20, "FileMinResolution", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _58$$20, "__construct", NULL, 470, _60$$20, field, _59$$20, code); zephir_check_temp_parameter(_59$$20); 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_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_61$$16, this_ptr, "hasoption", NULL, 0, _54$$16); zephir_check_temp_parameter(_54$$16); zephir_check_call_status(); if (zephir_is_true(_61$$16)) { ZEPHIR_INIT_VAR(_62$$21); ZVAL_STRING(_62$$21, "maxResolution", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&maxResolution, this_ptr, "getoption", NULL, 0, _62$$21); zephir_check_temp_parameter(_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", 272 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", 275 TSRMLS_CC); ZEPHIR_OBS_VAR(maxHeight); zephir_array_fetch_long(&maxHeight, maxResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 276 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_TEMP_PARAM_COPY); ZEPHIR_INIT_VAR(_66$$23); ZVAL_STRING(_66$$23, "messageMaxResolution", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _65$$23, _66$$23); zephir_check_temp_parameter(_65$$23); zephir_check_temp_parameter(_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_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_67$$23, "strtr", NULL, 27, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_66$$23); ZVAL_STRING(_66$$23, "FileMaxResolution", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _65$$23, "__construct", NULL, 470, _67$$23, field, _66$$23, code); zephir_check_temp_parameter(_66$$23); 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); }
/** * Resolves the service based on its configuration * * @param string name * @param array parameters * @return mixed */ PHP_METHOD(Phalcon_Di, get) { zephir_nts_static zephir_fcall_cache_entry *_4 = NULL, *_5 = NULL, *_6 = NULL, *_8 = NULL; zval *_1 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *name_param = NULL, *parameters = NULL, *service, *instance = NULL, *reflection = NULL, *eventsManager = NULL, *_0 = NULL, *_2 = NULL, *_3; zval *name = NULL, *_7; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &name_param, ¶meters); if (unlikely(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(name_param) == IS_STRING)) { zephir_get_strval(name, name_param); } else { ZEPHIR_INIT_VAR(name); ZVAL_EMPTY_STRING(name); } if (!parameters) { parameters = ZEPHIR_GLOBAL(global_null); } ZEPHIR_CALL_METHOD(&_0, this_ptr, "geteventsmanager", NULL); zephir_check_call_status(); ZEPHIR_CPY_WRT(eventsManager, _0); if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(_1); zephir_create_array(_1, 2, 0 TSRMLS_CC); zephir_array_update_string(&_1, SL("name"), &name, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_1, SL("parameters"), ¶meters, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_VAR(_2); ZVAL_STRING(_2, "di:beforeServiceResolve", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, _2, this_ptr, _1); zephir_check_temp_parameter(_2); zephir_check_call_status(); } ZEPHIR_OBS_VAR(service); _3 = zephir_fetch_nproperty_this(this_ptr, SL("_services"), PH_NOISY_CC); if (zephir_array_isset_fetch(&service, _3, name, 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(&instance, service, "resolve", NULL, parameters, this_ptr); zephir_check_call_status(); } else { if (zephir_class_exists(name, 1 TSRMLS_CC)) { if (Z_TYPE_P(parameters) == IS_ARRAY) { if (zephir_fast_count_int(parameters TSRMLS_CC)) { if (zephir_is_php_version(50600)) { ZEPHIR_INIT_VAR(reflection); object_init_ex(reflection, zephir_get_internal_ce(SS("reflectionclass") TSRMLS_CC)); ZEPHIR_CALL_METHOD(NULL, reflection, "__construct", &_4, name); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&instance, reflection, "newinstanceargs", &_5, parameters); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(instance); ZEPHIR_LAST_CALL_STATUS = zephir_create_instance_params(instance, name, parameters TSRMLS_CC); zephir_check_call_status(); } } else { if (zephir_is_php_version(50600)) { ZEPHIR_INIT_NVAR(reflection); object_init_ex(reflection, zephir_get_internal_ce(SS("reflectionclass") TSRMLS_CC)); ZEPHIR_CALL_METHOD(NULL, reflection, "__construct", &_4, name); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&instance, reflection, "newinstance", &_6); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(instance); ZEPHIR_LAST_CALL_STATUS = zephir_create_instance(instance, name TSRMLS_CC); zephir_check_call_status(); } } } else { if (zephir_is_php_version(50600)) { ZEPHIR_INIT_NVAR(reflection); object_init_ex(reflection, zephir_get_internal_ce(SS("reflectionclass") TSRMLS_CC)); ZEPHIR_CALL_METHOD(NULL, reflection, "__construct", &_4, name); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&instance, reflection, "newinstance", &_6); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(instance); ZEPHIR_LAST_CALL_STATUS = zephir_create_instance(instance, name TSRMLS_CC); zephir_check_call_status(); } } } else { ZEPHIR_INIT_NVAR(_2); object_init_ex(_2, phalcon_di_exception_ce); ZEPHIR_INIT_VAR(_7); ZEPHIR_CONCAT_SVS(_7, "Service '", name, "' wasn't found in the dependency injection container"); ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_8, _7); zephir_check_call_status(); zephir_throw_exception_debug(_2, "phalcon/di.zep", 246 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } } if (Z_TYPE_P(instance) == IS_OBJECT) { if (zephir_instance_of_ev(instance, phalcon_di_injectionawareinterface_ce TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, instance, "setdi", NULL, this_ptr); zephir_check_call_status(); } } if (Z_TYPE_P(eventsManager) == IS_OBJECT) { if (Z_TYPE_P(instance) == IS_OBJECT) { if (zephir_instance_of_ev(instance, phalcon_events_eventsawareinterface_ce TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, instance, "seteventsmanager", NULL, eventsManager); zephir_check_call_status(); } } ZEPHIR_INIT_NVAR(_1); zephir_create_array(_1, 3, 0 TSRMLS_CC); zephir_array_update_string(&_1, SL("name"), &name, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_1, SL("parameters"), ¶meters, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_1, SL("instance"), &instance, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(_2); ZVAL_STRING(_2, "di:afterServiceResolve", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, _2, this_ptr, _1); zephir_check_temp_parameter(_2); zephir_check_call_status(); } RETURN_CCTOR(instance); }
static int do_cli(int argc, char **argv) /* {{{ */ { int c; zend_file_handle file_handle; int behavior = PHP_MODE_STANDARD; char *reflection_what = NULL; volatile int request_started = 0; volatile int exit_status = 0; char *php_optarg = NULL, *orig_optarg = NULL; int php_optind = 1, orig_optind = 1; char *exec_direct=NULL, *exec_run=NULL, *exec_begin=NULL, *exec_end=NULL; char *arg_free=NULL, **arg_excp=&arg_free; char *script_file=NULL, *translated_path = NULL; int interactive=0; int lineno = 0; const char *param_error=NULL; int hide_argv = 0; zend_try { CG(in_compilation) = 0; /* not initialized but needed for several options */ while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) { switch (c) { case 'i': /* php info & quit */ if (php_request_startup()==FAILURE) { goto err; } request_started = 1; php_print_info(0xFFFFFFFF); php_output_end_all(); exit_status = (c == '?' && argc > 1 && !strchr(argv[1], c)); goto out; case 'v': /* show php version & quit */ php_printf("PHP %s (%s) (built: %s %s) ( %s)\nCopyright (c) 1997-2017 The PHP Group\n%s", PHP_VERSION, cli_sapi_module.name, __DATE__, __TIME__, #if ZTS "ZTS " #else "NTS " #endif #ifdef COMPILER COMPILER " " #endif #ifdef ARCHITECTURE ARCHITECTURE " " #endif #if ZEND_DEBUG "DEBUG " #endif #ifdef HAVE_GCOV "GCOV " #endif , get_zend_version() ); sapi_deactivate(); goto out; case 'm': /* list compiled in modules */ if (php_request_startup()==FAILURE) { goto err; } request_started = 1; php_printf("[PHP Modules]\n"); print_modules(); php_printf("\n[Zend Modules]\n"); print_extensions(); php_printf("\n"); php_output_end_all(); exit_status=0; goto out; default: break; } } /* Set some CLI defaults */ SG(options) |= SAPI_OPTION_NO_CHDIR; php_optind = orig_optind; php_optarg = orig_optarg; while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) { switch (c) { case 'a': /* interactive mode */ if (!interactive) { if (behavior != PHP_MODE_STANDARD) { param_error = param_mode_conflict; break; } interactive=1; } break; case 'C': /* don't chdir to the script directory */ /* This is default so NOP */ break; case 'F': if (behavior == PHP_MODE_PROCESS_STDIN) { if (exec_run || script_file) { param_error = "You can use -R or -F only once.\n"; break; } } else if (behavior != PHP_MODE_STANDARD) { param_error = param_mode_conflict; break; } behavior=PHP_MODE_PROCESS_STDIN; script_file = php_optarg; break; case 'f': /* parse file */ if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) { param_error = param_mode_conflict; break; } else if (script_file) { param_error = "You can use -f only once.\n"; break; } script_file = php_optarg; break; case 'l': /* syntax check mode */ if (behavior != PHP_MODE_STANDARD) { break; } behavior=PHP_MODE_LINT; break; case 'q': /* do not generate HTTP headers */ /* This is default so NOP */ break; case 'r': /* run code from command line */ if (behavior == PHP_MODE_CLI_DIRECT) { if (exec_direct || script_file) { param_error = "You can use -r only once.\n"; break; } } else if (behavior != PHP_MODE_STANDARD || interactive) { param_error = param_mode_conflict; break; } behavior=PHP_MODE_CLI_DIRECT; exec_direct=php_optarg; break; case 'R': if (behavior == PHP_MODE_PROCESS_STDIN) { if (exec_run || script_file) { param_error = "You can use -R or -F only once.\n"; break; } } else if (behavior != PHP_MODE_STANDARD) { param_error = param_mode_conflict; break; } behavior=PHP_MODE_PROCESS_STDIN; exec_run=php_optarg; break; case 'B': if (behavior == PHP_MODE_PROCESS_STDIN) { if (exec_begin) { param_error = "You can use -B only once.\n"; break; } } else if (behavior != PHP_MODE_STANDARD || interactive) { param_error = param_mode_conflict; break; } behavior=PHP_MODE_PROCESS_STDIN; exec_begin=php_optarg; break; case 'E': if (behavior == PHP_MODE_PROCESS_STDIN) { if (exec_end) { param_error = "You can use -E only once.\n"; break; } } else if (behavior != PHP_MODE_STANDARD || interactive) { param_error = param_mode_conflict; break; } behavior=PHP_MODE_PROCESS_STDIN; exec_end=php_optarg; break; case 's': /* generate highlighted HTML from source */ if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) { param_error = "Source highlighting only works for files.\n"; break; } behavior=PHP_MODE_HIGHLIGHT; break; case 'w': if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) { param_error = "Source stripping only works for files.\n"; break; } behavior=PHP_MODE_STRIP; break; case 'z': /* load extension file */ zend_load_extension(php_optarg); break; case 'H': hide_argv = 1; break; case 10: behavior=PHP_MODE_REFLECTION_FUNCTION; reflection_what = php_optarg; break; case 11: behavior=PHP_MODE_REFLECTION_CLASS; reflection_what = php_optarg; break; case 12: behavior=PHP_MODE_REFLECTION_EXTENSION; reflection_what = php_optarg; break; case 13: behavior=PHP_MODE_REFLECTION_ZEND_EXTENSION; reflection_what = php_optarg; break; case 14: behavior=PHP_MODE_REFLECTION_EXT_INFO; reflection_what = php_optarg; break; case 15: behavior = PHP_MODE_SHOW_INI_CONFIG; break; default: break; } } if (param_error) { PUTS(param_error); exit_status=1; goto err; } #if defined(PHP_WIN32) && !defined(PHP_CLI_WIN32_NO_CONSOLE) && (HAVE_LIBREADLINE || HAVE_LIBEDIT) && !defined(COMPILE_DL_READLINE) if (!interactive) { /* The -a option was not passed. If there is no file, it could still make sense to run interactively. The presense of a file is essential to mitigate buggy console info. */ interactive = php_win32_console_is_own() && !(script_file || argc > php_optind && behavior!=PHP_MODE_CLI_DIRECT && behavior!=PHP_MODE_PROCESS_STDIN && strcmp(argv[php_optind-1],"--") ); } #endif if (interactive) { #if (HAVE_LIBREADLINE || HAVE_LIBEDIT) && !defined(COMPILE_DL_READLINE) printf("Interactive shell\n\n"); #else printf("Interactive mode enabled\n\n"); #endif fflush(stdout); } /* only set script_file if not set already and not in direct mode and not at end of parameter list */ if (argc > php_optind && !script_file && behavior!=PHP_MODE_CLI_DIRECT && behavior!=PHP_MODE_PROCESS_STDIN && strcmp(argv[php_optind-1],"--")) { script_file=argv[php_optind]; php_optind++; } if (script_file) { if (cli_seek_file_begin(&file_handle, script_file, &lineno) != SUCCESS) { goto err; } else { char real_path[MAXPATHLEN]; if (VCWD_REALPATH(script_file, real_path)) { translated_path = strdup(real_path); } script_filename = script_file; } } else { /* We could handle PHP_MODE_PROCESS_STDIN in a different manner */ /* here but this would make things only more complicated. And it */ /* is consitent with the way -R works where the stdin file handle*/ /* is also accessible. */ file_handle.filename = "Standard input code"; file_handle.handle.fp = stdin; } file_handle.type = ZEND_HANDLE_FP; file_handle.opened_path = NULL; file_handle.free_filename = 0; php_self = (char*)file_handle.filename; /* before registering argv to module exchange the *new* argv[0] */ /* we can achieve this without allocating more memory */ SG(request_info).argc=argc-php_optind+1; arg_excp = argv+php_optind-1; arg_free = argv[php_optind-1]; SG(request_info).path_translated = translated_path? translated_path: (char*)file_handle.filename; argv[php_optind-1] = (char*)file_handle.filename; SG(request_info).argv=argv+php_optind-1; if (php_request_startup()==FAILURE) { *arg_excp = arg_free; fclose(file_handle.handle.fp); PUTS("Could not startup.\n"); goto err; } request_started = 1; CG(start_lineno) = lineno; *arg_excp = arg_free; /* reconstuct argv */ if (hide_argv) { int i; for (i = 1; i < argc; i++) { memset(argv[i], 0, strlen(argv[i])); } } zend_is_auto_global_str(ZEND_STRL("_SERVER")); PG(during_request_startup) = 0; switch (behavior) { case PHP_MODE_STANDARD: if (strcmp(file_handle.filename, "Standard input code")) { cli_register_file_handles(); } if (interactive && cli_shell_callbacks.cli_shell_run) { exit_status = cli_shell_callbacks.cli_shell_run(); } else { php_execute_script(&file_handle); exit_status = EG(exit_status); } break; case PHP_MODE_LINT: exit_status = php_lint_script(&file_handle); if (exit_status==SUCCESS) { zend_printf("No syntax errors detected in %s\n", file_handle.filename); } else { zend_printf("Errors parsing %s\n", file_handle.filename); } break; case PHP_MODE_STRIP: if (open_file_for_scanning(&file_handle)==SUCCESS) { zend_strip(); } goto out; break; case PHP_MODE_HIGHLIGHT: { zend_syntax_highlighter_ini syntax_highlighter_ini; if (open_file_for_scanning(&file_handle)==SUCCESS) { php_get_highlight_struct(&syntax_highlighter_ini); zend_highlight(&syntax_highlighter_ini); } goto out; } break; case PHP_MODE_CLI_DIRECT: cli_register_file_handles(); if (zend_eval_string_ex(exec_direct, NULL, "Command line code", 1) == FAILURE) { exit_status=254; } break; case PHP_MODE_PROCESS_STDIN: { char *input; size_t len, index = 0; zval argn, argi; cli_register_file_handles(); if (exec_begin && zend_eval_string_ex(exec_begin, NULL, "Command line begin code", 1) == FAILURE) { exit_status=254; } while (exit_status == SUCCESS && (input=php_stream_gets(s_in_process, NULL, 0)) != NULL) { len = strlen(input); while (len > 0 && len-- && (input[len]=='\n' || input[len]=='\r')) { input[len] = '\0'; } ZVAL_STRINGL(&argn, input, len + 1); zend_hash_str_update(&EG(symbol_table), "argn", sizeof("argn")-1, &argn); ZVAL_LONG(&argi, ++index); zend_hash_str_update(&EG(symbol_table), "argi", sizeof("argi")-1, &argi); if (exec_run) { if (zend_eval_string_ex(exec_run, NULL, "Command line run code", 1) == FAILURE) { exit_status=254; } } else { if (script_file) { if (cli_seek_file_begin(&file_handle, script_file, &lineno) != SUCCESS) { exit_status = 1; } else { CG(start_lineno) = lineno; php_execute_script(&file_handle); exit_status = EG(exit_status); } } } efree(input); } if (exec_end && zend_eval_string_ex(exec_end, NULL, "Command line end code", 1) == FAILURE) { exit_status=254; } break; } case PHP_MODE_REFLECTION_FUNCTION: case PHP_MODE_REFLECTION_CLASS: case PHP_MODE_REFLECTION_EXTENSION: case PHP_MODE_REFLECTION_ZEND_EXTENSION: { zend_class_entry *pce = NULL; zval arg, ref; zend_execute_data execute_data; switch (behavior) { default: break; case PHP_MODE_REFLECTION_FUNCTION: if (strstr(reflection_what, "::")) { pce = reflection_method_ptr; } else { pce = reflection_function_ptr; } break; case PHP_MODE_REFLECTION_CLASS: pce = reflection_class_ptr; break; case PHP_MODE_REFLECTION_EXTENSION: pce = reflection_extension_ptr; break; case PHP_MODE_REFLECTION_ZEND_EXTENSION: pce = reflection_zend_extension_ptr; break; } ZVAL_STRING(&arg, reflection_what); object_init_ex(&ref, pce); memset(&execute_data, 0, sizeof(zend_execute_data)); EG(current_execute_data) = &execute_data; zend_call_method_with_1_params(&ref, pce, &pce->constructor, "__construct", NULL, &arg); if (EG(exception)) { zval tmp, *msg, rv; ZVAL_OBJ(&tmp, EG(exception)); msg = zend_read_property(zend_ce_exception, &tmp, "message", sizeof("message")-1, 0, &rv); zend_printf("Exception: %s\n", Z_STRVAL_P(msg)); zval_ptr_dtor(&tmp); EG(exception) = NULL; } else { zend_call_method_with_1_params(NULL, reflection_ptr, NULL, "export", NULL, &ref); } zval_ptr_dtor(&ref); zval_ptr_dtor(&arg); break; } case PHP_MODE_REFLECTION_EXT_INFO: { size_t len = strlen(reflection_what); char *lcname = zend_str_tolower_dup(reflection_what, len); zend_module_entry *module; if ((module = zend_hash_str_find_ptr(&module_registry, lcname, len)) == NULL) { if (!strcmp(reflection_what, "main")) { display_ini_entries(NULL); } else { zend_printf("Extension '%s' not present.\n", reflection_what); exit_status = 1; } } else { php_info_print_module(module); } efree(lcname); break; } case PHP_MODE_SHOW_INI_CONFIG: { zend_printf("Configuration File (php.ini) Path: %s\n", PHP_CONFIG_FILE_PATH); zend_printf("Loaded Configuration File: %s\n", php_ini_opened_path ? php_ini_opened_path : "(none)"); zend_printf("Scan for additional .ini files in: %s\n", php_ini_scanned_path ? php_ini_scanned_path : "(none)"); zend_printf("Additional .ini files parsed: %s\n", php_ini_scanned_files ? php_ini_scanned_files : "(none)"); break; } } } zend_end_try(); out: if (request_started) { php_request_shutdown((void *) 0); } if (translated_path) { free(translated_path); } if (exit_status == 0) { exit_status = EG(exit_status); } return exit_status; err: sapi_deactivate(); zend_ini_deactivate(); exit_status = 1; goto out; }
/* {{{ spl_instantiate */ PHPAPI void spl_instantiate(zend_class_entry *pce, zval *object) { object_init_ex(object, pce); }
/** * Returns current row in the resultset */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, current) { zend_class_entry *_13$$15; HashTable *_3, *_6$$11; HashPosition _2, _5$$11; zval *row = NULL, *hydrateMode = NULL, *eager = NULL, *alias = NULL, *activeRow = NULL, *type = NULL, *column = NULL, *columnValue = NULL, *value = NULL, *attribute = NULL, *source = NULL, *attributes = NULL, *columnMap = NULL, *rowModel = NULL, *keepSnapshots = NULL, *sqlAlias = NULL, *modelName = NULL, *_0, *_1, **_4, **_7$$11, *_8$$12 = NULL, *_9$$15 = NULL, *_11$$15, *_12$$15 = NULL, *_10$$16, *_15$$18, *_16$$18 = NULL, _18$$24 = zval_used_for_init, _19$$24 = zval_used_for_init; zephir_fcall_cache_entry *_14 = NULL, *_17 = NULL; int ZEPHIR_LAST_CALL_STATUS, dirtyState = 0; ZEPHIR_MM_GROW(); ZEPHIR_OBS_VAR(activeRow); zephir_read_property_this(&activeRow, this_ptr, SL("_activeRow"), PH_NOISY_CC); if (Z_TYPE_P(activeRow) != IS_NULL) { RETURN_CCTOR(activeRow); } ZEPHIR_OBS_VAR(row); zephir_read_property_this(&row, this_ptr, SL("_row"), PH_NOISY_CC); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_disableHydration"), PH_NOISY_CC); if (zephir_is_true(_0)) { zephir_update_property_this(this_ptr, SL("_activeRow"), row TSRMLS_CC); RETURN_CCTOR(row); } if (Z_TYPE_P(row) != IS_ARRAY) { if (0) { zephir_update_property_this(this_ptr, SL("_activeRow"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC); } else { zephir_update_property_this(this_ptr, SL("_activeRow"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } RETURN_MM_BOOL(0); } ZEPHIR_OBS_VAR(hydrateMode); zephir_read_property_this(&hydrateMode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC); do { if (ZEPHIR_IS_LONG(hydrateMode, 0)) { ZEPHIR_INIT_NVAR(activeRow); object_init_ex(activeRow, phalcon_mvc_model_row_ce); if (zephir_has_constructor(activeRow TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, activeRow, "__construct", NULL, 0); zephir_check_call_status(); } break; } if (ZEPHIR_IS_LONG(hydrateMode, 1)) { ZEPHIR_INIT_NVAR(activeRow); array_init(activeRow); break; } ZEPHIR_INIT_NVAR(activeRow); object_init(activeRow); break; } while(0); dirtyState = 0; _1 = zephir_fetch_nproperty_this(this_ptr, SL("_columnTypes"), PH_NOISY_CC); zephir_is_iterable(_1, &_3, &_2, 0, 0, "phalcon/mvc/model/resultset/complex.zep", 246); for ( ; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS ; zephir_hash_move_forward_ex(_3, &_2) ) { ZEPHIR_GET_HMKEY(alias, _3, _2); ZEPHIR_GET_HVALUE(column, _4); if (Z_TYPE_P(column) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Column type is corrupt", "phalcon/mvc/model/resultset/complex.zep", 133); return; } ZEPHIR_OBS_NVAR(type); zephir_array_fetch_string(&type, column, SL("type"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 136 TSRMLS_CC); if (ZEPHIR_IS_STRING(type, "object")) { ZEPHIR_OBS_NVAR(source); zephir_array_fetch_string(&source, column, SL("column"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 142 TSRMLS_CC); ZEPHIR_OBS_NVAR(attributes); zephir_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 143 TSRMLS_CC); ZEPHIR_OBS_NVAR(columnMap); zephir_array_fetch_string(&columnMap, column, SL("columnMap"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 144 TSRMLS_CC); ZEPHIR_INIT_NVAR(rowModel); array_init(rowModel); zephir_is_iterable(attributes, &_6$$11, &_5$$11, 0, 0, "phalcon/mvc/model/resultset/complex.zep", 162); for ( ; zephir_hash_get_current_data_ex(_6$$11, (void**) &_7$$11, &_5$$11) == SUCCESS ; zephir_hash_move_forward_ex(_6$$11, &_5$$11) ) { ZEPHIR_GET_HVALUE(attribute, _7$$11); ZEPHIR_OBS_NVAR(columnValue); ZEPHIR_INIT_LNVAR(_8$$12); ZEPHIR_CONCAT_SVSV(_8$$12, "_", source, "_", attribute); zephir_array_fetch(&columnValue, row, _8$$12, PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 155 TSRMLS_CC); zephir_array_update_zval(&rowModel, attribute, &columnValue, PH_COPY | PH_SEPARATE); } do { if (ZEPHIR_IS_LONG(hydrateMode, 0)) { ZEPHIR_OBS_NVAR(keepSnapshots); if (!(zephir_array_isset_string_fetch(&keepSnapshots, column, SS("keepSnapshots"), 0 TSRMLS_CC))) { ZEPHIR_INIT_NVAR(keepSnapshots); ZVAL_BOOL(keepSnapshots, 0); } if (ZEPHIR_GLOBAL(orm).late_state_binding) { ZEPHIR_OBS_NVAR(_9$$15); zephir_array_fetch_string(&_9$$15, column, SL("instance"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 173 TSRMLS_CC); if (zephir_instance_of_ev(_9$$15, phalcon_mvc_model_ce TSRMLS_CC)) { zephir_array_fetch_string(&_10$$16, column, SL("instance"), PH_NOISY | PH_READONLY, "phalcon/mvc/model/resultset/complex.zep", 174 TSRMLS_CC); ZEPHIR_INIT_NVAR(modelName); zephir_get_class(modelName, _10$$16, 0 TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(modelName); ZVAL_STRING(modelName, "Phalcon\\Mvc\\Model", 1); } zephir_array_fetch_string(&_11$$15, column, SL("instance"), PH_NOISY | PH_READONLY, "phalcon/mvc/model/resultset/complex.zep", 180 TSRMLS_CC); ZEPHIR_INIT_NVAR(_12$$15); ZVAL_LONG(_12$$15, dirtyState); _13$$15 = zephir_fetch_class(modelName TSRMLS_CC); ZEPHIR_CALL_CE_STATIC(&value, _13$$15, "cloneresultmap", NULL, 0, _11$$15, rowModel, columnMap, _12$$15, keepSnapshots); zephir_check_call_status(); } else { zephir_array_fetch_string(&_15$$18, column, SL("instance"), PH_NOISY | PH_READONLY, "phalcon/mvc/model/resultset/complex.zep", 188 TSRMLS_CC); ZEPHIR_INIT_NVAR(_16$$18); ZVAL_LONG(_16$$18, dirtyState); ZEPHIR_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmap", &_14, 0, _15$$18, rowModel, columnMap, _16$$18, keepSnapshots); zephir_check_call_status(); } break; } ZEPHIR_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmaphydrate", &_17, 0, rowModel, columnMap, hydrateMode); zephir_check_call_status(); break; } while(0); ZEPHIR_OBS_NVAR(attribute); zephir_array_fetch_string(&attribute, column, SL("balias"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 202 TSRMLS_CC); } else { ZEPHIR_OBS_NVAR(sqlAlias); if (zephir_array_isset_string_fetch(&sqlAlias, column, SS("sqlAlias"), 0 TSRMLS_CC)) { ZEPHIR_OBS_NVAR(value); zephir_array_fetch(&value, row, sqlAlias, PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 210 TSRMLS_CC); } else { ZEPHIR_OBS_NVAR(value); zephir_array_isset_fetch(&value, row, alias, 0 TSRMLS_CC); } if (zephir_array_isset_string(column, SS("balias"))) { ZEPHIR_CPY_WRT(attribute, alias); } else { ZEPHIR_SINIT_NVAR(_18$$24); ZVAL_STRING(&_18$$24, "_", 0); ZEPHIR_SINIT_NVAR(_19$$24); ZVAL_STRING(&_19$$24, "", 0); ZEPHIR_INIT_NVAR(attribute); zephir_fast_str_replace(&attribute, &_18$$24, &_19$$24, alias TSRMLS_CC); } } if (!(zephir_array_isset_string_fetch(&eager, column, SS("eager"), 1 TSRMLS_CC))) { do { if (ZEPHIR_IS_LONG(hydrateMode, 1)) { zephir_array_update_zval(&activeRow, attribute, &value, PH_COPY | PH_SEPARATE); break; } zephir_update_property_zval_zval(activeRow, attribute, value TSRMLS_CC); break; } while(0); } } zephir_update_property_this(this_ptr, SL("_activeRow"), activeRow TSRMLS_CC); RETURN_CCTOR(activeRow); }
/** * Stores cached content into the file backend and stops the frontend * * @param int|string keyName * @param string content * @param int lifetime * @param boolean stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, save) { zend_long ZEPHIR_LAST_CALL_STATUS; zend_bool stopBuffer; zval *keyName = NULL, *content = NULL, *lifetime = NULL, *stopBuffer_param = NULL, *lastKey = NULL, *frontend = NULL, *memcache = NULL, *cachedContent = NULL, *preparedContent = NULL, *tmp = NULL, *tt1 = NULL, *success = NULL, *options = NULL, *specialKey = NULL, *keys = NULL, *isBuffering = NULL, *_0$$4, *_1$$15, *_2$$15 = NULL, *_3$$15; 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 (Z_TYPE_P(keyName) == IS_NULL) { ZEPHIR_OBS_VAR(lastKey); zephir_read_property_this(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC); } else { _0$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC); ZEPHIR_INIT_NVAR(lastKey); ZEPHIR_CONCAT_VV(lastKey, _0$$4, keyName); zephir_update_property_this(getThis(), SL("_lastKey"), lastKey TSRMLS_CC); } if (!(zephir_is_true(lastKey))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache must be started first", "phalcon/cache/backend/libmemcached.zep", 196); return; } ZEPHIR_OBS_VAR(frontend); zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); ZEPHIR_OBS_VAR(memcache); zephir_read_property_this(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC); if (Z_TYPE_P(memcache) != IS_OBJECT) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_NVAR(memcache); zephir_read_property_this(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC); } if (Z_TYPE_P(content) == IS_NULL) { 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(); } else { ZEPHIR_CPY_WRT(preparedContent, cachedContent); } if (Z_TYPE_P(lifetime) == IS_NULL) { 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); } ZEPHIR_CALL_METHOD(&success, memcache, "set", NULL, 0, lastKey, preparedContent, tt1); zephir_check_call_status(); if (!(zephir_is_true(success))) { ZEPHIR_INIT_VAR(_1$$15); object_init_ex(_1$$15, phalcon_cache_exception_ce); ZEPHIR_CALL_METHOD(&_2$$15, memcache, "getresultcode", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(_3$$15); ZEPHIR_CONCAT_SV(_3$$15, "Failed storing data in memcached, error code: ", _2$$15); ZEPHIR_CALL_METHOD(NULL, _1$$15, "__construct", NULL, 9, _3$$15); zephir_check_call_status(); zephir_throw_exception_debug(_1$$15, "phalcon/cache/backend/libmemcached.zep", 240 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_OBS_VAR(options); zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC); ZEPHIR_OBS_VAR(specialKey); if (!(zephir_array_isset_string_fetch(&specialKey, options, SS("statsKey"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/libmemcached.zep", 246); return; } if (!ZEPHIR_IS_STRING(specialKey, "")) { ZEPHIR_CALL_METHOD(&keys, memcache, "get", NULL, 0, specialKey); zephir_check_call_status(); if (Z_TYPE_P(keys) != IS_ARRAY) { ZEPHIR_INIT_NVAR(keys); array_init(keys); } if (!(zephir_array_isset(keys, lastKey))) { zephir_array_update_zval(&keys, lastKey, &tt1, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(NULL, memcache, "set", NULL, 0, specialKey, keys); 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(getThis(), SL("_started"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC); } else { zephir_update_property_this(getThis(), SL("_started"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } RETURN_CCTOR(success); }
/** * Returns an array of Phalcon\Db\Column objects describing a table * * <code>print_r($connection->describeColumns("posts")); ?></code> * * @param string $table * @param string $schema * @return Phalcon\Db\Column[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, describeColumns) { zval *table = NULL, *schema = NULL, *columns = NULL, *sql = NULL, *fetch_assoc = NULL; zval *describe = NULL, *old_column = NULL, *field = NULL, *definition = NULL; zval *char_size = NULL, *numeric_size = NULL, *column_type = NULL; zval *status = NULL, *attribute = NULL, *column_name = NULL, *column = NULL; zval *t0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!schema) { PHALCON_ALLOC_ZVAL_MM(schema); ZVAL_NULL(schema); } PHALCON_INIT_VAR(columns); array_init(columns); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_dialect"), PH_NOISY_CC); PHALCON_INIT_VAR(sql); PHALCON_CALL_METHOD_PARAMS_2(sql, t0, "describecolumns", table, schema, PH_NO_CHECK); PHALCON_INIT_VAR(fetch_assoc); phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC); PHALCON_INIT_VAR(describe); PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK); PHALCON_INIT_VAR(old_column); ZVAL_NULL(old_column); if (!phalcon_valid_foreach(describe TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(describe); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) { goto ph_cycle_end_0; } PHALCON_GET_FOREACH_VALUE(field); PHALCON_INIT_VAR(definition); array_init(definition); PHALCON_INIT_VAR(char_size); phalcon_array_fetch_string(&char_size, field, SL("size"), PH_NOISY_CC); PHALCON_INIT_VAR(numeric_size); phalcon_array_fetch_string(&numeric_size, field, SL("numericsize"), PH_NOISY_CC); PHALCON_INIT_VAR(column_type); phalcon_array_fetch_string(&column_type, field, SL("type"), PH_NOISY_CC); PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("int") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 0, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &numeric_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("varying") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("date") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("numeric") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 3, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &numeric_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("char") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("timestamp") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 4, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("text") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("float") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 7, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &numeric_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("uuid") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string_long(&definition, SL("size"), 36, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC); } } } } } } } } } PHALCON_INIT_VAR(status); phalcon_fast_strpos_str(status, column_type, SL("unsigned") TSRMLS_CC); if (PHALCON_IS_NOT_FALSE(status)) { phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_SEPARATE TSRMLS_CC); } if (Z_TYPE_P(old_column) == IS_NULL) { phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("key"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(attribute, "PRI")) { phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("null"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(attribute, "NO")) { phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(attribute); phalcon_array_fetch_string(&attribute, field, SL("extra"), PH_NOISY_CC); if (PHALCON_COMPARE_STRING(attribute, "auto_increment")) { phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(column_name); phalcon_array_fetch_string(&column_name, field, SL("field"), PH_NOISY_CC); PHALCON_INIT_VAR(column); object_init_ex(column, phalcon_db_column_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition, PH_CHECK); phalcon_array_append(&columns, column, PH_SEPARATE TSRMLS_CC); PHALCON_CPY_WRT(old_column, column_name); zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: RETURN_CTOR(columns); }
/** * Check whether internal resource has rows to fetch * * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, valid){ zval *type = NULL, *result, *row = NULL, *rows, *hydrate_mode, *underscore; zval *empty_str, *active_row = NULL, *columns_types; zval *dirty_state, *column = NULL, *alias = NULL, *source = NULL, *attributes = NULL; zval *column_map = NULL, *row_model = NULL, *attribute = NULL, *column_alias = NULL; zval *column_value = NULL, *keep_snapshots = NULL, *instance = NULL; zval *value = NULL, *sql_alias = NULL, *n_alias = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); PHALCON_OBS_VAR(type); phalcon_read_property_this(&type, this_ptr, SL("_type"), PH_NOISY_CC); if (zend_is_true(type)) { /** * The result is bigger than 32 rows so it's retrieved one by one */ PHALCON_OBS_VAR(result); phalcon_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_INIT_VAR(row); PHALCON_CALL_METHOD_PARAMS_1(row, result, "fetch", result); } else { PHALCON_INIT_NVAR(row); ZVAL_BOOL(row, 0); } } else { /** * The full rows are dumped in this_ptr->rows */ PHALCON_OBS_VAR(rows); phalcon_read_property_this(&rows, this_ptr, SL("_rows"), PH_NOISY_CC); if (Z_TYPE_P(rows) == IS_ARRAY) { PHALCON_INIT_NVAR(row); phalcon_array_get_current(row, rows TSRMLS_CC); if (Z_TYPE_P(row) == IS_OBJECT) { phalcon_array_next(rows); } } else { PHALCON_INIT_NVAR(row); ZVAL_BOOL(row, 0); } } /** * Valid records are arrays */ if (Z_TYPE_P(row) == IS_ARRAY || Z_TYPE_P(row) == IS_OBJECT) { /** * The result type=1 so we need to build every row */ if (zend_is_true(type)) { /** * Get current hydration mode */ PHALCON_OBS_VAR(hydrate_mode); phalcon_read_property_this(&hydrate_mode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC); PHALCON_INIT_VAR(underscore); ZVAL_STRING(underscore, "_", 1); PHALCON_INIT_VAR(empty_str); ZVAL_STRING(empty_str, "", 1); /** * Each row in a complex result is a Phalcon\Mvc\Model\Row instance */ switch (phalcon_get_intval(hydrate_mode)) { case 0: PHALCON_INIT_VAR(active_row); object_init_ex(active_row, phalcon_mvc_model_row_ce); break; case 1: PHALCON_INIT_NVAR(active_row); array_init(active_row); break; case 2: PHALCON_INIT_NVAR(active_row); object_init(active_row); break; } /** * Create every record according to the column types */ PHALCON_OBS_VAR(columns_types); phalcon_read_property_this(&columns_types, this_ptr, SL("_columnTypes"), PH_NOISY_CC); /** * Set records as dirty state PERSISTENT by default */ PHALCON_INIT_VAR(dirty_state); ZVAL_LONG(dirty_state, 0); if (!phalcon_is_iterable(columns_types, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_KEY(alias, ah0, hp0); PHALCON_GET_FOREACH_VALUE(column); PHALCON_OBS_NVAR(type); phalcon_array_fetch_string(&type, column, SL("type"), PH_NOISY_CC); if (PHALCON_IS_STRING(type, "object")) { /** * Object columns are assigned column by column */ PHALCON_OBS_NVAR(source); phalcon_array_fetch_string(&source, column, SL("column"), PH_NOISY_CC); PHALCON_OBS_NVAR(attributes); phalcon_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY_CC); PHALCON_OBS_NVAR(column_map); phalcon_array_fetch_string(&column_map, column, SL("columnMap"), PH_NOISY_CC); /** * Assign the values from the _source_attribute notation to its real column name */ PHALCON_INIT_NVAR(row_model); array_init(row_model); if (!phalcon_is_iterable(attributes, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(attribute); /** * Columns are supposed to be in the form _table_field */ PHALCON_INIT_NVAR(column_alias); PHALCON_CONCAT_VVVV(column_alias, underscore, source, underscore, attribute); PHALCON_OBS_NVAR(column_value); phalcon_array_fetch(&column_value, row, column_alias, PH_NOISY_CC); phalcon_array_update_zval(&row_model, attribute, &column_value, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); } /** * Generate the column value according to the hydration type */ switch (phalcon_get_intval(hydrate_mode)) { case 0: /** * Check if the resultset must keep snapshots */ if (phalcon_array_isset_string(column, SS("keepSnapshots"))) { PHALCON_OBS_NVAR(keep_snapshots); phalcon_array_fetch_string(&keep_snapshots, column, SL("keepSnapshots"), PH_NOISY_CC); } else { PHALCON_INIT_NVAR(keep_snapshots); ZVAL_BOOL(keep_snapshots, 0); } /** * Get the base instance */ PHALCON_OBS_NVAR(instance); phalcon_array_fetch_string(&instance, column, SL("instance"), PH_NOISY_CC); /** * Assign the values to the attributes using a column map */ PHALCON_INIT_NVAR(value); PHALCON_CALL_STATIC_PARAMS_5(value, "phalcon\\mvc\\model", "cloneresultmap", instance, row_model, column_map, dirty_state, keep_snapshots); break; default: /** * Other kinds of hydrations */ PHALCON_INIT_NVAR(value); PHALCON_CALL_STATIC_PARAMS_3(value, "phalcon\\mvc\\model", "cloneresultmaphydrate", row_model, column_map, hydrate_mode); break; } /** * The complete object is assigned to an attribute with the name of the alias or * the model name */ PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_string(&attribute, column, SL("balias"), PH_NOISY_CC); } else { /** * Scalar columns are simply assigned to the result object */ if (phalcon_array_isset_string(column, SS("sqlAlias"))) { PHALCON_OBS_NVAR(sql_alias); phalcon_array_fetch_string(&sql_alias, column, SL("sqlAlias"), PH_NOISY_CC); PHALCON_OBS_NVAR(value); phalcon_array_fetch(&value, row, sql_alias, PH_NOISY_CC); } else { PHALCON_OBS_NVAR(value); phalcon_array_fetch(&value, row, alias, PH_NOISY_CC); } /** * If a 'balias' is defined is not an unnamed scalar */ if (phalcon_array_isset_string(column, SS("balias"))) { PHALCON_CPY_WRT(attribute, alias); } else { PHALCON_INIT_NVAR(n_alias); phalcon_fast_str_replace(n_alias, underscore, empty_str, alias TSRMLS_CC); PHALCON_CPY_WRT(attribute, n_alias); } } /** * Assign the instance according to the hydration type */ switch (phalcon_get_intval(hydrate_mode)) { case 1: phalcon_array_update_zval(&active_row, attribute, &value, PH_COPY | PH_SEPARATE TSRMLS_CC); break; default: phalcon_update_property_zval_zval(active_row, attribute, value TSRMLS_CC); break; } zend_hash_move_forward_ex(ah0, &hp0); } /** * Store the generated row in this_ptr->activeRow to be retrieved by 'current' */ phalcon_update_property_this(this_ptr, SL("_activeRow"), active_row TSRMLS_CC); } else { /** * The row is already built so we just assign it to the activeRow */ phalcon_update_property_this(this_ptr, SL("_activeRow"), row TSRMLS_CC); } RETURN_MM_TRUE; } /** * There are no results to retrieve so we update this_ptr->activeRow as false */ phalcon_update_property_bool(this_ptr, SL("_activeRow"), 0 TSRMLS_CC); RETURN_MM_FALSE; }
PHP_METHOD(Phalcon_Db_Column, __set_state){ zval *data = NULL, *definition = NULL, *column_name = NULL, *column_type = NULL; zval *not_null = NULL, *primary = NULL, *size = NULL, *dunsigned = NULL, *after = NULL; zval *is_numeric = NULL, *first = NULL, *column = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &data) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(definition); array_init(definition); eval_int = phalcon_array_isset_string(data, SL("_columnName")+1); if (eval_int) { PHALCON_INIT_VAR(column_name); phalcon_array_fetch_string(&column_name, data, SL("_columnName"), PH_NOISY_CC); } eval_int = phalcon_array_isset_string(data, SL("_type")+1); if (eval_int) { PHALCON_INIT_VAR(column_type); phalcon_array_fetch_string(&column_type, data, SL("_type"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("type"), &column_type, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(data, SL("_notNull")+1); if (eval_int) { PHALCON_INIT_VAR(not_null); phalcon_array_fetch_string(¬_null, data, SL("_notNull"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("notNull"), ¬_null, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(data, SL("_primary")+1); if (eval_int) { PHALCON_INIT_VAR(primary); phalcon_array_fetch_string(&primary, data, SL("_primary"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("primary"), &primary, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(data, SL("_size")+1); if (eval_int) { PHALCON_INIT_VAR(size); phalcon_array_fetch_string(&size, data, SL("_size"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("size"), &size, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(data, SL("_unsigned")+1); if (eval_int) { PHALCON_INIT_VAR(dunsigned); phalcon_array_fetch_string(&dunsigned, data, SL("_unsigned"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("unsigned"), &dunsigned, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(data, SL("_after")+1); if (eval_int) { PHALCON_INIT_VAR(after); phalcon_array_fetch_string(&after, data, SL("_after"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("after"), &after, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(data, SL("_isNumeric")+1); if (eval_int) { PHALCON_INIT_VAR(is_numeric); phalcon_array_fetch_string(&is_numeric, data, SL("_isNumeric"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("isNumeric"), &is_numeric, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(data, SL("_first")+1); if (eval_int) { PHALCON_INIT_VAR(first); phalcon_array_fetch_string(&first, data, SL("_first"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("first"), &first, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(column); object_init_ex(column, phalcon_db_column_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition, PH_CHECK); RETURN_CTOR(column); }
/** * Executes the validation */ PHP_METHOD(Phalcon_Validation_Validator_Regex, validate) { zend_bool failed = 0; zend_long 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, *_4$$6 = NULL, *_5$$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(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", 84 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", 88 TSRMLS_CC); failed = !ZEPHIR_IS_EQUAL(_2$$4, value); } else { failed = 1; } if (failed == 1) { ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field); zephir_check_call_status(); ZEPHIR_INIT_VAR(_3$$6); ZVAL_STRING(_3$$6, "Regex", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _3$$6); zephir_check_temp_parameter(_3$$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(_3$$6); object_init_ex(_3$$6, phalcon_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_4$$6, "strtr", NULL, 27, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_VAR(_5$$6); ZVAL_STRING(_5$$6, "Regex", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _3$$6, "__construct", NULL, 470, _4$$6, field, _5$$6, code); zephir_check_temp_parameter(_5$$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); }
/** * Returns a complete resultset as an array, if the resultset has a big number of rows * it could consume more memory than currently it does. Export the resultset to an array * couldn't be faster with a large number of records */ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, toArray) { HashTable *_2$$7, *_5$$8; HashPosition _1$$7, _4$$8; zephir_fcall_cache_entry *_9 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *renameColumns_param = NULL, *result = NULL, *records = NULL, *record = NULL, *renamed = NULL, *renamedKey = NULL, *key = NULL, *value = NULL, *renamedRecords = NULL, *columnMap = NULL, *_0$$3, **_3$$7, **_6$$8, *_7$$10 = NULL, *_8$$10 = NULL, *_10$$12 = NULL, *_11$$12 = NULL; zend_bool renameColumns; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &renameColumns_param); if (!renameColumns_param) { renameColumns = 1; } else { renameColumns = zephir_get_boolval(renameColumns_param); } ZEPHIR_OBS_VAR(records); zephir_read_property_this(&records, this_ptr, SL("_rows"), PH_NOISY_CC); if (Z_TYPE_P(records) != IS_ARRAY) { ZEPHIR_OBS_VAR(result); zephir_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC); _0$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_row"), PH_NOISY_CC); if (Z_TYPE_P(_0$$3) != IS_NULL) { ZEPHIR_CALL_METHOD(NULL, result, "execute", NULL, 0); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&records, result, "fetchall", NULL, 0); zephir_check_call_status(); zephir_update_property_this(getThis(), SL("_row"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC); zephir_update_property_this(getThis(), SL("_rows"), records TSRMLS_CC); } if (renameColumns) { ZEPHIR_OBS_VAR(columnMap); zephir_read_property_this(&columnMap, this_ptr, SL("_columnMap"), PH_NOISY_CC); if (Z_TYPE_P(columnMap) != IS_ARRAY) { RETURN_CCTOR(records); } ZEPHIR_INIT_VAR(renamedRecords); array_init(renamedRecords); if (Z_TYPE_P(records) == IS_ARRAY) { zephir_is_iterable(records, &_2$$7, &_1$$7, 0, 0, "phalcon/mvc/model/resultset/simple.zep", 217); for ( ; zend_hash_get_current_data_ex(_2$$7, (void**) &_3$$7, &_1$$7) == SUCCESS ; zend_hash_move_forward_ex(_2$$7, &_1$$7) ) { ZEPHIR_GET_HVALUE(record, _3$$7); ZEPHIR_INIT_NVAR(renamed); array_init(renamed); zephir_is_iterable(record, &_5$$8, &_4$$8, 0, 0, "phalcon/mvc/model/resultset/simple.zep", 215); for ( ; zend_hash_get_current_data_ex(_5$$8, (void**) &_6$$8, &_4$$8) == SUCCESS ; zend_hash_move_forward_ex(_5$$8, &_4$$8) ) { ZEPHIR_GET_HMKEY(key, _5$$8, _4$$8); ZEPHIR_GET_HVALUE(value, _6$$8); ZEPHIR_OBS_NVAR(renamedKey); if (!(zephir_array_isset_fetch(&renamedKey, columnMap, key, 0 TSRMLS_CC))) { ZEPHIR_INIT_NVAR(_7$$10); object_init_ex(_7$$10, phalcon_mvc_model_exception_ce); ZEPHIR_INIT_LNVAR(_8$$10); ZEPHIR_CONCAT_SVS(_8$$10, "Column '", key, "' is not part of the column map"); ZEPHIR_CALL_METHOD(NULL, _7$$10, "__construct", &_9, 9, _8$$10); zephir_check_call_status(); zephir_throw_exception_debug(_7$$10, "phalcon/mvc/model/resultset/simple.zep", 199 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } if (Z_TYPE_P(renamedKey) == IS_ARRAY) { ZEPHIR_OBS_NVAR(renamedKey); if (!(zephir_array_isset_long_fetch(&renamedKey, renamedKey, 0, 0 TSRMLS_CC))) { ZEPHIR_INIT_NVAR(_10$$12); object_init_ex(_10$$12, phalcon_mvc_model_exception_ce); ZEPHIR_INIT_LNVAR(_11$$12); ZEPHIR_CONCAT_SVS(_11$$12, "Column '", key, "' is not part of the column map"); ZEPHIR_CALL_METHOD(NULL, _10$$12, "__construct", &_9, 9, _11$$12); zephir_check_call_status(); zephir_throw_exception_debug(_10$$12, "phalcon/mvc/model/resultset/simple.zep", 205 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } } zephir_array_update_zval(&renamed, renamedKey, &value, PH_COPY | PH_SEPARATE); } zephir_array_append(&renamedRecords, renamed, PH_SEPARATE, "phalcon/mvc/model/resultset/simple.zep", 215); } } RETURN_CCTOR(renamedRecords); } RETURN_CCTOR(records); }
/** * Phalcon\Config\Adapter\Yaml constructor * * @throws \Phalcon\Config\Exception */ PHP_METHOD(Phalcon_Config_Adapter_Yaml, __construct) { zephir_fcall_cache_entry *_4 = NULL, *_8 = NULL; int ZEPHIR_LAST_CALL_STATUS, ndocs; zval *callbacks = NULL; zval *filePath_param = NULL, *callbacks_param = NULL, *yamlConfig = NULL, _0, *_1 = NULL, *_2$$4, *_3$$4, *_5$$6, *_6$$6, *_7$$6; zval *filePath = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &filePath_param, &callbacks_param); if (unlikely(Z_TYPE_P(filePath_param) != IS_STRING && Z_TYPE_P(filePath_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'filePath' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(filePath_param) == IS_STRING)) { zephir_get_strval(filePath, filePath_param); } else { ZEPHIR_INIT_VAR(filePath); ZVAL_EMPTY_STRING(filePath); } if (!callbacks_param) { ZEPHIR_INIT_VAR(callbacks); array_init(callbacks); } else { callbacks = callbacks_param; } ndocs = 0; ZEPHIR_SINIT_VAR(_0); ZVAL_STRING(&_0, "yaml", 0); ZEPHIR_CALL_FUNCTION(&_1, "extension_loaded", NULL, 137, &_0); zephir_check_call_status(); if (!(zephir_is_true(_1))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_config_exception_ce, "Yaml extension not loaded", "phalcon/config/adapter/yaml.zep", 71); return; } if (!ZEPHIR_IS_STRING_IDENTICAL(callbacks, "")) { ZEPHIR_INIT_VAR(_2$$4); ZVAL_LONG(_2$$4, 0); ZEPHIR_INIT_VAR(_3$$4); ZVAL_LONG(_3$$4, ndocs); ZEPHIR_MAKE_REF(_3$$4); ZEPHIR_CALL_FUNCTION(&yamlConfig, "yaml_parse_file", &_4, 138, filePath, _2$$4, _3$$4, callbacks); ZEPHIR_UNREF(_3$$4); zephir_check_call_status(); } else { ZEPHIR_CALL_FUNCTION(&yamlConfig, "yaml_parse_file", &_4, 138, filePath); zephir_check_call_status(); } if (ZEPHIR_IS_FALSE_IDENTICAL(yamlConfig)) { ZEPHIR_INIT_VAR(_5$$6); object_init_ex(_5$$6, phalcon_config_exception_ce); ZEPHIR_INIT_VAR(_6$$6); zephir_basename(_6$$6, filePath TSRMLS_CC); ZEPHIR_INIT_VAR(_7$$6); ZEPHIR_CONCAT_SVS(_7$$6, "Configuration file ", _6$$6, " can't be loaded"); ZEPHIR_CALL_METHOD(NULL, _5$$6, "__construct", NULL, 9, _7$$6); zephir_check_call_status(); zephir_throw_exception_debug(_5$$6, "phalcon/config/adapter/yaml.zep", 81 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_CALL_PARENT(NULL, phalcon_config_adapter_yaml_ce, this_ptr, "__construct", &_8, 19, yamlConfig); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); }
/** * Sets a cookie to be sent at the end of the request * This method overrides any cookie set before with the same name * * @param string name * @param mixed value * @param int expire * @param string path * @param boolean secure * @param string domain * @param boolean httpOnly * @return Phalcon\Http\Response\Cookies */ PHP_METHOD(Phalcon_Http_Response_Cookies, set) { int expire, ZEPHIR_LAST_CALL_STATUS; zval *name_param = NULL, *value = NULL, *expire_param = NULL, *path_param = NULL, *secure = NULL, *domain_param = NULL, *httpOnly = NULL, *cookie = NULL, *encryption, *dependencyInjector, *response = NULL, *_0, *_1 = NULL, *_2; zval *name = NULL, *path = NULL, *domain = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 6, &name_param, &value, &expire_param, &path_param, &secure, &domain_param, &httpOnly); if (unlikely(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(name_param) == IS_STRING)) { zephir_get_strval(name, name_param); } else { ZEPHIR_INIT_VAR(name); ZVAL_EMPTY_STRING(name); } if (!value) { value = ZEPHIR_GLOBAL(global_null); } if (!expire_param) { expire = 0; } else { expire = zephir_get_intval(expire_param); } if (!path_param) { ZEPHIR_INIT_VAR(path); ZVAL_STRING(path, "/", 1); } else { zephir_get_strval(path, path_param); } if (!secure) { secure = ZEPHIR_GLOBAL(global_null); } if (!domain_param) { ZEPHIR_INIT_VAR(domain); ZVAL_EMPTY_STRING(domain); } else { if (unlikely(Z_TYPE_P(domain_param) != IS_STRING && Z_TYPE_P(domain_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'domain' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(domain_param) == IS_STRING)) { zephir_get_strval(domain, domain_param); } else { ZEPHIR_INIT_VAR(domain); ZVAL_EMPTY_STRING(domain); } } if (!httpOnly) { httpOnly = ZEPHIR_GLOBAL(global_null); } ZEPHIR_OBS_VAR(encryption); zephir_read_property_this(&encryption, this_ptr, SL("_useEncryption"), PH_NOISY_CC); ZEPHIR_OBS_VAR(cookie); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_cookies"), PH_NOISY_CC); if (!(zephir_array_isset_fetch(&cookie, _0, name, 0 TSRMLS_CC))) { ZEPHIR_INIT_NVAR(cookie); object_init_ex(cookie, phalcon_http_cookie_ce); ZEPHIR_INIT_VAR(_1); ZVAL_LONG(_1, expire); ZEPHIR_CALL_METHOD(NULL, cookie, "__construct", NULL, 215, name, value, _1, path, secure, domain, httpOnly); zephir_check_call_status(); _2 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(NULL, cookie, "setdi", NULL, 216, _2); zephir_check_call_status(); if (zephir_is_true(encryption)) { ZEPHIR_CALL_METHOD(NULL, cookie, "useencryption", NULL, 217, encryption); zephir_check_call_status(); } zephir_update_property_array(this_ptr, SL("_cookies"), name, cookie TSRMLS_CC); } else { ZEPHIR_CALL_METHOD(NULL, cookie, "setvalue", NULL, 218, value); zephir_check_call_status(); ZEPHIR_INIT_NVAR(_1); ZVAL_LONG(_1, expire); ZEPHIR_CALL_METHOD(NULL, cookie, "setexpiration", NULL, 219, _1); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, cookie, "setpath", NULL, 220, path); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, cookie, "setsecure", NULL, 221, secure); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, cookie, "setdomain", NULL, 222, domain); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, cookie, "sethttponly", NULL, 223, httpOnly); zephir_check_call_status(); } _2 = zephir_fetch_nproperty_this(this_ptr, SL("_registered"), PH_NOISY_CC); if (ZEPHIR_IS_FALSE_IDENTICAL(_2)) { ZEPHIR_OBS_VAR(dependencyInjector); zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_cookie_exception_ce, "A dependency injection object is required to access the 'response' service", "phalcon/http/response/cookies.zep", 138); return; } ZEPHIR_INIT_NVAR(_1); ZVAL_STRING(_1, "response", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&response, dependencyInjector, "getshared", NULL, 0, _1); zephir_check_temp_parameter(_1); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, response, "setcookies", NULL, 0, this_ptr); zephir_check_call_status(); } RETURN_THIS(); }
/** * Returns an array of Phalcon\Db\Column objects describing a table * * <code>print_r($connection->describeColumns("posts")); ?></code> * * @param string $table * @param string $schema * @return Phalcon\Db\Column[] */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, describeColumns){ zval *table, *schema = NULL, *columns, *dialect, *sql = NULL, *fetch_num; zval *describe = NULL, *old_column = NULL, *field = NULL, *definition = NULL; zval *char_size = NULL, *numeric_size = NULL, *numeric_scale = NULL, *column_type = NULL; zval *attribute = NULL, *column_name = NULL, *column = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &table, &schema); if (!schema || !zend_is_true(schema)) { schema = phalcon_fetch_nproperty_this(this_ptr, SL("_schema"), PH_NOISY TSRMLS_CC); } PHALCON_INIT_VAR(columns); array_init(columns); PHALCON_OBS_VAR(dialect); phalcon_read_property_this(&dialect, this_ptr, SL("_dialect"), PH_NOISY TSRMLS_CC); PHALCON_CALL_METHOD(&sql, dialect, "describecolumns", table, schema); /** * We're using FETCH_NUM to fetch the columns */ PHALCON_INIT_VAR(fetch_num); ZVAL_LONG(fetch_num, PDO_FETCH_NUM); PHALCON_CALL_METHOD(&describe, this_ptr, "fetchall", sql, fetch_num); /** * 0:name, 1:type, 2:size, 3:numeric size, 4:numeric scale, 5: null, 6: key, 7: extra, 8: position, 9: element type */ PHALCON_INIT_VAR(old_column); phalcon_is_iterable(describe, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(field); PHALCON_INIT_NVAR(definition); array_init_size(definition, 1); add_assoc_long_ex(definition, SS("bindType"), 2); PHALCON_OBS_NVAR(char_size); phalcon_array_fetch_long(&char_size, field, 2, PH_NOISY); if (Z_TYPE_P(char_size) != IS_NULL) { convert_to_long(char_size); } PHALCON_OBS_NVAR(numeric_size); phalcon_array_fetch_long(&numeric_size, field, 3, PH_NOISY); if (phalcon_is_numeric(numeric_size)) { convert_to_long(numeric_size); } PHALCON_OBS_NVAR(numeric_scale); phalcon_array_fetch_long(&numeric_scale, field, 4, PH_NOISY); if (phalcon_is_numeric(numeric_scale)) { convert_to_long(numeric_scale); } PHALCON_OBS_NVAR(column_type); phalcon_array_fetch_long(&column_type, field, 1, PH_NOISY); /** * Check the column type to get the correct Phalcon type */ while (1) { /** * Tinyint(1) is boolean */ if (phalcon_memnstr_str(column_type, SL("smallint(1)"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_BOOLEAN, PH_COPY); phalcon_array_update_string_long(&definition, SL("bindType"), 5, PH_COPY); break; } /** * Smallint/Bigint/Integers/Int are int */ if (phalcon_memnstr_str(column_type, SL("int"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_INTEGER, PH_COPY); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY); phalcon_array_update_string(&definition, SL("size"), numeric_size, PH_COPY); phalcon_array_update_string_long(&definition, SL("bindType"), 1, PH_COPY); break; } /** * Varchar */ if (phalcon_memnstr_str(column_type, SL("varying"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_VARCHAR, PH_COPY); phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY); break; } /** * Special type for datetime */ if (phalcon_memnstr_str(column_type, SL("date"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DATE, PH_COPY); phalcon_array_update_string_long(&definition, SL("size"), 0, PH_COPY); break; } /** * Numeric */ if (phalcon_memnstr_str(column_type, SL("numeric"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DECIMAL, PH_COPY); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY); if (phalcon_is_numeric(numeric_size)) { phalcon_array_update_string(&definition, SL("size"), numeric_size, PH_COPY); phalcon_array_update_string_long(&definition, SL("bytes"), Z_LVAL_P(numeric_size) * 8, PH_COPY); } else { phalcon_array_update_string_long(&definition, SL("size"), 30, PH_COPY); phalcon_array_update_string_long(&definition, SL("bytes"), 80, PH_COPY); } if (phalcon_is_numeric(numeric_scale)) { phalcon_array_update_string(&definition, SL("scale"), numeric_scale, PH_COPY); } else { phalcon_array_update_string_long(&definition, SL("scale"), 6, PH_COPY); } phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_COPY); break; } /** * Chars are chars */ if (phalcon_memnstr_str(column_type, SL("char"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_CHAR, PH_COPY); phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY); break; } /** * Date */ if (phalcon_memnstr_str(column_type, SL("timestamp"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DATETIME, PH_COPY); phalcon_array_update_string_long(&definition, SL("size"), 0, PH_COPY); break; } /** * Text are varchars */ if (phalcon_memnstr_str(column_type, SL("text"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_TEXT, PH_COPY); phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY); break; } /** * Float/Smallfloats/Decimals are float */ if (phalcon_memnstr_str(column_type, SL("float"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_FLOAT, PH_COPY); phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY); phalcon_array_update_string(&definition, SL("size"), numeric_size, PH_COPY); phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_COPY); break; } /** * Boolean */ if (phalcon_memnstr_str(column_type, SL("bool"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_BOOLEAN, PH_COPY); phalcon_array_update_string_long(&definition, SL("size"), 0, PH_COPY); phalcon_array_update_string_long(&definition, SL("bindType"), 5, PH_COPY); break; } /** * UUID */ if (phalcon_memnstr_str(column_type, SL("uuid"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_CHAR, PH_COPY); phalcon_array_update_string_long(&definition, SL("size"), 36, PH_COPY); break; } /** * JSON */ if (phalcon_memnstr_str(column_type, SL("json"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_JSON, PH_COPY); phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY); break; } /** * ARRAY */ if (phalcon_memnstr_str(column_type, SL("ARRAY"))) { phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_ARRAY, PH_COPY); phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY); break; } /** * By default is string */ phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_OTHER, PH_COPY); break; } if (phalcon_memnstr_str(column_type, SL("unsigned"))) { phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_COPY); } if (Z_TYPE_P(old_column) == IS_NULL) { phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_COPY); } else { phalcon_array_update_string(&definition, SL("after"), old_column, PH_COPY); } /** * Check if the field is primary key */ PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_long(&attribute, field, 6, PH_NOISY); if (PHALCON_IS_STRING(attribute, "PRI")) { phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_COPY); } /** * Check if the column allows null values */ PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_long(&attribute, field, 5, PH_NOISY); if (PHALCON_IS_STRING(attribute, "NO")) { phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_COPY); } /** * Check if the column is auto increment */ PHALCON_OBS_NVAR(attribute); phalcon_array_fetch_long(&attribute, field, 7, PH_NOISY); if (PHALCON_IS_STRING(attribute, "auto_increment")) { phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_COPY); } else if (!PHALCON_IS_EMPTY(attribute)) { phalcon_array_update_string(&definition, SL("default"), attribute, PH_COPY); } PHALCON_OBS_NVAR(column_name); phalcon_array_fetch_long(&column_name, field, 0, PH_NOISY); /** * Create a Phalcon\Db\Column to abstract the column */ PHALCON_INIT_NVAR(column); object_init_ex(column, phalcon_db_column_ce); PHALCON_CALL_METHOD(NULL, column, "__construct", column_name, definition); phalcon_array_append(&columns, column, PH_COPY); PHALCON_CPY_WRT(old_column, column_name); zend_hash_move_forward_ex(ah0, &hp0); } RETURN_CTOR(columns); }
PHP_METHOD(PhalconPlus_Enum_Sys, getModuleConfigPath) { zval *_0, *_4, *_7$$3; zend_long ZEPHIR_LAST_CALL_STATUS; zephir_fcall_cache_entry *_6 = NULL; zval *moduleDir_param = NULL, *confPrefix = NULL, *confPath = NULL, *_1 = NULL, _2, _3, *_5 = NULL, *_9 = NULL, *_8$$3 = NULL, *_10$$4, *_11$$4, *_12$$4; zval *moduleDir = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &moduleDir_param); zephir_get_strval(moduleDir, moduleDir_param); ZEPHIR_INIT_VAR(confPrefix); ZVAL_STRING(confPrefix, "", 1); ZEPHIR_INIT_VAR(confPath); ZVAL_STRING(confPath, "", 1); ZEPHIR_INIT_VAR(_0); zephir_create_array(_0, 4, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_1); ZEPHIR_SINIT_VAR(_2); ZVAL_STRING(&_2, "/", 0); zephir_fast_trim(_1, moduleDir, &_2, ZEPHIR_TRIM_RIGHT TSRMLS_CC); zephir_array_fast_append(_0, _1); ZEPHIR_INIT_NVAR(_1); ZVAL_STRING(_1, "app", 1); zephir_array_fast_append(_0, _1); ZEPHIR_INIT_NVAR(_1); ZVAL_STRING(_1, "config", 1); zephir_array_fast_append(_0, _1); ZEPHIR_INIT_NVAR(_1); ZVAL_STRING(_1, "", 1); zephir_array_fast_append(_0, _1); ZEPHIR_SINIT_VAR(_3); ZVAL_STRING(&_3, "/", 0); ZEPHIR_INIT_NVAR(confPrefix); zephir_fast_join(confPrefix, &_3, _0 TSRMLS_CC); ZEPHIR_INIT_VAR(_4); zephir_create_array(_4, 3, 0 TSRMLS_CC); zephir_array_fast_append(_4, confPrefix); ZEPHIR_INIT_NVAR(_1); ZEPHIR_GET_CONSTANT(_1, "APP_RUN_ENV"); zephir_array_fast_append(_4, _1); ZEPHIR_INIT_NVAR(_1); ZVAL_STRING(_1, ".php", 1); zephir_array_fast_append(_4, _1); ZEPHIR_INIT_NVAR(confPath); zephir_fast_join_str(confPath, SL(""), _4 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&_5, "is_file", &_6, 44, confPath); zephir_check_call_status(); if (!(zephir_is_true(_5))) { ZEPHIR_INIT_VAR(_7$$3); zephir_create_array(_7$$3, 3, 0 TSRMLS_CC); zephir_array_fast_append(_7$$3, confPrefix); ZEPHIR_INIT_VAR(_8$$3); ZVAL_STRING(_8$$3, "config", 1); zephir_array_fast_append(_7$$3, _8$$3); ZEPHIR_INIT_NVAR(_8$$3); ZVAL_STRING(_8$$3, ".php", 1); zephir_array_fast_append(_7$$3, _8$$3); ZEPHIR_INIT_NVAR(confPath); zephir_fast_join_str(confPath, SL(""), _7$$3 TSRMLS_CC); } ZEPHIR_CALL_FUNCTION(&_9, "is_file", &_6, 44, confPath); zephir_check_call_status(); if (!(zephir_is_true(_9))) { ZEPHIR_INIT_VAR(_10$$4); object_init_ex(_10$$4, zend_exception_get_default(TSRMLS_C)); ZEPHIR_INIT_VAR(_11$$4); ZEPHIR_GET_CONSTANT(_11$$4, "APP_RUN_ENV"); ZEPHIR_INIT_VAR(_12$$4); ZEPHIR_CONCAT_SVSVS(_12$$4, "Module Config file not exists: ", confPath, " & ", _11$$4, ".php"); ZEPHIR_CALL_METHOD(NULL, _10$$4, "__construct", NULL, 7, _12$$4); zephir_check_call_status(); zephir_throw_exception_debug(_10$$4, "phalconplus/Enum/Sys.zep", 143 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } RETURN_CCTOR(confPath); }
PHP_METHOD(Phalcon_Model_MetaData, _initializeMetaData){ zval *model = NULL, *table = NULL, *schema = NULL, *key = NULL, *connection = NULL, *is_view = NULL; zval *exists = NULL, *meta_datas = NULL, *attributes = NULL, *primary_keys = NULL; zval *non_primary_keys = NULL, *numeric_typed = NULL, *not_null = NULL; zval *field_types = NULL, *identity_field = NULL, *meta_data = NULL; zval *field_name = NULL, *type = NULL, *table_metadata = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL; zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL; zval *i0 = NULL; zval *a0 = NULL, *a1 = NULL, *a2 = NULL, *a3 = NULL, *a4 = NULL, *a5 = NULL, *a6 = NULL; zval *a7 = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL, *c3 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &model, &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_VV(r0, schema, table); PHALCON_CPY_WRT(key, r0); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_metaData"), PHALCON_NOISY TSRMLS_CC); eval_int = phalcon_array_isset(t0, key); if (!eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_METHOD(r1, model, "getconnection", PHALCON_NO_CHECK); PHALCON_CPY_WRT(connection, r1); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CALL_METHOD(r2, model, "isview", PHALCON_NO_CHECK); PHALCON_CPY_WRT(is_view, r2); if (!zend_is_true(is_view)) { PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_CALL_METHOD_PARAMS_2(r3, connection, "tableexists", table, schema, PHALCON_NO_CHECK); PHALCON_CPY_WRT(exists, r3); } else { PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CALL_METHOD_PARAMS_2(r4, connection, "viewexists", table, schema, PHALCON_NO_CHECK); PHALCON_CPY_WRT(exists, r4); } if (!zend_is_true(exists)) { PHALCON_ALLOC_ZVAL_MM(i0); object_init_ex(i0, phalcon_model_exception_ce); PHALCON_ALLOC_ZVAL_MM(r5); PHALCON_ALLOC_ZVAL_MM(r6); phalcon_get_class(r6, model TSRMLS_CC); PHALCON_CONCAT_SVSVSV(r5, "Table \"", schema, "\".\"", table, "\" doesn't exist on database when dumping information for ", r6); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r5, PHALCON_CHECK); phalcon_throw_exception(i0 TSRMLS_CC); return; } else { if (zend_is_true(is_view)) { PHALCON_ALLOC_ZVAL_MM(r7); PHALCON_CALL_METHOD_PARAMS_2(r7, connection, "describeview", table, schema, PHALCON_NO_CHECK); PHALCON_CPY_WRT(meta_datas, r7); } else { PHALCON_ALLOC_ZVAL_MM(r8); PHALCON_CALL_METHOD_PARAMS_2(r8, connection, "describetable", table, schema, PHALCON_NO_CHECK); PHALCON_CPY_WRT(meta_datas, r8); } PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(attributes, a0); PHALCON_INIT_VAR(a1); array_init(a1); PHALCON_CPY_WRT(primary_keys, a1); PHALCON_INIT_VAR(a2); array_init(a2); PHALCON_CPY_WRT(non_primary_keys, a2); PHALCON_INIT_VAR(a3); array_init(a3); PHALCON_CPY_WRT(numeric_typed, a3); PHALCON_INIT_VAR(a4); array_init(a4); PHALCON_CPY_WRT(not_null, a4); PHALCON_INIT_VAR(a5); array_init(a5); PHALCON_CPY_WRT(field_types, a5); PHALCON_INIT_VAR(identity_field); ZVAL_BOOL(identity_field, 0); if (phalcon_valid_foreach(meta_datas TSRMLS_CC)) { ah0 = Z_ARRVAL_P(meta_datas); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_f5c6_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_f5c6_0; } PHALCON_INIT_VAR(meta_data); ZVAL_ZVAL(meta_data, *hd, 1, 0); PHALCON_INIT_VAR(r9); phalcon_array_fetch_string(&r9, meta_data, SL("Field"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(field_name, r9); phalcon_array_append(&attributes, field_name, PHALCON_SEPARATE_PLZ TSRMLS_CC); PHALCON_INIT_VAR(r10); phalcon_array_fetch_string(&r10, meta_data, SL("Key"), PHALCON_NOISY TSRMLS_CC); if (PHALCON_COMPARE_STRING(r10, "PRI")) { phalcon_array_append(&primary_keys, field_name, PHALCON_SEPARATE_PLZ TSRMLS_CC); } else { phalcon_array_append(&non_primary_keys, field_name, PHALCON_SEPARATE_PLZ TSRMLS_CC); } PHALCON_INIT_VAR(r11); phalcon_array_fetch_string(&r11, meta_data, SL("Type"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(type, r11); phalcon_array_update(&field_types, field_name, &type, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "char", 1); PHALCON_INIT_VAR(r12); phalcon_fast_strpos(r12, type, c0 TSRMLS_CC); if (Z_TYPE_P(r12) == IS_BOOL && !Z_BVAL_P(r12)) { PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "int", 1); PHALCON_INIT_VAR(r13); phalcon_fast_strpos(r13, type, c1 TSRMLS_CC); if (Z_TYPE_P(r13) != IS_BOOL || (Z_TYPE_P(r13) == IS_BOOL && Z_BVAL_P(r13))) { PHALCON_INIT_VAR(t1); ZVAL_BOOL(t1, 1); phalcon_array_update(&numeric_typed, field_name, &t1, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); } else { PHALCON_INIT_VAR(c2); ZVAL_STRING(c2, "decimal", 1); PHALCON_INIT_VAR(r14); phalcon_fast_strpos(r14, type, c2 TSRMLS_CC); if (Z_TYPE_P(r14) != IS_BOOL || (Z_TYPE_P(r14) == IS_BOOL && Z_BVAL_P(r14))) { PHALCON_INIT_VAR(t2); ZVAL_BOOL(t2, 1); phalcon_array_update(&numeric_typed, field_name, &t2, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); } else { PHALCON_INIT_VAR(c3); ZVAL_STRING(c3, "numeric", 1); PHALCON_INIT_VAR(r15); phalcon_fast_strpos(r15, type, c3 TSRMLS_CC); if (Z_TYPE_P(r15) != IS_BOOL || (Z_TYPE_P(r15) == IS_BOOL && Z_BVAL_P(r15))) { PHALCON_INIT_VAR(t3); ZVAL_BOOL(t3, 1); phalcon_array_update(&numeric_typed, field_name, &t3, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); } } } } PHALCON_INIT_VAR(r16); phalcon_array_fetch_string(&r16, meta_data, SL("Null"), PHALCON_NOISY TSRMLS_CC); if (PHALCON_COMPARE_STRING(r16, "NO")) { phalcon_array_append(¬_null, field_name, PHALCON_SEPARATE_PLZ TSRMLS_CC); } PHALCON_INIT_VAR(r17); phalcon_array_fetch_string(&r17, meta_data, SL("Extra"), PHALCON_NOISY TSRMLS_CC); if (PHALCON_COMPARE_STRING(r17, "auto_increment")) { PHALCON_CPY_WRT(identity_field, field_name); } zend_hash_move_forward_ex(ah0, &hp0); goto fes_f5c6_0; fee_f5c6_0: if(0){} } else { return; } PHALCON_INIT_VAR(a6); array_init(a6); PHALCON_CPY_WRT(table_metadata, a6); phalcon_array_update_long(&table_metadata, 0, &attributes, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_array_update_long(&table_metadata, 1, &primary_keys, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_array_update_long(&table_metadata, 2, &non_primary_keys, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_array_update_long(&table_metadata, 3, ¬_null, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_array_update_long(&table_metadata, 4, &field_types, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_array_update_long(&table_metadata, 5, &numeric_typed, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_array_update_long(&table_metadata, 8, &identity_field, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t4); phalcon_read_property(&t4, this_ptr, SL("_metaData"), PHALCON_NOISY TSRMLS_CC); phalcon_array_update(&t4, key, &table_metadata, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_metaData"), t4 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t5); phalcon_read_property(&t5, this_ptr, SL("_changed"), PHALCON_NOISY TSRMLS_CC); if (!zend_is_true(t5)) { PHALCON_INIT_VAR(a7); array_init(a7); phalcon_array_append(&a7, this_ptr, PHALCON_SEPARATE_PLZ TSRMLS_CC); add_next_index_stringl(a7, SL("storeMetaData"), 1); PHALCON_CALL_FUNC_PARAMS_1_NORETURN("register_shutdown_function", a7); phalcon_update_property_bool(this_ptr, SL("_changed"), 1 TSRMLS_CC); } } } PHALCON_MM_RESTORE(); }
PHP_METHOD(Xs_FieldMeta, getCustomTokenizer) { zend_class_entry *_15, *_17; int ZEPHIR_LAST_CALL_STATUS; zval *name = NULL, *arg = NULL, *_7 = NULL, *_9 = NULL, *_11 = NULL; zval *tokenizer = NULL, *m = NULL, *_0, *_1, *_2, *_3, _4, *_5 = NULL, *_6, *_8 = NULL, *_10, *_12 = NULL, *_13 = NULL, *_14 = NULL, *_16 = NULL; ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(m); ZVAL_NULL(m); ZEPHIR_OBS_VAR(tokenizer); _0 = zephir_fetch_static_property_ce(xs_fieldmeta_ce, SL("tokenizers") TSRMLS_CC); _1 = zephir_fetch_nproperty_this(this_ptr, SL("tokenizer"), PH_NOISY_CC); if (zephir_array_isset_fetch(&tokenizer, _0, _1, 0 TSRMLS_CC)) { RETURN_CCTOR(tokenizer); } ZEPHIR_INIT_VAR(_2); _3 = zephir_fetch_nproperty_this(this_ptr, SL("tokenizer"), PH_NOISY_CC); ZEPHIR_SINIT_VAR(_4); ZVAL_STRING(&_4, "/^([^\\(]+)\\((.*)\\)$/", 0); zephir_preg_match(_2, &_4, _3, m, 0, 0 , 0 TSRMLS_CC); if (zephir_is_true(_2)) { ZEPHIR_INIT_VAR(_5); zephir_array_fetch_long(&_6, m, 1, PH_NOISY | PH_READONLY, "xs/fieldmeta.zep", 125 TSRMLS_CC); zephir_ucfirst(_5, _6); zephir_get_strval(_7, _5); ZEPHIR_INIT_VAR(name); ZEPHIR_CONCAT_SSV(name, "Xs", "\\Tokenizer", _7); ZEPHIR_OBS_VAR(_8); zephir_array_fetch_long(&_8, m, 2, PH_NOISY, "xs/fieldmeta.zep", 126 TSRMLS_CC); zephir_get_strval(_9, _8); ZEPHIR_CPY_WRT(arg, _9); } else { ZEPHIR_INIT_NVAR(_5); _10 = zephir_fetch_nproperty_this(this_ptr, SL("tokenizer"), PH_NOISY_CC); zephir_ucfirst(_5, _10); zephir_get_strval(_11, _5); ZEPHIR_INIT_NVAR(name); ZEPHIR_CONCAT_SSV(name, "Xs", "\\Tokenizer", _11); ZEPHIR_INIT_NVAR(arg); ZVAL_EMPTY_STRING(arg); } if (unlikely(!(zephir_class_exists(name, zephir_is_true(ZEPHIR_GLOBAL(global_true)) TSRMLS_CC)))) { ZEPHIR_INIT_NVAR(_5); object_init_ex(_5, xs_exception_ce); _10 = zephir_fetch_nproperty_this(this_ptr, SL("name"), PH_NOISY_CC); ZEPHIR_INIT_VAR(_12); ZEPHIR_CONCAT_SVSVS(_12, "Undefined custom tokenizer ", name, " for field `", _10, "`"); ZEPHIR_CALL_METHOD(NULL, _5, "__construct", NULL, 4, _12); zephir_check_call_status(); zephir_throw_exception_debug(_5, "xs/fieldmeta.zep", 133 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_INIT_NVAR(tokenizer); if (zephir_fast_strlen_ev(arg) > 0) { zephir_fetch_safe_class(_14, name); _15 = zend_fetch_class(Z_STRVAL_P(_14), Z_STRLEN_P(_14), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); object_init_ex(tokenizer, _15); if (zephir_has_constructor(tokenizer TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, tokenizer, "__construct", NULL, 0, arg); zephir_check_call_status(); } } else { zephir_fetch_safe_class(_16, name); _17 = zend_fetch_class(Z_STRVAL_P(_16), Z_STRLEN_P(_16), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); object_init_ex(tokenizer, _17); if (zephir_has_constructor(tokenizer TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, tokenizer, "__construct", NULL, 0); zephir_check_call_status(); } } if (unlikely(!((zephir_instance_of_ev(tokenizer, xs_tokenizer_ce TSRMLS_CC))))) { ZEPHIR_INIT_NVAR(_5); object_init_ex(_5, xs_exception_ce); _10 = zephir_fetch_nproperty_this(this_ptr, SL("name"), PH_NOISY_CC); ZEPHIR_INIT_LNVAR(_12); ZEPHIR_CONCAT_VSVS(_12, name, " for field `", _10, "` does not implement Tokenizer interface"); ZEPHIR_CALL_METHOD(NULL, _5, "__construct", NULL, 4, _12); zephir_check_call_status(); zephir_throw_exception_debug(_5, "xs/fieldmeta.zep", 143 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_OBS_NVAR(_8); zephir_read_property_this(&_8, this_ptr, SL("tokenizer"), PH_NOISY_CC); zephir_update_static_property_array_multi_ce(xs_fieldmeta_ce, SL("tokenizers"), &tokenizer TSRMLS_CC, SL("z"), 1, _8); RETURN_CCTOR(tokenizer); }
/** * Executes the validation */ PHP_METHOD(Phalcon_Validation_Validator_Date, validate) { int ZEPHIR_LAST_CALL_STATUS; zval *field = NULL; zval *validation, *field_param = NULL, *value = NULL, *format = NULL, *label = NULL, *message = NULL, *replacePairs = NULL, *_0, *_2 = NULL, *_1$$3, *_3$$5 = NULL, *_7$$5 = NULL, *_8$$5, *_4$$6, *_5$$8, *_6$$9; 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(_0); ZVAL_STRING(_0, "format", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&format, this_ptr, "getoption", NULL, 0, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (Z_TYPE_P(format) == IS_ARRAY) { zephir_array_fetch(&_1$$3, format, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/date.zep", 77 TSRMLS_CC); ZEPHIR_CPY_WRT(format, _1$$3); } if (ZEPHIR_IS_EMPTY(format)) { ZEPHIR_INIT_NVAR(format); ZVAL_STRING(format, "Y-m-d", 1); } ZEPHIR_CALL_METHOD(&_2, this_ptr, "checkdate", NULL, 472, value, format); zephir_check_call_status(); if (!(zephir_is_true(_2))) { ZEPHIR_INIT_VAR(_3$$5); ZVAL_STRING(_3$$5, "label", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _3$$5); zephir_check_temp_parameter(_3$$5); zephir_check_call_status(); if (Z_TYPE_P(label) == IS_ARRAY) { zephir_array_fetch(&_4$$6, label, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/date.zep", 87 TSRMLS_CC); ZEPHIR_CPY_WRT(label, _4$$6); } if (ZEPHIR_IS_EMPTY(label)) { ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_3$$5); ZVAL_STRING(_3$$5, "message", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _3$$5); zephir_check_temp_parameter(_3$$5); zephir_check_call_status(); if (Z_TYPE_P(message) == IS_ARRAY) { zephir_array_fetch(&_5$$8, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/date.zep", 95 TSRMLS_CC); ZEPHIR_CPY_WRT(message, _5$$8); } 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$$9); ZVAL_STRING(_6$$9, "Date", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _6$$9); zephir_check_temp_parameter(_6$$9); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_3$$5); object_init_ex(_3$$5, phalcon_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_7$$5, "strtr", NULL, 26, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_VAR(_8$$5); ZVAL_STRING(_8$$5, "Date", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _3$$5, "__construct", NULL, 466, _7$$5, field, _8$$5); zephir_check_temp_parameter(_8$$5); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _3$$5); zephir_check_call_status(); RETURN_MM_BOOL(0); } RETURN_MM_BOOL(1); }
/** * Executes the validation */ PHP_METHOD(Phalcon_Validation_Validator_Confirmation, validate) { int ZEPHIR_LAST_CALL_STATUS; zval *field = NULL; zval *validation, *field_param = NULL, *fieldWith = NULL, *value = NULL, *valueWith = NULL, *message = NULL, *label = NULL, *labelWith = NULL, *replacePairs = NULL, *code = NULL, *_0, *_2 = NULL, *_1$$3, *_3$$4 = NULL, *_9$$4 = NULL, *_10$$4, *_4$$5, *_5$$7, *_6$$9, *_7$$10, *_8$$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(_0); ZVAL_STRING(_0, "with", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&fieldWith, this_ptr, "getoption", NULL, 0, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); if (Z_TYPE_P(fieldWith) == IS_ARRAY) { zephir_array_fetch(&_1$$3, fieldWith, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/confirmation.zep", 65 TSRMLS_CC); ZEPHIR_CPY_WRT(fieldWith, _1$$3); } ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueWith, validation, "getvalue", NULL, 0, fieldWith); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_2, this_ptr, "compare", NULL, 464, value, valueWith); zephir_check_call_status(); if (!(zephir_is_true(_2))) { ZEPHIR_INIT_VAR(_3$$4); ZVAL_STRING(_3$$4, "label", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _3$$4); zephir_check_temp_parameter(_3$$4); zephir_check_call_status(); if (Z_TYPE_P(label) == IS_ARRAY) { zephir_array_fetch(&_4$$5, label, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/confirmation.zep", 75 TSRMLS_CC); ZEPHIR_CPY_WRT(label, _4$$5); } if (ZEPHIR_IS_EMPTY(label)) { ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_3$$4); ZVAL_STRING(_3$$4, "labelWith", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&labelWith, this_ptr, "getoption", NULL, 0, _3$$4); zephir_check_temp_parameter(_3$$4); zephir_check_call_status(); if (Z_TYPE_P(labelWith) == IS_ARRAY) { zephir_array_fetch(&_5$$7, labelWith, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/confirmation.zep", 83 TSRMLS_CC); ZEPHIR_CPY_WRT(labelWith, _5$$7); } if (ZEPHIR_IS_EMPTY(labelWith)) { ZEPHIR_CALL_METHOD(&labelWith, validation, "getlabel", NULL, 0, fieldWith); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_3$$4); ZVAL_STRING(_3$$4, "message", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _3$$4); zephir_check_temp_parameter(_3$$4); zephir_check_call_status(); if (Z_TYPE_P(message) == IS_ARRAY) { zephir_array_fetch(&_6$$9, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/confirmation.zep", 91 TSRMLS_CC); ZEPHIR_CPY_WRT(message, _6$$9); } 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(":with"), &labelWith, PH_COPY | PH_SEPARATE); if (ZEPHIR_IS_EMPTY(message)) { ZEPHIR_INIT_VAR(_7$$10); ZVAL_STRING(_7$$10, "Confirmation", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _7$$10); zephir_check_temp_parameter(_7$$10); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_3$$4); ZVAL_STRING(_3$$4, "code", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&code, this_ptr, "getoption", NULL, 0, _3$$4); zephir_check_temp_parameter(_3$$4); zephir_check_call_status(); if (Z_TYPE_P(code) == IS_ARRAY) { zephir_array_fetch(&_8$$11, code, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/confirmation.zep", 101 TSRMLS_CC); ZEPHIR_CPY_WRT(code, _8$$11); } ZEPHIR_INIT_NVAR(_3$$4); object_init_ex(_3$$4, phalcon_validation_message_ce); ZEPHIR_CALL_FUNCTION(&_9$$4, "strtr", NULL, 26, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_VAR(_10$$4); ZVAL_STRING(_10$$4, "Confirmation", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _3$$4, "__construct", NULL, 462, _9$$4, field, _10$$4, code); zephir_check_temp_parameter(_10$$4); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _3$$4); zephir_check_call_status(); RETURN_MM_BOOL(0); } RETURN_MM_BOOL(1); }
/** * Phalcon\Session\Adapter\Redis constructor */ PHP_METHOD(Phalcon_Session_Adapter_Redis, __construct) { zephir_fcall_cache_entry *_13 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *options_param = NULL, *lifetime = NULL, *_2, *_3, *_5, *_7 = NULL, *_0$$3, *_1$$4; zval *options = NULL, *_4, *_6, *_8, *_9, *_10, *_11, *_12; 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, 6379); zephir_array_update_string(&options, SL("port"), &_1$$4, PH_COPY | PH_SEPARATE); } if (!(zephir_array_isset_string(options, SS("persistent")))) { zephir_array_update_string(&options, SL("persistent"), &ZEPHIR_GLOBAL(global_false), 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(getThis(), SL("_lifetime"), lifetime TSRMLS_CC); } ZEPHIR_INIT_VAR(_2); object_init_ex(_2, phalcon_cache_backend_redis_ce); ZEPHIR_INIT_VAR(_3); object_init_ex(_3, phalcon_cache_frontend_none_ce); if (zephir_has_constructor(_3 TSRMLS_CC)) { ZEPHIR_INIT_VAR(_4); zephir_create_array(_4, 1, 0 TSRMLS_CC); ZEPHIR_OBS_VAR(_5); zephir_read_property_this(&_5, this_ptr, SL("_lifetime"), PH_NOISY_CC); zephir_array_update_string(&_4, SL("lifetime"), &_5, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(NULL, _3, "__construct", NULL, 0, _4); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(NULL, _2, "__construct", NULL, 347, _3, options); zephir_check_call_status(); zephir_update_property_this(getThis(), SL("_redis"), _2 TSRMLS_CC); ZEPHIR_INIT_VAR(_6); zephir_create_array(_6, 2, 0 TSRMLS_CC); zephir_array_fast_append(_6, this_ptr); ZEPHIR_INIT_VAR(_7); ZVAL_STRING(_7, "open", 1); zephir_array_fast_append(_6, _7); ZEPHIR_INIT_VAR(_8); zephir_create_array(_8, 2, 0 TSRMLS_CC); zephir_array_fast_append(_8, this_ptr); ZEPHIR_INIT_NVAR(_7); ZVAL_STRING(_7, "close", 1); zephir_array_fast_append(_8, _7); ZEPHIR_INIT_VAR(_9); zephir_create_array(_9, 2, 0 TSRMLS_CC); zephir_array_fast_append(_9, this_ptr); ZEPHIR_INIT_NVAR(_7); ZVAL_STRING(_7, "read", 1); zephir_array_fast_append(_9, _7); ZEPHIR_INIT_VAR(_10); zephir_create_array(_10, 2, 0 TSRMLS_CC); zephir_array_fast_append(_10, this_ptr); ZEPHIR_INIT_NVAR(_7); ZVAL_STRING(_7, "write", 1); zephir_array_fast_append(_10, _7); ZEPHIR_INIT_VAR(_11); zephir_create_array(_11, 2, 0 TSRMLS_CC); zephir_array_fast_append(_11, this_ptr); ZEPHIR_INIT_NVAR(_7); ZVAL_STRING(_7, "destroy", 1); zephir_array_fast_append(_11, _7); ZEPHIR_INIT_VAR(_12); zephir_create_array(_12, 2, 0 TSRMLS_CC); zephir_array_fast_append(_12, this_ptr); ZEPHIR_INIT_NVAR(_7); ZVAL_STRING(_7, "gc", 1); zephir_array_fast_append(_12, _7); ZEPHIR_CALL_FUNCTION(NULL, "session_set_save_handler", NULL, 447, _6, _8, _9, _10, _11, _12); zephir_check_call_status(); ZEPHIR_CALL_PARENT(NULL, phalcon_session_adapter_redis_ce, getThis(), "__construct", &_13, 448, options); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); }
/** * Magic method to get or set services using setters/getters * * @param string method * @param array arguments * @return mixed */ PHP_METHOD(Phalcon_Di, __call) { zephir_fcall_cache_entry *_3 = NULL; int ZEPHIR_LAST_CALL_STATUS; zephir_nts_static zephir_fcall_cache_entry *_2 = NULL, *_6 = NULL; zval *method_param = NULL, *arguments = NULL, *instance = NULL, *possibleService = NULL, *services, *definition, _0 = zval_used_for_init, *_1 = NULL, *_4 = NULL; zval *method = NULL, *_5; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &method_param, &arguments); if (unlikely(Z_TYPE_P(method_param) != IS_STRING && Z_TYPE_P(method_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'method' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(method_param) == IS_STRING)) { zephir_get_strval(method, method_param); } else { ZEPHIR_INIT_VAR(method); ZVAL_EMPTY_STRING(method); } if (!arguments) { arguments = ZEPHIR_GLOBAL(global_null); } if (zephir_start_with_str(method, SL("get"))) { ZEPHIR_OBS_VAR(services); zephir_read_property_this(&services, this_ptr, SL("_services"), PH_NOISY_CC); ZEPHIR_SINIT_VAR(_0); ZVAL_LONG(&_0, 3); ZEPHIR_INIT_VAR(_1); zephir_substr(_1, method, 3 , 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_CALL_FUNCTION(&possibleService, "lcfirst", &_2, _1); zephir_check_call_status(); if (zephir_array_isset(services, possibleService)) { if (zephir_fast_count_int(arguments TSRMLS_CC)) { ZEPHIR_CALL_METHOD(&instance, this_ptr, "get", &_3, possibleService, arguments); zephir_check_call_status(); } else { ZEPHIR_CALL_METHOD(&instance, this_ptr, "get", &_3, possibleService); zephir_check_call_status(); } RETURN_CCTOR(instance); } } if (zephir_start_with_str(method, SL("set"))) { ZEPHIR_OBS_VAR(definition); if (zephir_array_isset_long_fetch(&definition, arguments, 0, 0 TSRMLS_CC)) { ZEPHIR_SINIT_NVAR(_0); ZVAL_LONG(&_0, 3); ZEPHIR_INIT_NVAR(_1); zephir_substr(_1, method, 3 , 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_CALL_FUNCTION(&_4, "lcfirst", &_2, _1); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "set", NULL, _4, definition); zephir_check_call_status(); RETURN_MM_NULL(); } } ZEPHIR_INIT_NVAR(_1); object_init_ex(_1, phalcon_di_exception_ce); ZEPHIR_INIT_VAR(_5); ZEPHIR_CONCAT_SVS(_5, "Call to undefined method or service '", method, "'"); ZEPHIR_CALL_METHOD(NULL, _1, "__construct", &_6, _5); zephir_check_call_status(); zephir_throw_exception_debug(_1, "phalcon/di.zep", 436 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; }
/** * Create internal connection to memcached */ PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, _connect) { zval options, memcache, client, servers, persistentId, _0, _1$$4, _2$$4; zend_long ZEPHIR_LAST_CALL_STATUS; zval *this_ptr = getThis(); ZVAL_UNDEF(&options); ZVAL_UNDEF(&memcache); ZVAL_UNDEF(&client); ZVAL_UNDEF(&servers); ZVAL_UNDEF(&persistentId); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1$$4); ZVAL_UNDEF(&_2$$4); ZEPHIR_MM_GROW(); ZEPHIR_OBS_VAR(&options); zephir_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC); ZEPHIR_OBS_VAR(&persistentId); if (!(zephir_array_isset_string_fetch(&persistentId, &options, SL("persistent_id"), 0))) { ZEPHIR_INIT_NVAR(&persistentId); ZVAL_STRING(&persistentId, "phalcon_cache"); } ZEPHIR_INIT_VAR(&memcache); object_init_ex(&memcache, zephir_get_internal_ce(SL("memcached"))); ZEPHIR_CALL_METHOD(NULL, &memcache, "__construct", NULL, 0, &persistentId); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_0, &memcache, "getserverlist", NULL, 0); zephir_check_call_status(); if (ZEPHIR_IS_EMPTY(&_0)) { ZEPHIR_OBS_VAR(&servers); if (!(zephir_array_isset_string_fetch(&servers, &options, SL("servers"), 0))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Servers must be an array", "phalcon/cache/backend/libmemcached.zep", 110); return; } if (Z_TYPE_P(&servers) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Servers must be an array", "phalcon/cache/backend/libmemcached.zep", 114); return; } ZEPHIR_OBS_VAR(&client); if (!(zephir_array_isset_string_fetch(&client, &options, SL("client"), 0))) { ZEPHIR_INIT_NVAR(&client); array_init(&client); } if (Z_TYPE_P(&client) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Client options must be instance of array", "phalcon/cache/backend/libmemcached.zep", 122); return; } ZEPHIR_CALL_METHOD(&_1$$4, &memcache, "setoptions", NULL, 0, &client); zephir_check_call_status(); if (!(zephir_is_true(&_1$$4))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cannot set to Memcached options", "phalcon/cache/backend/libmemcached.zep", 126); return; } ZEPHIR_CALL_METHOD(&_2$$4, &memcache, "addservers", NULL, 0, &servers); zephir_check_call_status(); if (!(zephir_is_true(&_2$$4))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cannot connect to Memcached server", "phalcon/cache/backend/libmemcached.zep", 130); return; } } zephir_update_property_zval(this_ptr, SL("_memcache"), &memcache); ZEPHIR_MM_RESTORE(); }
/** * Throws an internal exception * * @param string $message * @param int $exceptionCode */ PHP_METHOD(Phalcon_Mvc_Dispatcher, _throwDispatchException){ zval *message, *exception_code = NULL, *dependency_injector; zval *exception_message, *exception = NULL, *service; zval *response, *status_code, *status_message; zval *events_manager, *event_name, *status; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &message, &exception_code); if (!exception_code) { PHALCON_INIT_VAR(exception_code); ZVAL_LONG(exception_code, 0); } else { PHALCON_SEPARATE_PARAM(exception_code); } PHALCON_OBS_VAR(dependency_injector); phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_INIT_NVAR(exception_code); ZVAL_LONG(exception_code, 0); PHALCON_INIT_VAR(exception_message); ZVAL_STRING(exception_message, "A dependency injection container is required to access the 'response' service", 1); PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_mvc_dispatcher_exception_ce); phalcon_call_method_p2_noret(exception, "__construct", exception_message, exception_code); phalcon_throw_exception(exception TSRMLS_CC); return; } PHALCON_INIT_VAR(service); ZVAL_STRING(service, "response", 1); PHALCON_INIT_VAR(response); phalcon_call_method_p1(response, dependency_injector, "getshared", service); /** * Dispatcher exceptions automatically sends 404 status */ PHALCON_INIT_VAR(status_code); ZVAL_LONG(status_code, 404); PHALCON_INIT_VAR(status_message); ZVAL_STRING(status_message, "Not Found", 1); phalcon_call_method_p2_noret(response, "setstatuscode", status_code, status_message); /** * Create the real exception */ PHALCON_INIT_NVAR(exception); object_init_ex(exception, phalcon_mvc_dispatcher_exception_ce); phalcon_call_method_p2_noret(exception, "__construct", message, exception_code); PHALCON_OBS_VAR(events_manager); phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "dispatch:beforeException", 1); PHALCON_INIT_VAR(status); phalcon_call_method_p3(status, events_manager, "fire", event_name, this_ptr, exception); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } /** * Throw the exception if it wasn't handled */ phalcon_throw_exception(exception TSRMLS_CC); return; }
/** * Stores cached content into the file backend and stops the frontend * * @param int|string keyName * @param string content * @param int lifetime */ PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, save) { zend_long ZEPHIR_LAST_CALL_STATUS; zend_bool stopBuffer; zval *keyName = NULL, keyName_sub, *content = NULL, content_sub, *lifetime = NULL, lifetime_sub, *stopBuffer_param = NULL, __$true, __$false, __$null, lastKey, frontend, memcache, cachedContent, preparedContent, tmp, tt1, success, options, specialKey, keys, isBuffering, _0$$4, _1$$15, _2$$15, _3$$15; zval *this_ptr = getThis(); ZVAL_UNDEF(&keyName_sub); ZVAL_UNDEF(&content_sub); ZVAL_UNDEF(&lifetime_sub); ZVAL_BOOL(&__$true, 1); ZVAL_BOOL(&__$false, 0); ZVAL_NULL(&__$null); ZVAL_UNDEF(&lastKey); ZVAL_UNDEF(&frontend); ZVAL_UNDEF(&memcache); ZVAL_UNDEF(&cachedContent); ZVAL_UNDEF(&preparedContent); ZVAL_UNDEF(&tmp); ZVAL_UNDEF(&tt1); ZVAL_UNDEF(&success); ZVAL_UNDEF(&options); ZVAL_UNDEF(&specialKey); ZVAL_UNDEF(&keys); ZVAL_UNDEF(&isBuffering); ZVAL_UNDEF(&_0$$4); ZVAL_UNDEF(&_1$$15); ZVAL_UNDEF(&_2$$15); ZVAL_UNDEF(&_3$$15); ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 4, &keyName, &content, &lifetime, &stopBuffer_param); if (!keyName) { keyName = &keyName_sub; keyName = &__$null; } if (!content) { content = &content_sub; content = &__$null; } if (!lifetime) { lifetime = &lifetime_sub; lifetime = &__$null; } if (!stopBuffer_param) { stopBuffer = 1; } else { stopBuffer = zephir_get_boolval(stopBuffer_param); } if (Z_TYPE_P(keyName) == IS_NULL) { ZEPHIR_OBS_VAR(&lastKey); zephir_read_property(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC); } else { zephir_read_property(&_0$$4, this_ptr, SL("_prefix"), PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&lastKey); ZEPHIR_CONCAT_VV(&lastKey, &_0$$4, keyName); zephir_update_property_zval(this_ptr, SL("_lastKey"), &lastKey); } if (!(zephir_is_true(&lastKey))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache must be started first", "phalcon/cache/backend/libmemcached.zep", 186); return; } ZEPHIR_OBS_VAR(&frontend); zephir_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); ZEPHIR_OBS_VAR(&memcache); zephir_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC); if (Z_TYPE_P(&memcache) != IS_OBJECT) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&memcache); zephir_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC); } if (Z_TYPE_P(content) == IS_NULL) { 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(); } else { ZEPHIR_CPY_WRT(&preparedContent, &cachedContent); } if (Z_TYPE_P(lifetime) == IS_NULL) { ZEPHIR_OBS_VAR(&tmp); zephir_read_property(&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); } ZEPHIR_CALL_METHOD(&success, &memcache, "set", NULL, 0, &lastKey, &preparedContent, &tt1); zephir_check_call_status(); if (!(zephir_is_true(&success))) { ZEPHIR_INIT_VAR(&_1$$15); object_init_ex(&_1$$15, phalcon_cache_exception_ce); ZEPHIR_CALL_METHOD(&_2$$15, &memcache, "getresultcode", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3$$15); ZEPHIR_CONCAT_SV(&_3$$15, "Failed storing data in memcached, error code: ", &_2$$15); ZEPHIR_CALL_METHOD(NULL, &_1$$15, "__construct", NULL, 4, &_3$$15); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$15, "phalcon/cache/backend/libmemcached.zep", 230 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_OBS_VAR(&options); zephir_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC); ZEPHIR_OBS_VAR(&specialKey); if (!(zephir_array_isset_string_fetch(&specialKey, &options, SL("statsKey"), 0))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/libmemcached.zep", 236); return; } if (!ZEPHIR_IS_STRING(&specialKey, "")) { ZEPHIR_CALL_METHOD(&keys, &memcache, "get", NULL, 0, &specialKey); zephir_check_call_status(); if (Z_TYPE_P(&keys) != IS_ARRAY) { ZEPHIR_INIT_NVAR(&keys); array_init(&keys); } if (!(zephir_array_isset(&keys, &lastKey))) { zephir_array_update_zval(&keys, &lastKey, &tt1, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(NULL, &memcache, "set", NULL, 0, &specialKey, &keys); 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_zval(this_ptr, SL("_started"), &__$true); } else { zephir_update_property_zval(this_ptr, SL("_started"), &__$false); } RETURN_CCTOR(&success); }
/** * Handle the whole command-line tasks */ PHP_METHOD(Phalcon_Cli_Console, handle) { zend_bool _5; int ZEPHIR_LAST_CALL_STATUS; zval *arguments_param = NULL, *dependencyInjector = NULL, *router = NULL, *eventsManager = NULL, *moduleName = NULL, *modules = NULL, *module = NULL, *path = NULL, *className = NULL, *moduleObject = NULL, *dispatcher = NULL, *task = NULL, *_0, *_3 = NULL, *_4 = NULL, *_15 = NULL, *_16 = NULL, *_17, *_1$$4 = NULL, *_2$$4, *_6$$6, *_7$$10 = NULL, *_8$$10, *_9$$12, *_10$$12, *_11$$15, *_12$$15, *_13$$17 = NULL, *_14$$17, *_18$$19 = NULL, *_19$$19, *_20$$21; zval *arguments = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &arguments_param); if (!arguments_param) { ZEPHIR_INIT_VAR(arguments); array_init(arguments); } else { zephir_get_arrval(arguments, arguments_param); } ZEPHIR_OBS_VAR(dependencyInjector); zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_console_exception_ce, "A dependency injection object is required to access internal services", "phalcon/cli/console.zep", 69); return; } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC); ZEPHIR_CPY_WRT(eventsManager, _0); if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(_2$$4); ZVAL_STRING(_2$$4, "console:boot", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_1$$4, eventsManager, "fire", NULL, 0, _2$$4, this_ptr); zephir_check_temp_parameter(_2$$4); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(_1$$4)) { RETURN_MM_BOOL(0); } } ZEPHIR_INIT_VAR(_4); ZVAL_STRING(_4, "router", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_3, dependencyInjector, "getshared", NULL, 0, _4); zephir_check_temp_parameter(_4); zephir_check_call_status(); ZEPHIR_CPY_WRT(router, _3); _5 = !(zephir_fast_count_int(arguments TSRMLS_CC)); if (_5) { _0 = zephir_fetch_nproperty_this(this_ptr, SL("_arguments"), PH_NOISY_CC); _5 = zephir_is_true(_0); } if (_5) { _6$$6 = zephir_fetch_nproperty_this(this_ptr, SL("_arguments"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(NULL, router, "handle", NULL, 0, _6$$6); zephir_check_call_status(); } else { ZEPHIR_CALL_METHOD(NULL, router, "handle", NULL, 0, arguments); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&moduleName, router, "getmodulename", NULL, 0); zephir_check_call_status(); if (!(zephir_is_true(moduleName))) { ZEPHIR_OBS_NVAR(moduleName); zephir_read_property_this(&moduleName, this_ptr, SL("_defaultModule"), PH_NOISY_CC); } if (zephir_is_true(moduleName)) { if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(_8$$10); ZVAL_STRING(_8$$10, "console:beforeStartModule", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_7$$10, eventsManager, "fire", NULL, 0, _8$$10, this_ptr, moduleName); zephir_check_temp_parameter(_8$$10); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(_7$$10)) { RETURN_MM_BOOL(0); } } ZEPHIR_OBS_VAR(modules); zephir_read_property_this(&modules, this_ptr, SL("_modules"), PH_NOISY_CC); if (!(zephir_array_isset(modules, moduleName))) { ZEPHIR_INIT_VAR(_9$$12); object_init_ex(_9$$12, phalcon_cli_console_exception_ce); ZEPHIR_INIT_VAR(_10$$12); ZEPHIR_CONCAT_SVS(_10$$12, "Module '", moduleName, "' isn't registered in the console container"); ZEPHIR_CALL_METHOD(NULL, _9$$12, "__construct", NULL, 9, _10$$12); zephir_check_call_status(); zephir_throw_exception_debug(_9$$12, "phalcon/cli/console.zep", 109 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_OBS_VAR(module); zephir_array_fetch(&module, modules, moduleName, PH_NOISY, "phalcon/cli/console.zep", 112 TSRMLS_CC); if (Z_TYPE_P(module) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_console_exception_ce, "Invalid module definition path", "phalcon/cli/console.zep", 114); return; } ZEPHIR_OBS_VAR(path); if (zephir_array_isset_string_fetch(&path, module, SS("path"), 0 TSRMLS_CC)) { if (!((zephir_file_exists(path TSRMLS_CC) == SUCCESS))) { ZEPHIR_INIT_VAR(_11$$15); object_init_ex(_11$$15, phalcon_cli_console_exception_ce); ZEPHIR_INIT_VAR(_12$$15); ZEPHIR_CONCAT_SVS(_12$$15, "Module definition path '", path, "' doesn't exist"); ZEPHIR_CALL_METHOD(NULL, _11$$15, "__construct", NULL, 9, _12$$15); zephir_check_call_status(); zephir_throw_exception_debug(_11$$15, "phalcon/cli/console.zep", 119 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } if (zephir_require_zval(path TSRMLS_CC) == FAILURE) { RETURN_MM_NULL(); } } ZEPHIR_OBS_VAR(className); if (!(zephir_array_isset_string_fetch(&className, module, SS("className"), 0 TSRMLS_CC))) { ZEPHIR_INIT_NVAR(className); ZVAL_STRING(className, "Module", 1); } ZEPHIR_CALL_METHOD(&moduleObject, dependencyInjector, "get", NULL, 0, className); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, moduleObject, "registerautoloaders", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, moduleObject, "registerservices", NULL, 0, dependencyInjector); zephir_check_call_status(); if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(_14$$17); ZVAL_STRING(_14$$17, "console:afterStartModule", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_13$$17, eventsManager, "fire", NULL, 0, _14$$17, this_ptr, moduleObject); zephir_check_temp_parameter(_14$$17); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(_13$$17)) { RETURN_MM_BOOL(0); } } } ZEPHIR_INIT_NVAR(_4); ZVAL_STRING(_4, "dispatcher", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_3, dependencyInjector, "getshared", NULL, 0, _4); zephir_check_temp_parameter(_4); zephir_check_call_status(); ZEPHIR_CPY_WRT(dispatcher, _3); ZEPHIR_CALL_METHOD(&_3, router, "gettaskname", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, dispatcher, "settaskname", NULL, 0, _3); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_15, router, "getactionname", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, dispatcher, "setactionname", NULL, 0, _15); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_16, router, "getparams", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, dispatcher, "setparams", NULL, 0, _16); zephir_check_call_status(); _17 = zephir_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(NULL, dispatcher, "setoptions", NULL, 0, _17); zephir_check_call_status(); if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(_19$$19); ZVAL_STRING(_19$$19, "console:beforeHandleTask", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_18$$19, eventsManager, "fire", NULL, 0, _19$$19, this_ptr, dispatcher); zephir_check_temp_parameter(_19$$19); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(_18$$19)) { RETURN_MM_BOOL(0); } } ZEPHIR_CALL_METHOD(&task, dispatcher, "dispatch", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(_20$$21); ZVAL_STRING(_20$$21, "console:afterHandleTask", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _20$$21, this_ptr, task); zephir_check_temp_parameter(_20$$21); zephir_check_call_status(); } RETURN_CCTOR(task); }
void grpc_php_wrap_timeval(gpr_timespec wrapped, zval *timeval_object) { object_init_ex(timeval_object, grpc_ce_timeval); wrapped_grpc_timeval *timeval = Z_WRAPPED_GRPC_TIMEVAL_P(timeval_object); memcpy(&timeval->wrapped, &wrapped, sizeof(gpr_timespec)); }
/** * Inserts data into a table using custom RBDM SQL syntax * * @param string $table * @param array $values * @param array $fields * @return boolean */ PHP_METHOD(Phalcon_Db, insert){ zval *table = NULL, *values = NULL, *fields = NULL, *number_values = NULL, *exception_message = NULL; zval *exception = NULL, *placeholders = NULL, *value = NULL, *n = NULL, *str_value = NULL; zval *comma = NULL, *joined_values = NULL, *joined_fields = NULL; zval *insert_sql = NULL, *success = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &table, &values, &fields) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_SEPARATE_PARAM(values); if (!fields) { PHALCON_ALLOC_ZVAL_MM(fields); ZVAL_NULL(fields); } if (Z_TYPE_P(values) == IS_ARRAY) { PHALCON_INIT_VAR(number_values); phalcon_fast_count(number_values, values TSRMLS_CC); if (!zend_is_true(number_values)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Unable to insert into ", table, " without data"); PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_db_exception_ce); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(exception, "__construct", exception_message, PH_CHECK); phalcon_throw_exception(exception TSRMLS_CC); return; } PHALCON_INIT_VAR(placeholders); array_init(placeholders); if (!phalcon_valid_foreach(values TSRMLS_CC)) { return; } ALLOC_HASHTABLE(ah0); zend_hash_init(ah0, 0, NULL, NULL, 0); zend_hash_copy(ah0, Z_ARRVAL_P(values), NULL, NULL, sizeof(zval*)); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_e7f0_1: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_e7f0_1; } PHALCON_INIT_VAR(n); PHALCON_GET_FOREACH_KEY(n, ah0, hp0); PHALCON_INIT_VAR(value); ZVAL_ZVAL(value, *hd, 1, 0); if (Z_TYPE_P(value) == IS_OBJECT) { PHALCON_INIT_VAR(str_value); PHALCON_CALL_FUNC_PARAMS_1(str_value, "strval", value); phalcon_array_append(&placeholders, str_value, PH_SEPARATE TSRMLS_CC); PHALCON_SEPARATE_PARAM(values); phalcon_array_unset(values, n); } else { if (Z_TYPE_P(value) == IS_NULL) { phalcon_array_append_string(&placeholders, SL("null"), PH_SEPARATE TSRMLS_CC); PHALCON_SEPARATE_PARAM(values); phalcon_array_unset(values, n); } else { phalcon_array_append_string(&placeholders, SL("?"), PH_SEPARATE TSRMLS_CC); } } zend_hash_move_forward_ex(ah0, &hp0); goto fes_e7f0_1; fee_e7f0_1: zend_hash_destroy(ah0); efree(ah0); PHALCON_INIT_VAR(comma); ZVAL_STRING(comma, ", ", 1); PHALCON_INIT_VAR(joined_values); phalcon_fast_join(joined_values, comma, placeholders TSRMLS_CC); if (Z_TYPE_P(fields) == IS_ARRAY) { PHALCON_INIT_VAR(joined_fields); phalcon_fast_join(joined_fields, comma, fields TSRMLS_CC); PHALCON_INIT_VAR(insert_sql); PHALCON_CONCAT_SVSVSVS(insert_sql, "INSERT INTO ", table, " (", joined_fields, ") VALUES (", joined_values, ")"); } else { PHALCON_INIT_VAR(insert_sql); PHALCON_CONCAT_SVSVS(insert_sql, "INSERT INTO ", table, " VALUES (", joined_values, ")"); } PHALCON_INIT_VAR(success); PHALCON_CALL_METHOD_PARAMS_2(success, this_ptr, "execute", insert_sql, values, PH_NO_CHECK); RETURN_CCTOR(success); } PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The second parameter for insert isn't an Array"); return; }
ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_entry *scope, zval *this_ptr) /* {{{ */ { zend_closure *closure; object_init_ex(res, zend_ce_closure); closure = (zend_closure *)Z_OBJ_P(res); closure->func = *func; closure->func.common.prototype = (zend_function*)closure; closure->func.common.fn_flags |= ZEND_ACC_CLOSURE; if ((scope == NULL) && this_ptr && (Z_TYPE_P(this_ptr) != IS_UNDEF)) { /* use dummy scope if we're binding an object without specifying a scope */ /* maybe it would be better to create one for this purpose */ scope = zend_ce_closure; } if (closure->func.type == ZEND_USER_FUNCTION) { if (closure->func.op_array.static_variables) { HashTable *static_variables = closure->func.op_array.static_variables; ALLOC_HASHTABLE(closure->func.op_array.static_variables); zend_hash_init(closure->func.op_array.static_variables, zend_hash_num_elements(static_variables), NULL, ZVAL_PTR_DTOR, 0); zend_hash_apply_with_arguments(static_variables, zval_copy_static_var, 1, closure->func.op_array.static_variables); } closure->func.op_array.run_time_cache = NULL; if (closure->func.op_array.refcount) { (*closure->func.op_array.refcount)++; } } else { /* verify that we aren't binding internal function to a wrong scope */ if(func->common.scope != NULL) { if(scope && !instanceof_function(scope, func->common.scope)) { zend_error(E_WARNING, "Cannot bind function %s::%s to scope class %s", func->common.scope->name->val, func->common.function_name->val, scope->name->val); scope = NULL; } if(scope && this_ptr && (func->common.fn_flags & ZEND_ACC_STATIC) == 0 && !instanceof_function(Z_OBJCE_P(this_ptr), closure->func.common.scope)) { zend_error(E_WARNING, "Cannot bind function %s::%s to object of class %s", func->common.scope->name->val, func->common.function_name->val, Z_OBJCE_P(this_ptr)->name->val); scope = NULL; this_ptr = NULL; } } else { /* if it's a free function, we won't set scope & this since they're meaningless */ this_ptr = NULL; scope = NULL; } } ZVAL_UNDEF(&closure->this_ptr); /* Invariants: * If the closure is unscoped, it has no bound object. * The the closure is scoped, it's either static or it's bound */ closure->func.common.scope = scope; if (scope) { closure->func.common.fn_flags |= ZEND_ACC_PUBLIC; if (this_ptr && Z_TYPE_P(this_ptr) == IS_OBJECT && (closure->func.common.fn_flags & ZEND_ACC_STATIC) == 0) { ZVAL_COPY(&closure->this_ptr, this_ptr); } else { closure->func.common.fn_flags |= ZEND_ACC_STATIC; } } }