/** * Inserts data into a table using custom RBDM SQL syntax * * <code> * //Inserting a new robot * $success = $connection->insert( * "robots", * array("Astro Boy", 1952), * array("name", "year") * ); * * //Next SQL sentence is sent to the database system * INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952); * </code> * * @param string $table * @param array $values * @param array $fields * @param array $dataTypes * @return boolean */ PHP_METHOD(Phalcon_Db, insert){ zval *table, *values, *fields = NULL, *data_types = NULL, *exception_message; zval *placeholders, *insert_values, *bind_data_types = NULL; zval *value = NULL, *position = NULL, *str_value = NULL, *bind_type = NULL; zval *joined_values, *joined_fields, *insert_sql = NULL; zval *success; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|zz", &table, &values, &fields, &data_types) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!fields) { PHALCON_INIT_NVAR(fields); } if (!data_types) { PHALCON_INIT_NVAR(data_types); } if (Z_TYPE_P(values) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The second parameter for insert isn't an Array"); return; } if (!phalcon_fast_count_ev(values TSRMLS_CC)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Unable to insert into ", table, " without data"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_db_exception_ce, exception_message); return; } PHALCON_INIT_VAR(placeholders); array_init(placeholders); PHALCON_INIT_VAR(insert_values); array_init(insert_values); if (Z_TYPE_P(data_types) == IS_ARRAY) { PHALCON_INIT_VAR(bind_data_types); array_init(bind_data_types); } else { PHALCON_CPY_WRT(bind_data_types, data_types); } if (!phalcon_valid_foreach(values TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(values); 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_KEY(position, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (Z_TYPE_P(value) == IS_OBJECT) { PHALCON_INIT_NVAR(str_value); PHALCON_CALL_FUNC_PARAMS_1(str_value, "strval", value); phalcon_array_append(&placeholders, str_value, PH_SEPARATE TSRMLS_CC); } else { if (Z_TYPE_P(value) == IS_NULL) { phalcon_array_append_string(&placeholders, SL("null"), PH_SEPARATE TSRMLS_CC); } else { phalcon_array_append_string(&placeholders, SL("?"), PH_SEPARATE TSRMLS_CC); phalcon_array_append(&insert_values, value, PH_SEPARATE TSRMLS_CC); if (Z_TYPE_P(data_types) == IS_ARRAY) { eval_int = phalcon_array_isset(data_types, position); if (!eval_int) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Incomplete number of bind types"); return; } PHALCON_INIT_NVAR(bind_type); phalcon_array_fetch(&bind_type, data_types, position, PH_NOISY_CC); phalcon_array_append(&bind_data_types, bind_type, PH_SEPARATE TSRMLS_CC); } } } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: PHALCON_INIT_VAR(joined_values); phalcon_fast_join_str(joined_values, SL(", "), placeholders TSRMLS_CC); if (Z_TYPE_P(fields) == IS_ARRAY) { PHALCON_INIT_VAR(joined_fields); phalcon_fast_join_str(joined_fields, SL(", "), fields TSRMLS_CC); PHALCON_INIT_VAR(insert_sql); PHALCON_CONCAT_SVSVSVS(insert_sql, "INSERT INTO ", table, " (", joined_fields, ") VALUES (", joined_values, ")"); } else { PHALCON_INIT_NVAR(insert_sql); PHALCON_CONCAT_SVSVS(insert_sql, "INSERT INTO ", table, " VALUES (", joined_values, ")"); } PHALCON_INIT_VAR(success); PHALCON_CALL_METHOD_PARAMS_3(success, this_ptr, "execute", insert_sql, insert_values, bind_data_types, PH_NO_CHECK); RETURN_CCTOR(success); }
PHPAPI void php_var_dump(zval *struc, int level) /* {{{ */ { HashTable *myht; zend_string *class_name; int is_temp; int is_ref = 0; zend_ulong num; zend_string *key; zval *val; if (level > 1) { php_printf("%*c", level - 1, ' '); } again: switch (Z_TYPE_P(struc)) { case IS_FALSE: php_printf("%sbool(false)\n", COMMON); break; case IS_TRUE: php_printf("%sbool(true)\n", COMMON); break; case IS_NULL: php_printf("%sNULL\n", COMMON); break; case IS_LONG: php_printf("%sint(" ZEND_LONG_FMT ")\n", COMMON, Z_LVAL_P(struc)); break; case IS_DOUBLE: php_printf("%sfloat(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_P(struc)); break; case IS_STRING: php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_P(struc)); PHPWRITE(Z_STRVAL_P(struc), Z_STRLEN_P(struc)); PUTS("\"\n"); break; case IS_ARRAY: myht = Z_ARRVAL_P(struc); if (level > 1 && ZEND_HASH_APPLY_PROTECTION(myht) && ++myht->u.v.nApplyCount > 1) { PUTS("*RECURSION*\n"); --myht->u.v.nApplyCount; return; } php_printf("%sarray(%d) {\n", COMMON, zend_hash_num_elements(myht)); is_temp = 0; ZEND_HASH_FOREACH_KEY_VAL_IND(myht, num, key, val) { php_array_element_dump(val, num, key, level); } ZEND_HASH_FOREACH_END(); if (level > 1 && ZEND_HASH_APPLY_PROTECTION(myht)) { --myht->u.v.nApplyCount; } if (is_temp) { zend_hash_destroy(myht); efree(myht); } if (level > 1) { php_printf("%*c", level-1, ' '); } PUTS("}\n"); break; case IS_OBJECT: if (Z_OBJ_APPLY_COUNT_P(struc) > 0) { PUTS("*RECURSION*\n"); return; } Z_OBJ_INC_APPLY_COUNT_P(struc); myht = Z_OBJDEBUG_P(struc, is_temp); class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(Z_OBJ_P(struc)); php_printf("%sobject(%s)#%d (%d) {\n", COMMON, ZSTR_VAL(class_name), Z_OBJ_HANDLE_P(struc), myht ? zend_obj_num_elements(myht) : 0); zend_string_release(class_name); if (myht) { zend_ulong num; zend_string *key; zval *val; ZEND_HASH_FOREACH_KEY_VAL_IND(myht, num, key, val) { php_object_property_dump(val, num, key, level); } ZEND_HASH_FOREACH_END(); if (is_temp) { zend_hash_destroy(myht); efree(myht); } }
/** * Commits the internal transaction * */ PHP_METHOD(Phalcon_Logger_Adapter_File, commit){ zval *transaction, *file_handler, *quenue, *message = NULL; zval *message_str = NULL, *type = NULL, *time = NULL, *applied_format = NULL; zval *applied_eol = NULL; zval *t0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); PHALCON_INIT_VAR(transaction); phalcon_read_property(&transaction, this_ptr, SL("_transaction"), PH_NOISY_CC); if (!zend_is_true(transaction)) { PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "There is no active transaction"); return; } phalcon_update_property_bool(this_ptr, SL("_transaction"), 0 TSRMLS_CC); PHALCON_INIT_VAR(file_handler); phalcon_read_property(&file_handler, this_ptr, SL("_fileHandler"), PH_NOISY_CC); PHALCON_INIT_VAR(quenue); phalcon_read_property(&quenue, this_ptr, SL("_quenue"), PH_NOISY_CC); if (!phalcon_valid_foreach(quenue TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(quenue); zend_hash_internal_pointer_reset_ex(ah0, &hp0); 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(message); PHALCON_INIT_NVAR(message_str); PHALCON_CALL_METHOD(message_str, message, "getmessage", PH_NO_CHECK); PHALCON_INIT_NVAR(type); PHALCON_CALL_METHOD(type, message, "gettype", PH_NO_CHECK); PHALCON_INIT_NVAR(time); PHALCON_CALL_METHOD(time, message, "gettime", PH_NO_CHECK); PHALCON_INIT_NVAR(applied_format); PHALCON_CALL_METHOD_PARAMS_3(applied_format, this_ptr, "_applyformat", message_str, type, time, PH_NO_CHECK); PHALCON_INIT_NVAR(t0); zend_get_constant(SL("PHP_EOL"), t0 TSRMLS_CC); PHALCON_INIT_NVAR(applied_eol); PHALCON_CONCAT_VV(applied_eol, applied_format, t0); PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fwrite", file_handler, applied_eol); zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: if(0){} PHALCON_MM_RESTORE(); }
/** * Reads an item from an array using a zval as index */ int phalcon_array_fetch(zval **return_value, zval *arr, zval *index, int silent TSRMLS_DC){ zval **zv; int result = FAILURE, type; if (Z_TYPE_P(index) == IS_ARRAY || Z_TYPE_P(index) == IS_OBJECT) { ZVAL_NULL(*return_value); if (silent == PH_NOISY) { php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Illegal offset type"); } return FAILURE; } if (Z_TYPE_P(index) == IS_NULL) { convert_to_string(index); } ZVAL_NULL(*return_value); if (Z_TYPE_P(arr) == IS_NULL || Z_TYPE_P(arr) == IS_BOOL) { return FAILURE; } if (Z_TYPE_P(index) != IS_STRING && Z_TYPE_P(index) != IS_LONG && Z_TYPE_P(index) != IS_DOUBLE) { if (silent == PH_NOISY) { php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Illegal offset type"); } return FAILURE; } if (Z_TYPE_P(index) == IS_STRING) { if((type = is_numeric_string(Z_STRVAL_P(index), Z_STRLEN_P(index), NULL, NULL, 0))){ if (type == IS_LONG) { convert_to_long(index); } } } else { if (Z_TYPE_P(index) == IS_DOUBLE) { convert_to_long(index); } } if (Z_TYPE_P(index) == IS_STRING) { if((result = zend_hash_find(Z_ARRVAL_P(arr), Z_STRVAL_P(index), Z_STRLEN_P(index)+1, (void**) &zv)) == SUCCESS){ zval_ptr_dtor(return_value); *return_value = *zv; Z_ADDREF_PP(return_value); return SUCCESS; } } if (Z_TYPE_P(index) == IS_LONG) { if ((result = zend_hash_index_find(Z_ARRVAL_P(arr), Z_LVAL_P(index), (void**) &zv)) == SUCCESS) { zval_ptr_dtor(return_value); *return_value = *zv; Z_ADDREF_PP(return_value); return SUCCESS; } } if (silent == PH_NOISY) { if (Z_TYPE_P(index) == IS_LONG) { php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Undefined index: %ld", Z_LVAL_P(index)); } else { php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Undefined index: %s", Z_STRVAL_P(index)); } } return FAILURE; }
/** * Check if char index exists on an array zval */ int phalcon_array_isset_long(const zval *arr, ulong index){ if(Z_TYPE_P(arr)!=IS_ARRAY){ return 0; } return zend_hash_index_exists(Z_ARRVAL_P(arr), index); }
/** * 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; }
/** * Unsets string index from array */ int phalcon_array_unset_string(zval *arr, char *index, uint index_length){ if (Z_TYPE_P(arr) != IS_ARRAY) { return 0; } return zend_hash_del(Z_ARRVAL_P(arr), index, index_length); }
/** * Process a request header and return an array of values with their qualities * * @param string $serverIndex * @param string $name * @return array */ PHP_METHOD(Phalcon_Http_Request, _getQualityHeader){ zval *server_index = NULL, *name = NULL, *quality_one = NULL, *returned_parts = NULL; zval *http_server = NULL, *pattern = NULL, *parts = NULL, *part = NULL, *header_parts = NULL; zval *quality_part = NULL, *quality = NULL, *header_name = NULL; zval *c0 = NULL, *c1 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &server_index, &name) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(quality_one); ZVAL_DOUBLE(quality_one, 1); PHALCON_INIT_VAR(returned_parts); array_init(returned_parts); PHALCON_INIT_VAR(http_server); PHALCON_CALL_METHOD_PARAMS_1(http_server, this_ptr, "getserver", server_index, PH_NO_CHECK); PHALCON_INIT_VAR(pattern); ZVAL_STRING(pattern, "/,\\s*/", 1); PHALCON_INIT_VAR(parts); PHALCON_CALL_FUNC_PARAMS_2(parts, "preg_split", pattern, http_server); if (!phalcon_valid_foreach(parts TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(parts); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_ac06_2: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_ac06_2; } PHALCON_INIT_VAR(part); ZVAL_ZVAL(part, *hd, 1, 0); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, ";", 1); PHALCON_INIT_VAR(header_parts); phalcon_fast_explode(header_parts, c0, part TSRMLS_CC); eval_int = phalcon_array_isset_long(header_parts, 1); if (eval_int) { PHALCON_INIT_VAR(quality_part); phalcon_array_fetch_long(&quality_part, header_parts, 1, PH_NOISY_CC); PHALCON_INIT_VAR(c1); ZVAL_LONG(c1, 2); PHALCON_INIT_VAR(quality); PHALCON_CALL_FUNC_PARAMS_2(quality, "substr", quality_part, c1); } else { PHALCON_CPY_WRT(quality, quality_one); } PHALCON_INIT_VAR(header_name); phalcon_array_fetch_long(&header_name, header_parts, 0, PH_NOISY_CC); PHALCON_INIT_VAR(quality_part); array_init(quality_part); phalcon_array_update_zval(&quality_part, name, &header_name, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&quality_part, SL("quality"), &quality, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_append(&returned_parts, quality_part, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_ac06_2; fee_ac06_2: RETURN_CTOR(returned_parts); }
/** * Process a request header and return the one with best quality * * @param array $qualityParts * @param string $name * @return string */ PHP_METHOD(Phalcon_Http_Request, _getBestQuality){ zval *quality_parts = NULL, *name = NULL, *i = NULL, *quality = NULL, *selected_name = NULL; zval *accept = NULL, *accept_quality = NULL; zval *r0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &quality_parts, &name) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(i); ZVAL_LONG(i, 0); PHALCON_INIT_VAR(quality); ZVAL_LONG(quality, 0); PHALCON_INIT_VAR(selected_name); ZVAL_STRING(selected_name, "", 1); if (!phalcon_valid_foreach(quality_parts TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(quality_parts); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_ac06_3: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_ac06_3; } PHALCON_INIT_VAR(accept); ZVAL_ZVAL(accept, *hd, 1, 0); if (phalcon_compare_strict_long(i, 0 TSRMLS_CC)) { PHALCON_INIT_VAR(quality); phalcon_array_fetch_string(&quality, accept, SL("quality"), PH_NOISY_CC); PHALCON_INIT_VAR(selected_name); phalcon_array_fetch(&selected_name, accept, name, PH_NOISY_CC); } else { PHALCON_INIT_VAR(accept_quality); phalcon_array_fetch_string(&accept_quality, accept, SL("quality"), PH_NOISY_CC); PHALCON_INIT_VAR(r0); is_smaller_function(r0, quality, accept_quality TSRMLS_CC); if (zend_is_true(r0)) { PHALCON_CPY_WRT(quality, accept_quality); PHALCON_INIT_VAR(selected_name); phalcon_array_fetch(&selected_name, accept, name, PH_NOISY_CC); } } PHALCON_SEPARATE(i); increment_function(i); zend_hash_move_forward_ex(ah0, &hp0); goto fes_ac06_3; fee_ac06_3: RETURN_CCTOR(selected_name); }
PHP_METHOD(Phalcon_Tag_Select, select){ zval *parameters = NULL, *data = NULL, *params = NULL, *eol = NULL, *id = NULL, *value = NULL, *dummy_value = NULL; zval *dummy_text = NULL, *code = NULL, *avalue = NULL, *key = NULL, *close_option = NULL; zval *options = NULL, *using = NULL; zval *a0 = NULL; zval *t0 = NULL, *t1 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL; zval *p1[] = { NULL, NULL, NULL, NULL }; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", ¶meters, &data) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!data) { PHALCON_INIT_VAR(data); ZVAL_NULL(data); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(a0); array_init(a0); phalcon_array_append(&a0, parameters, PHALCON_SEPARATE_PLZ TSRMLS_CC); phalcon_array_append(&a0, data, PHALCON_SEPARATE_PLZ TSRMLS_CC); PHALCON_CPY_WRT(params, a0); } else { PHALCON_CPY_WRT(params, parameters); } PHALCON_ALLOC_ZVAL_MM(t0); zend_get_constant("PHP_EOL", strlen("PHP_EOL"), t0 TSRMLS_CC); PHALCON_CPY_WRT(eol, t0); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_long(&r0, params, 0, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(id, r0); eval_int = phalcon_array_isset_string(params, "value", strlen("value")+1); if (!eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_STATIC_PARAMS_1(r1, "phalcon_tag", "getvalue", id); PHALCON_CPY_WRT(value, r1); } else { PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_string(&r2, params, "value", strlen("value"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(value, r2); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, "value", strlen("value")+1); } eval_int = phalcon_array_isset_string(params, "dummyValue", strlen("dummyValue")+1); if (!eval_int) { PHALCON_INIT_VAR(dummy_value); ZVAL_STRING(dummy_value, "", 1); } else { PHALCON_ALLOC_ZVAL_MM(r3); phalcon_array_fetch_string(&r3, params, "dummyValue", strlen("dummyValue"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(dummy_value, r3); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, "dummyValue", strlen("dummyValue")+1); } eval_int = phalcon_array_isset_string(params, "dummyText", strlen("dummyText")+1); if (!eval_int) { PHALCON_INIT_VAR(dummy_text); ZVAL_STRING(dummy_text, "Choose...", 1); } else { PHALCON_ALLOC_ZVAL_MM(r4); phalcon_array_fetch_string(&r4, params, "dummyText", strlen("dummyText"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(dummy_text, r4); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, "dummyText", strlen("dummyText")+1); } PHALCON_ALLOC_ZVAL_MM(r5); PHALCON_CONCAT_SVSVS(r5, "<select id=\"", id, "\" name=\"", id, "\""); PHALCON_CPY_WRT(code, r5); if (Z_TYPE_P(params) == IS_ARRAY) { if (phalcon_valid_foreach(params TSRMLS_CC)) { ah0 = Z_ARRVAL_P(params); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_9c31_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_9c31_0; } else { PHALCON_INIT_VAR(key); PHALCON_GET_FOREACH_KEY(key, ah0, hp0); } PHALCON_INIT_VAR(avalue); ZVAL_ZVAL(avalue, *hd, 1, 0); if (Z_TYPE_P(key) != IS_LONG) { if (Z_TYPE_P(avalue) != IS_ARRAY) { PHALCON_INIT_VAR(r6); PHALCON_CONCAT_SVSVS(r6, " ", key, "=\"", avalue, "\""); phalcon_concat_self(&code, r6 TSRMLS_CC); } } zend_hash_move_forward_ex(ah0, &hp0); goto fes_9c31_0; fee_9c31_0: if(0){} } else { return; } } PHALCON_ALLOC_ZVAL_MM(r7); PHALCON_CONCAT_SV(r7, ">", eol); phalcon_concat_self(&code, r7 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r8); PHALCON_CONCAT_SV(r8, "</option>", eol); PHALCON_CPY_WRT(close_option, r8); eval_int = phalcon_array_isset_string(params, "useDummy", strlen("useDummy")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r9); PHALCON_CONCAT_SVSVV(r9, "\t<option value=\"", dummy_value, "\">", dummy_text, close_option); phalcon_concat_self(&code, r9 TSRMLS_CC); } eval_int = phalcon_array_isset_long(params, 1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r10); phalcon_array_fetch_long(&r10, params, 1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(options, r10); } else { PHALCON_CPY_WRT(options, data); } if (Z_TYPE_P(options) == IS_OBJECT) { eval_int = phalcon_array_isset_string(params, "using", strlen("using")+1); if (!eval_int) { PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter is required"); return; } else { PHALCON_ALLOC_ZVAL_MM(r11); phalcon_array_fetch_string(&r11, params, "using", strlen("using"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(using, r11); if (Z_TYPE_P(using) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter should be an Array"); return; } } PHALCON_ALLOC_ZVAL_MM(r12); p1[0] = options; p1[1] = using; p1[2] = value; p1[3] = close_option; PHALCON_CALL_SELF_PARAMS(r12, this_ptr, "_optionsfromresultset", 4, p1); phalcon_concat_self(&code, r12 TSRMLS_CC); } else {
/** {{{ public ZeActiveString::toString($separator) */ PHP_METHOD(ze_activestring, toString) { zval * self = NULL; zval * items = NULL; zval * actives = NULL; char * sep = NULL; int sep_len = 0; smart_str sstr = {NULL, 0, 0}; HashTable * items_table = NULL; HashPosition items_pointer = NULL; HashTable * actives_table = NULL; char * key = NULL; uint key_len = 0; ulong idx = 0; zval ** val = NULL; char * str = NULL; int str_len = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s" , &sep, &sep_len ) == FAILURE) { WRONG_PARAM_COUNT; } self = getThis(); items = zend_read_property(ze_activestring_ce, self, ZEND_STRL(ZE_ITEMS) , 0 TSRMLS_CC); actives = zend_read_property(ze_activestring_ce, self, ZEND_STRL(ZE_ACTIVES), 0 TSRMLS_CC); do { if (!items || Z_TYPE_P(items) != IS_ARRAY) { ZE_PTR_DTOR(items); ze_error(E_ERROR TSRMLS_CC, "recorder.toString.items.not_array"); break; } if (!actives || Z_TYPE_P(actives) != IS_ARRAY) { ZE_PTR_DTOR(actives); ze_error(E_ERROR TSRMLS_CC, "recorder.toString.actives.not_array"); break; } items_table = Z_ARRVAL_P(items); actives_table = Z_ARRVAL_P(actives); for (zend_hash_internal_pointer_reset_ex(items_table, &items_pointer); zend_hash_get_current_key_ex(items_table, &key, &key_len, &idx, 0, &items_pointer) == HASH_KEY_IS_STRING; zend_hash_move_forward_ex(items_table, &items_pointer)) { if (!key || !key_len) { continue; } if (zend_hash_exists(actives_table, key, key_len )) { if (zend_hash_get_current_data_ex(items_table , (void**) &val, &items_pointer) == SUCCESS) { smart_str_appendl(&sstr, Z_STRVAL_PP(val), Z_STRLEN_PP(val)); if (sep_len) { smart_str_appendl(&sstr, sep, sep_len); } } } } smart_str_0(&sstr); } while(0); if (sstr.len) { str_len = sstr.len - sep_len; spprintf(&str, str_len, "%s", sstr.c); smart_str_free(&sstr); RETURN_STRING(str , 0); }else{ smart_str_free(&sstr); RETURN_EMPTY_STRING(); } }
void cpServer_init(zval *conf, char *ini_file) { size_t group_num = 0; cpShareMemory shm = {0}; shm.size = sizeof (cpServerGS); strncpy(shm.mmap_name, CP_SERVER_MMAP_FILE, strlen(CP_SERVER_MMAP_FILE)); if (cp_create_mmap_file(&shm) == 0) { CPGS = (cpServerGS*) cp_mmap_calloc_with_file(&shm); cpKillClient(); bzero(CPGS, shm.size); if (CPGS == NULL) { php_printf("calloc[1] fail\n"); return; } } else { php_printf("calloc[1] fail\n"); return; } bzero(&CPGL, sizeof (cpServerG)); CPGC.backlog = CP_BACKLOG; // CPGC.reactor_num = CP_CPU_NUM; CPGC.reactor_num = 1; CPGC.timeout_sec = CP_REACTOR_TIMEO_SEC; CPGC.timeout_usec = CP_REACTOR_TIMEO_USEC; CPGC.max_conn = CP_MAX_FDS; CPGC.max_request = CP_MAX_REQUEST; CPGC.idel_time = CP_IDEL_TIME; CPGC.recycle_num = CP_RECYCLE_NUM; CPGC.max_read_len = CP_DEF_MAX_READ_LEN; CPGC.ser_fail_hits = 1; CPGC.max_fail_num = 2; strcpy(CPGC.ini_file, ini_file); // MAKE_STD_ZVAL(CPGS->group); // array_init(CPGS->group); for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(conf)); zend_hash_has_more_elements(Z_ARRVAL_P(conf)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(conf))) { zval **config; zend_hash_get_current_data(Z_ARRVAL_P(conf), (void**) &config); char *name; uint keylen; zend_hash_get_current_key_ex(Z_ARRVAL_P(conf), &name, &keylen, NULL, 0, NULL); if (strcmp(name, "common") == 0) {//common config cpServer_init_common(*config); } else { zval **v; strcpy(CPGS->G[group_num].name, name); if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("pool_min"), (void **) &v) == SUCCESS) { convert_to_long(*v); CPGS->G[group_num].worker_num = CPGS->G[group_num].worker_min = Z_LVAL_PP(v); } if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("pool_max"), (void **) &v) == SUCCESS) { convert_to_long(*v); CPGS->G[group_num].worker_max = Z_LVAL_PP(v); } CPGS->max_buffer_len = CPGC.max_read_len; pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); if (pthread_mutex_init(&CPGS->G[group_num].mutex_lock, &attr) < 0) { cpLog("pthread_mutex_init error!. Error: %s [%d]", strerror(errno), errno); return; } CPGS->G[group_num].lock = cpMutexLock; CPGS->G[group_num].unLock = cpMutexUnLock; CPGS->G[group_num].tryLock = cpMutexTryLock; // CPGS->G[group_num].WaitList = CPGS->G[group_num].WaitTail = NULL; CPGS->group_num++; group_num++; } } }
/** {{{ zend_string * yaf_route_map_assemble(zval *info, zval *query) */ zend_string * yaf_route_map_assemble(yaf_route_t *this_ptr, zval *info, zval *query) { char *seg, *ptrptr, *pname; smart_str uri = {0}; size_t seg_len; zend_bool has_delim = 0; zval *delim, *ctl_prefer, *zv; ctl_prefer = zend_read_property(yaf_route_map_ce, this_ptr, ZEND_STRL(YAF_ROUTE_MAP_VAR_NAME_CTL_PREFER), 1, NULL); delim = zend_read_property(yaf_route_map_ce, this_ptr, ZEND_STRL(YAF_ROUTE_MAP_VAR_NAME_DELIMETER), 1, NULL); if (IS_STRING == Z_TYPE_P(delim) && Z_STRLEN_P(delim)) { has_delim = 1; } do { if (Z_TYPE_P(ctl_prefer) == IS_TRUE) { if ((zv = zend_hash_str_find(Z_ARRVAL_P(info), ZEND_STRL(YAF_ROUTE_ASSEMBLE_ACTION_FORMAT))) != NULL && Z_TYPE_P(zv) == IS_STRING) { pname = estrndup(Z_STRVAL_P(zv), Z_STRLEN_P(zv)); } else { yaf_trigger_error(YAF_ERR_TYPE_ERROR, "%s", "Undefined the 'action' parameter for the 1st parameter"); break; } } else { if ((zv = zend_hash_str_find(Z_ARRVAL_P(info), ZEND_STRL(YAF_ROUTE_ASSEMBLE_CONTROLLER_FORMAT))) != NULL && Z_TYPE_P(zv) == IS_STRING) { pname = estrndup(Z_STRVAL_P(zv), Z_STRLEN_P(zv)); } else { yaf_trigger_error(YAF_ERR_TYPE_ERROR, "%s", "Undefined the 'controller' parameter for the 1st parameter"); break; } } seg = php_strtok_r(pname, "_", &ptrptr); while (seg) { seg_len = strlen(seg); if (seg_len) { smart_str_appendc(&uri, '/'); smart_str_appendl(&uri, seg, seg_len); } seg = php_strtok_r(NULL, "_", &ptrptr); } efree(pname); if (query && IS_ARRAY == Z_TYPE_P(query)) { zend_bool start = 1; zend_string *key, *val; if (has_delim) { smart_str_appendc(&uri, '/'); smart_str_appendl(&uri, Z_STRVAL_P(delim), Z_STRLEN_P(delim)); } ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(query), key, zv) { if (key) { val = zval_get_string(zv); if (has_delim) { smart_str_appendc(&uri, '/'); smart_str_appendl(&uri, ZSTR_VAL(key), ZSTR_LEN(key)); smart_str_appendc(&uri, '/'); smart_str_appendl(&uri, ZSTR_VAL(val), ZSTR_LEN(val)); } else { if (start) { smart_str_appendc(&uri, '?'); smart_str_appendl(&uri, ZSTR_VAL(key), ZSTR_LEN(key)); smart_str_appendc(&uri, '='); smart_str_appendl(&uri, ZSTR_VAL(val), ZSTR_LEN(val)); start = 0; } else { smart_str_appendc(&uri, '&'); smart_str_appendl(&uri, ZSTR_VAL(key), ZSTR_LEN(key)); smart_str_appendc(&uri, '='); smart_str_appendl(&uri, ZSTR_VAL(val), ZSTR_LEN(val)); } } zend_string_release(val); } } ZEND_HASH_FOREACH_END(); } smart_str_0(&uri); return uri.s; } while (0);
/** * Updates data on a table using custom RBDM SQL syntax * * <code> * //Updating existing robot * $success = $connection->update( * "robots", * array("name") * array("New Astro Boy"), * "id = 101" * ); * * //Next SQL sentence is sent to the database system * UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101 * </code> * * @param string $table * @param array $fields * @param array $values * @param string $whereCondition * @param array $dataTypes * @return boolean */ PHP_METHOD(Phalcon_Db, update){ zval *table, *fields, *values, *where_condition = NULL; zval *data_types = NULL, *placeholders, *update_values; zval *bind_data_types = NULL, *value = NULL, *position = NULL, *field = NULL; zval *set_clause_part = NULL, *bind_type = NULL, *set_clause; zval *update_sql = NULL, *success; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|zz", &table, &fields, &values, &where_condition, &data_types) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!where_condition) { PHALCON_INIT_NVAR(where_condition); } if (!data_types) { PHALCON_INIT_NVAR(data_types); } PHALCON_INIT_VAR(placeholders); array_init(placeholders); PHALCON_INIT_VAR(update_values); array_init(update_values); if (Z_TYPE_P(data_types) == IS_ARRAY) { PHALCON_INIT_VAR(bind_data_types); array_init(bind_data_types); } else { PHALCON_CPY_WRT(bind_data_types, data_types); } if (!phalcon_valid_foreach(values TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(values); 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_KEY(position, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); eval_int = phalcon_array_isset(fields, position); if (eval_int) { PHALCON_INIT_NVAR(field); phalcon_array_fetch(&field, fields, position, PH_NOISY_CC); if (Z_TYPE_P(value) == IS_OBJECT) { PHALCON_INIT_NVAR(set_clause_part); PHALCON_CONCAT_VSV(set_clause_part, field, " = ", value); phalcon_array_append(&placeholders, set_clause_part, PH_SEPARATE TSRMLS_CC); } else { if (Z_TYPE_P(value) == IS_NULL) { PHALCON_INIT_NVAR(set_clause_part); PHALCON_CONCAT_VS(set_clause_part, field, " = null"); } else { PHALCON_INIT_NVAR(set_clause_part); PHALCON_CONCAT_VS(set_clause_part, field, " = ?"); phalcon_array_append(&update_values, value, PH_SEPARATE TSRMLS_CC); if (Z_TYPE_P(data_types) == IS_ARRAY) { eval_int = phalcon_array_isset(data_types, position); if (!eval_int) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Incomplete number of bind types"); return; } PHALCON_INIT_NVAR(bind_type); phalcon_array_fetch(&bind_type, data_types, position, PH_NOISY_CC); phalcon_array_append(&bind_data_types, bind_type, PH_SEPARATE TSRMLS_CC); } } phalcon_array_append(&placeholders, set_clause_part, PH_SEPARATE TSRMLS_CC); } } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The number of values in the update is not the same as fields"); return; } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: PHALCON_INIT_VAR(set_clause); phalcon_fast_join_str(set_clause, SL(", "), placeholders TSRMLS_CC); if (Z_TYPE_P(where_condition) != IS_NULL) { PHALCON_INIT_VAR(update_sql); PHALCON_CONCAT_SVSVSV(update_sql, "UPDATE ", table, " SET ", set_clause, " WHERE ", where_condition); } else { PHALCON_INIT_NVAR(update_sql); PHALCON_CONCAT_SVSV(update_sql, "UPDATE ", table, " SET ", set_clause); } PHALCON_INIT_VAR(success); PHALCON_CALL_METHOD_PARAMS_3(success, this_ptr, "execute", update_sql, update_values, bind_data_types, PH_NO_CHECK); RETURN_CCTOR(success); }
static int php_mongo_command_supports_rp(zval *cmd) { HashPosition pos; char *str; uint str_len; long type; ulong idx; if (!cmd || Z_TYPE_P(cmd) != IS_ARRAY) { return 0; } zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(cmd), &pos); type = zend_hash_get_current_key_ex(Z_ARRVAL_P(cmd), &str, &str_len, &idx, 0, &pos); if (type != HASH_KEY_IS_STRING) { return 0; } /* Commands in MongoDB are case-sensitive */ if (str_len == 6) { if (strcmp(str, "count") == 0 || strcmp(str, "group") == 0) { return 1; } return 0; } if (str_len == 8) { if (strcmp(str, "dbStats") == 0 || strcmp(str, "geoNear") == 0 || strcmp(str, "geoWalk") == 0) { return 1; } return 0; } if (str_len == 9) { if (strcmp(str, "distinct") == 0) { return 1; } return 0; } if (str_len == 10) { if (strcmp(str, "aggregate") == 0 || strcmp(str, "collStats") == 0 || strcmp(str, "geoSearch") == 0) { return 1; } if (strcmp(str, "mapreduce") == 0 || strcmp(str, "mapReduce") == 0) { zval **value = NULL; if (zend_hash_find(Z_ARRVAL_P(cmd), "out", 4, (void **)&value) == SUCCESS) { if (Z_TYPE_PP(value) == IS_ARRAY) { if (zend_hash_exists(Z_ARRVAL_PP(value), "inline", 7)) { return 1; } } } } return 0; } if (str_len == 23) { if (strcmp(str, "parallelCollectionScan") == 0) { return 1; } return 0; } return 0; }
/* {{{ MongoCursor->__construct */ PHP_METHOD(MongoCursor, __construct) { zval *zlink = 0, *zns = 0, *zquery = 0, *zfields = 0, *empty, *timeout; zval **data; mongo_cursor *cursor; mongo_link *link; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Oz|zz", &zlink, mongo_ce_Mongo, &zns, &zquery, &zfields) == FAILURE) { return; } if ((zquery && IS_SCALAR_P(zquery)) || (zfields && IS_SCALAR_P(zfields))) { zend_error(E_WARNING, "MongoCursor::__construct() expects parameters 3 and 4 to be arrays or objects"); return; } // if query or fields weren't passed, make them default to an empty array MAKE_STD_ZVAL(empty); object_init(empty); // these are both initialized to the same zval, but that's okay because // there's no way to change them without creating a new cursor if (!zquery || (Z_TYPE_P(zquery) == IS_ARRAY && zend_hash_num_elements(HASH_P(zquery)) == 0)) { zquery = empty; } if (!zfields) { zfields = empty; } cursor = (mongo_cursor*)zend_object_store_get_object(getThis() TSRMLS_CC); // db connection cursor->resource = zlink; zval_add_ref(&zlink); // db connection resource PHP_MONGO_GET_LINK(zlink); cursor->link = link; // change ['x', 'y', 'z'] into {'x' : 1, 'y' : 1, 'z' : 1} if (Z_TYPE_P(zfields) == IS_ARRAY) { HashPosition pointer; zval *fields; MAKE_STD_ZVAL(fields); array_init(fields); // fields to return for(zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(zfields), &pointer); zend_hash_get_current_data_ex(Z_ARRVAL_P(zfields), (void**) &data, &pointer) == SUCCESS; zend_hash_move_forward_ex(Z_ARRVAL_P(zfields), &pointer)) { int key_type, key_len; ulong index; char *key; key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(zfields), &key, (uint*)&key_len, &index, NO_DUP, &pointer); if (key_type == HASH_KEY_IS_LONG) { if (Z_TYPE_PP(data) == IS_STRING) { add_assoc_long(fields, Z_STRVAL_PP(data), 1); } else { zval_ptr_dtor(&empty); zval_ptr_dtor(&fields); zend_throw_exception(mongo_ce_Exception, "field names must be strings", 0 TSRMLS_CC); return; } } else { add_assoc_zval(fields, key, *data); zval_add_ref(data); } } cursor->fields = fields; } // if it's already an object, we don't have to worry else { cursor->fields = zfields; zval_add_ref(&zfields); } // ns convert_to_string(zns); cursor->ns = estrdup(Z_STRVAL_P(zns)); // query cursor->query = zquery; zval_add_ref(&zquery); // reset iteration pointer, just in case MONGO_METHOD(MongoCursor, reset, return_value, getThis()); cursor->at = 0; cursor->num = 0; cursor->special = 0; cursor->persist = 0; timeout = zend_read_static_property(mongo_ce_Cursor, "timeout", strlen("timeout"), NOISY TSRMLS_CC); cursor->timeout = Z_LVAL_P(timeout); cursor->opts = link->slave_okay ? (1 << 2) : 0; // get rid of extra ref zval_ptr_dtor(&empty); }
static void from_zval_write_sockaddr_aux(const zval *container, struct sockaddr **sockaddr_ptr, socklen_t *sockaddr_len, ser_context *ctx) { int family; zval *elem; int fill_sockaddr; if (Z_TYPE_P(container) != IS_ARRAY) { do_from_zval_err(ctx, "%s", "expected an array here"); return; } fill_sockaddr = param_get_bool(ctx, KEY_FILL_SOCKADDR, 1); if ((elem = zend_hash_str_find(Z_ARRVAL_P(container), "family", sizeof("family") - 1)) != NULL && Z_TYPE_P(elem) != IS_NULL) { const char *node = "family"; zend_llist_add_element(&ctx->keys, &node); from_zval_write_int(elem, (char*)&family, ctx); zend_llist_remove_tail(&ctx->keys); } else { family = ctx->sock->type; } switch (family) { case AF_INET: /* though not all OSes support sockaddr_in used in IPv6 sockets */ if (ctx->sock->type != AF_INET && ctx->sock->type != AF_INET6) { do_from_zval_err(ctx, "the specified family (number %d) is not " "supported on this socket", family); return; } *sockaddr_ptr = accounted_ecalloc(1, sizeof(struct sockaddr_in), ctx); *sockaddr_len = sizeof(struct sockaddr_in); if (fill_sockaddr) { from_zval_write_sockaddr_in(container, (char*)*sockaddr_ptr, ctx); (*sockaddr_ptr)->sa_family = AF_INET; } break; #if HAVE_IPV6 case AF_INET6: if (ctx->sock->type != AF_INET6) { do_from_zval_err(ctx, "the specified family (AF_INET6) is not " "supported on this socket"); return; } *sockaddr_ptr = accounted_ecalloc(1, sizeof(struct sockaddr_in6), ctx); *sockaddr_len = sizeof(struct sockaddr_in6); if (fill_sockaddr) { from_zval_write_sockaddr_in6(container, (char*)*sockaddr_ptr, ctx); (*sockaddr_ptr)->sa_family = AF_INET6; } break; #endif /* HAVE_IPV6 */ case AF_UNIX: if (ctx->sock->type != AF_UNIX) { do_from_zval_err(ctx, "the specified family (AF_UNIX) is not " "supported on this socket"); return; } *sockaddr_ptr = accounted_ecalloc(1, sizeof(struct sockaddr_un), ctx); if (fill_sockaddr) { struct sockaddr_un *sock_un = (struct sockaddr_un*)*sockaddr_ptr; from_zval_write_sockaddr_un(container, (char*)*sockaddr_ptr, ctx); (*sockaddr_ptr)->sa_family = AF_UNIX; /* calculating length is more complicated here. Giving the size of * struct sockaddr_un here and relying on the nul termination of * sun_path does not work for paths in the abstract namespace. Note * that we always assume the path is not empty and nul terminated */ *sockaddr_len = offsetof(struct sockaddr_un, sun_path) + (sock_un->sun_path[0] == '\0' ? (1 + strlen(&sock_un->sun_path[1])) : strlen(sock_un->sun_path)); } else { *sockaddr_len = sizeof(struct sockaddr_un); } break; default: do_from_zval_err(ctx, "%s", "the only families currently supported are " "AF_INET, AF_INET6 and AF_UNIX"); break; }
unsigned char type_check(zval *val) { long l; double d; HashTable *ht; switch (Z_TYPE_P(val)) { case IS_LONG: l = Z_LVAL_P(val); return integer_type_check(l); break; case IS_DOUBLE: d = Z_DVAL_P(val); return fp_type_check(d); break; case IS_NULL: return LEON_NULL; break; #if PHP_API_VERSION <= 20131106 case IS_BOOL: return (Z_LVAL_P(val) ? LEON_TRUE : LEON_FALSE); break; #else case IS_FALSE: return LEON_FALSE; break; case IS_TRUE: return LEON_TRUE; break; #endif case IS_STRING: return LEON_STRING; break; #if PHP_API_VERSION > 20131106 case IS_REFERENCE: val = Z_REFVAL_P(val); return type_check(val); break; #endif case IS_OBJECT: if (instanceof_function(Z_OBJCE_P(val), undefined_ce)) return LEON_UNDEFINED; else if (instanceof_function(Z_OBJCE_P(val), date_ce)) return LEON_DATE; else if (instanceof_function(Z_OBJCE_P(val), nan_ce)) return LEON_NAN; else if (instanceof_function(Z_OBJCE_P(val), infinity_ce)) return LEON_INFINITY; else if (instanceof_function(Z_OBJCE_P(val), minus_infinity_ce)) return LEON_MINUS_INFINITY; else if (instanceof_function(Z_OBJCE_P(val), string_buffer_ce)) return LEON_BUFFER; else if (instanceof_function(Z_OBJCE_P(val), regexp_ce)) return LEON_REGEXP; return LEON_NATIVE_OBJECT; break; case IS_ARRAY: ht = Z_ARRVAL_P(val); return determine_array_type(ht); break; #if PHP_API_VERSION > 20131106 case IS_INDIRECT: return LEON_INDIRECT; #endif case IS_CONSTANT: case IS_CONSTANT_AST: return LEON_CONSTANT; default: php_error_docref(NULL, E_WARNING, "Unsupported type."); break; } }
/** * Updates data on a table using custom RBDM SQL syntax * * @param string $table * @param array $fields * @param array $values * @param string $whereCondition * @return boolean */ PHP_METHOD(Phalcon_Db, update){ zval *table = NULL, *fields = NULL, *values = NULL, *where_condition = NULL; zval *placeholders = NULL, *value = NULL, *n = NULL, *field = NULL, *set_clause_part = NULL; zval *set_clause = NULL, *update_sql = NULL, *success = NULL; zval *c0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &table, &fields, &values, &where_condition) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_SEPARATE_PARAM(values); if (!where_condition) { PHALCON_ALLOC_ZVAL_MM(where_condition); ZVAL_NULL(where_condition); } 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_2: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_e7f0_2; } PHALCON_INIT_VAR(n); PHALCON_GET_FOREACH_KEY(n, ah0, hp0); PHALCON_INIT_VAR(value); ZVAL_ZVAL(value, *hd, 1, 0); eval_int = phalcon_array_isset(fields, n); if (eval_int) { PHALCON_INIT_VAR(field); phalcon_array_fetch(&field, fields, n, PH_NOISY_CC); if (Z_TYPE_P(value) == IS_OBJECT) { PHALCON_INIT_VAR(set_clause_part); PHALCON_CONCAT_VSV(set_clause_part, field, " = ", value); phalcon_array_append(&placeholders, set_clause_part, PH_SEPARATE TSRMLS_CC); PHALCON_SEPARATE_PARAM(values); phalcon_array_unset(values, n); } else { if (Z_TYPE_P(value) == IS_NULL) { PHALCON_INIT_VAR(set_clause_part); PHALCON_CONCAT_VS(set_clause_part, field, " = null"); PHALCON_SEPARATE_PARAM(values); phalcon_array_unset(values, n); } else { PHALCON_INIT_VAR(set_clause_part); PHALCON_CONCAT_VS(set_clause_part, field, " = ?"); } phalcon_array_append(&placeholders, set_clause_part, PH_SEPARATE TSRMLS_CC); } } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The number of values in the update is not the same as fields"); return; } zend_hash_move_forward_ex(ah0, &hp0); goto fes_e7f0_2; fee_e7f0_2: zend_hash_destroy(ah0); efree(ah0); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, ", ", 1); PHALCON_INIT_VAR(set_clause); phalcon_fast_join(set_clause, c0, placeholders TSRMLS_CC); if (Z_TYPE_P(where_condition) != IS_NULL) { PHALCON_INIT_VAR(update_sql); PHALCON_CONCAT_SVSVSV(update_sql, "UPDATE ", table, " SET ", set_clause, " WHERE ", where_condition); } else { PHALCON_INIT_VAR(update_sql); PHALCON_CONCAT_SVSV(update_sql, "UPDATE ", table, " SET ", set_clause); } PHALCON_INIT_VAR(success); PHALCON_CALL_METHOD_PARAMS_2(success, this_ptr, "execute", update_sql, values, PH_NO_CHECK); RETURN_CCTOR(success); }
/** * Builds HTML IMG tags * * @param array $parameters * @return string */ PHP_METHOD(Phalcon_Tag, image){ zval *parameters = NULL, *params = NULL, *first_param, *url, *url_src; zval *src, *code, *value = NULL, *key = NULL, *doctype; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", ¶meters) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!parameters) { PHALCON_INIT_NVAR(parameters); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(params); array_init(params); phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC); } else { PHALCON_CPY_WRT(params, parameters); } eval_int = phalcon_array_isset_string(params, SS("src")); if (!eval_int) { eval_int = phalcon_array_isset_long(params, 0); if (eval_int) { PHALCON_INIT_VAR(first_param); phalcon_array_fetch_long(&first_param, params, 0, PH_NOISY_CC); phalcon_array_update_string(¶ms, SL("src"), &first_param, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string_string(¶ms, SL("src"), SL(""), PH_SEPARATE TSRMLS_CC); } } PHALCON_INIT_VAR(url); PHALCON_CALL_SELF(url, this_ptr, "geturlservice"); PHALCON_INIT_VAR(url_src); phalcon_array_fetch_string(&url_src, params, SL("src"), PH_NOISY_CC); PHALCON_INIT_VAR(src); PHALCON_CALL_METHOD_PARAMS_1(src, url, "get", url_src, PH_NO_CHECK); phalcon_array_update_string(¶ms, SL("src"), &src, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(code); ZVAL_STRING(code, "<img", 1); if (!phalcon_valid_foreach(params TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(params); 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_KEY(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (Z_TYPE_P(key) != IS_LONG) { PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", value, "\""); } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: PHALCON_INIT_VAR(doctype); PHALCON_CALL_SELF(doctype, this_ptr, "getdoctype"); if (phalcon_memnstr_str(doctype, SL("XHTML") TSRMLS_CC)) { phalcon_concat_self_str(code, SL(" />") TSRMLS_CC); } else { phalcon_concat_self_str(code, SL(">") TSRMLS_CC); } RETURN_CTOR(code); }
/** * Unsets long index from array */ int phalcon_array_unset_long(zval *arr, ulong index){ if (Z_TYPE_P(arr) != IS_ARRAY) { return 0; } return zend_hash_index_del(Z_ARRVAL_P(arr), index); }
/** * Builds a HTML A tag using framework conventions * *<code> * echo Phalcon\Tag::linkTo('signup/register', 'Register Here!'); *</code> * * @param array $parameters * @return string */ PHP_METHOD(Phalcon_Tag, linkTo){ zval *parameters, *text = NULL, *params = NULL, *action = NULL, *url, *internal_url; zval *code, *value = NULL, *key = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", ¶meters, &text) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!text) { PHALCON_INIT_NVAR(text); } else { PHALCON_SEPARATE_PARAM(text); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(params); array_init(params); phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC); phalcon_array_append(¶ms, text, PH_SEPARATE TSRMLS_CC); } else { PHALCON_CPY_WRT(params, parameters); } PHALCON_INIT_VAR(action); ZVAL_STRING(action, "", 1); eval_int = phalcon_array_isset_long(params, 0); if (eval_int) { PHALCON_INIT_NVAR(action); phalcon_array_fetch_long(&action, params, 0, PH_NOISY_CC); } else { eval_int = phalcon_array_isset_string(params, SS("action")); if (eval_int) { PHALCON_INIT_NVAR(action); phalcon_array_fetch_string(&action, params, SL("action"), PH_NOISY_CC); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, SS("action")); } } PHALCON_INIT_NVAR(text); ZVAL_STRING(text, "", 1); eval_int = phalcon_array_isset_long(params, 1); if (eval_int) { PHALCON_INIT_NVAR(text); phalcon_array_fetch_long(&text, params, 1, PH_NOISY_CC); } else { eval_int = phalcon_array_isset_string(params, SS("text")); if (eval_int) { PHALCON_INIT_NVAR(text); phalcon_array_fetch_string(&text, params, SL("text"), PH_NOISY_CC); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, SS("text")); } } PHALCON_INIT_VAR(url); PHALCON_CALL_SELF(url, this_ptr, "geturlservice"); PHALCON_INIT_VAR(internal_url); PHALCON_CALL_METHOD_PARAMS_1(internal_url, url, "get", action, PH_NO_CHECK); PHALCON_INIT_VAR(code); PHALCON_CONCAT_SVS(code, "<a href=\"", internal_url, "\""); if (!phalcon_valid_foreach(params TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(params); 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_KEY(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (Z_TYPE_P(key) != IS_LONG) { PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", value, "\""); } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: PHALCON_SCONCAT_SVS(code, ">", text, "</a>"); RETURN_CTOR(code); }
/** * Check if char index exists on an array zval */ int phalcon_array_isset_string(const zval *arr, char *index, uint index_length){ if (Z_TYPE_P(arr) != IS_ARRAY) { return 0; } return zend_hash_exists(Z_ARRVAL_P(arr), index, index_length); }
/** * Builds generic INPUT tags * * @param string $type * @param array $parameters * @param boolean $asValue * @return string */ PHP_METHOD(Phalcon_Tag, _inputField){ zval *type, *parameters, *as_value = NULL, *params = NULL, *value = NULL; zval *id = NULL, *name, *code, *key = NULL, *doctype; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &type, ¶meters, &as_value) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!as_value) { PHALCON_INIT_NVAR(as_value); ZVAL_BOOL(as_value, 0); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(params); array_init(params); phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC); } else { PHALCON_CPY_WRT(params, parameters); } PHALCON_INIT_VAR(value); if (PHALCON_IS_FALSE(as_value)) { eval_int = phalcon_array_isset_long(params, 0); if (!eval_int) { PHALCON_INIT_VAR(id); phalcon_array_fetch_string(&id, params, SL("id"), PH_NOISY_CC); phalcon_array_update_long(¶ms, 0, &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(id); phalcon_array_fetch_long(&id, params, 0, PH_NOISY_CC); eval_int = phalcon_array_isset_string(params, SS("name")); if (!eval_int) { phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(name); phalcon_array_fetch_string(&name, params, SL("name"), PH_NOISY_CC); if (!zend_is_true(name)) { phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } } eval_int = phalcon_array_isset_string(params, SS("id")); if (!eval_int) { phalcon_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(params, SS("value")); if (!eval_int) { PHALCON_CALL_SELF_PARAMS_1(value, this_ptr, "getvalue", id); phalcon_array_update_string(¶ms, SL("value"), &value, PH_COPY | PH_SEPARATE TSRMLS_CC); } } else { eval_int = phalcon_array_isset_long(params, 0); if (eval_int) { PHALCON_INIT_NVAR(value); phalcon_array_fetch_long(&value, params, 0, PH_NOISY_CC); phalcon_array_update_string(¶ms, SL("value"), &value, PH_COPY | PH_SEPARATE TSRMLS_CC); } } /** * Automatically check inputs */ if (PHALCON_COMPARE_STRING(type, "checkbox")) { if (zend_is_true(value)) { phalcon_array_update_string_string(¶ms, SL("checked"), SL("checked"), PH_SEPARATE TSRMLS_CC); } } PHALCON_INIT_VAR(code); PHALCON_CONCAT_SVS(code, "<input type=\"", type, "\""); if (!phalcon_valid_foreach(params TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(params); 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_KEY(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (Z_TYPE_P(key) != IS_LONG) { PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", value, "\""); } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: /** * Check if Doctype is XHTML */ PHALCON_INIT_VAR(doctype); PHALCON_CALL_SELF(doctype, this_ptr, "getdoctype"); if (phalcon_memnstr_str(doctype, SL("XHTML") TSRMLS_CC)) { phalcon_concat_self_str(code, SL(" />") TSRMLS_CC); } else { phalcon_concat_self_str(code, SL(">") TSRMLS_CC); } RETURN_CTOR(code); }
int php_openssl_get_x509_list_id(void); php_stream_ops php_openssl_socket_ops; /* it doesn't matter that we do some hash traversal here, since it is done only * in an error condition arising from a network connection problem */ static int is_http_stream_talking_to_iis(php_stream *stream TSRMLS_DC) { if (stream->wrapperdata && stream->wrapper && strcasecmp(stream->wrapper->wops->label, "HTTP") == 0) { /* the wrapperdata is an array zval containing the headers */ zval **tmp; #define SERVER_MICROSOFT_IIS "Server: Microsoft-IIS" #define SERVER_GOOGLE "Server: GFE/" zend_hash_internal_pointer_reset(Z_ARRVAL_P(stream->wrapperdata)); while (SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(stream->wrapperdata), (void**)&tmp)) { if (strncasecmp(Z_STRVAL_PP(tmp), SERVER_MICROSOFT_IIS, sizeof(SERVER_MICROSOFT_IIS)-1) == 0) { return 1; } else if (strncasecmp(Z_STRVAL_PP(tmp), SERVER_GOOGLE, sizeof(SERVER_GOOGLE)-1) == 0) { return 1; } zend_hash_move_forward(Z_ARRVAL_P(stream->wrapperdata)); } } return 0; } static int handle_ssl_error(php_stream *stream, int nr_bytes, zend_bool is_init TSRMLS_DC)
/** * Builds a HTML TEXTAREA tag * *<code> * echo Phalcon\Tag::textArea(array("comments", "cols" => 10, "rows" => 4)) *</code> * * @param array $parameters * @return string */ PHP_METHOD(Phalcon_Tag, textArea){ zval *parameters, *params = NULL, *id = NULL, *name, *content = NULL, *code; zval *avalue = NULL, *key = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", ¶meters) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(params); array_init(params); phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC); } else { PHALCON_CPY_WRT(params, parameters); } eval_int = phalcon_array_isset_long(params, 0); if (!eval_int) { eval_int = phalcon_array_isset_string(params, SS("id")); if (eval_int) { PHALCON_INIT_VAR(id); phalcon_array_fetch_string(&id, params, SL("id"), PH_NOISY_CC); phalcon_array_update_long(¶ms, 0, &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } } PHALCON_INIT_NVAR(id); phalcon_array_fetch_long(&id, params, 0, PH_NOISY_CC); eval_int = phalcon_array_isset_string(params, SS("name")); if (!eval_int) { phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(name); phalcon_array_fetch_string(&name, params, SL("name"), PH_NOISY_CC); if (!zend_is_true(name)) { phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } } eval_int = phalcon_array_isset_string(params, SS("id")); if (!eval_int) { phalcon_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } eval_int = phalcon_array_isset_string(params, SS("value")); if (eval_int) { PHALCON_INIT_VAR(content); phalcon_array_fetch_string(&content, params, SL("value"), PH_NOISY_CC); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, SS("value")); } else { PHALCON_INIT_NVAR(content); PHALCON_CALL_SELF_PARAMS_1(content, this_ptr, "getvalue", id); } PHALCON_INIT_VAR(code); ZVAL_STRING(code, "<textarea", 1); if (!phalcon_valid_foreach(params TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(params); 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_KEY(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(avalue); if (Z_TYPE_P(key) != IS_LONG) { PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", avalue, "\""); } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: PHALCON_SCONCAT_SVS(code, ">", content, "</textarea>"); RETURN_CTOR(code); }
static int php_do_mcast_opt(php_socket *php_sock, int level, int optname, zval *arg4) { HashTable *opt_ht; unsigned int if_index; int retval; int (*mcast_req_fun)(php_socket *, int, struct sockaddr *, socklen_t, unsigned); #ifdef HAS_MCAST_EXT int (*mcast_sreq_fun)(php_socket *, int, struct sockaddr *, socklen_t, struct sockaddr *, socklen_t, unsigned); #endif switch (optname) { case PHP_MCAST_JOIN_GROUP: mcast_req_fun = &php_mcast_join; goto mcast_req_fun; case PHP_MCAST_LEAVE_GROUP: { php_sockaddr_storage group = {0}; socklen_t glen; mcast_req_fun = &php_mcast_leave; mcast_req_fun: convert_to_array_ex(arg4); opt_ht = Z_ARRVAL_P(arg4); if (php_get_address_from_array(opt_ht, "group", php_sock, &group, &glen) == FAILURE) { return FAILURE; } if (php_get_if_index_from_array(opt_ht, "interface", php_sock, &if_index) == FAILURE) { return FAILURE; } retval = mcast_req_fun(php_sock, level, (struct sockaddr*)&group, glen, if_index); break; } #ifdef HAS_MCAST_EXT case PHP_MCAST_BLOCK_SOURCE: mcast_sreq_fun = &php_mcast_block_source; goto mcast_sreq_fun; case PHP_MCAST_UNBLOCK_SOURCE: mcast_sreq_fun = &php_mcast_unblock_source; goto mcast_sreq_fun; case PHP_MCAST_JOIN_SOURCE_GROUP: mcast_sreq_fun = &php_mcast_join_source; goto mcast_sreq_fun; case PHP_MCAST_LEAVE_SOURCE_GROUP: { php_sockaddr_storage group = {0}, source = {0}; socklen_t glen, slen; mcast_sreq_fun = &php_mcast_leave_source; mcast_sreq_fun: convert_to_array_ex(arg4); opt_ht = Z_ARRVAL_P(arg4); if (php_get_address_from_array(opt_ht, "group", php_sock, &group, &glen) == FAILURE) { return FAILURE; } if (php_get_address_from_array(opt_ht, "source", php_sock, &source, &slen) == FAILURE) { return FAILURE; } if (php_get_if_index_from_array(opt_ht, "interface", php_sock, &if_index) == FAILURE) { return FAILURE; } retval = mcast_sreq_fun(php_sock, level, (struct sockaddr*)&group, glen, (struct sockaddr*)&source, slen, if_index); break; } #endif default: php_error_docref(NULL, E_WARNING, "unexpected option in php_do_mcast_opt (level %d, option %d). " "This is a bug.", level, optname); return FAILURE; } if (retval != 0) { if (retval != -2) { /* error, but message already emitted */ PHP_SOCKET_ERROR(php_sock, "unable to set socket option", errno); } return FAILURE; } return SUCCESS; }
/** * Builds a HTML FORM tag * * <code> * echo Phalcon\Tag::form("posts/save"); * echo Phalcon\Tag::form(array("posts/save", "method" => "post")); * </code> * * Volt syntax: * <code> * {{ form("posts/save") }} * {{ form("posts/save", "method": "post") }} * </code> * * @param array $parameters * @return string */ PHP_METHOD(Phalcon_Tag, form){ zval *parameters = NULL, *params = NULL, *dispatcher, *dispatch_params; zval *action_parameters, *params_action = NULL, *controller_name; zval *action_name, *url, *action = NULL, *form_action; zval *code, *avalue = NULL, *key = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", ¶meters) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!parameters) { PHALCON_INIT_NVAR(parameters); } else { PHALCON_SEPARATE_PARAM(parameters); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(params); array_init(params); phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC); } else { PHALCON_CPY_WRT(params, parameters); } PHALCON_INIT_VAR(dispatcher); PHALCON_CALL_SELF(dispatcher, this_ptr, "getdispatcherservice"); PHALCON_INIT_VAR(dispatch_params); PHALCON_CALL_METHOD(dispatch_params, dispatcher, "getparams", PH_NO_CHECK); PHALCON_INIT_VAR(action_parameters); phalcon_fast_join_str(action_parameters, SL("/"), dispatch_params TSRMLS_CC); eval_int = phalcon_array_isset_long(params, 0); if (!eval_int) { eval_int = phalcon_array_isset_string(params, SS("action")); if (eval_int) { PHALCON_INIT_VAR(params_action); phalcon_array_fetch_string(¶ms_action, params, SL("action"), PH_NOISY_CC); } else { PHALCON_INIT_VAR(controller_name); PHALCON_CALL_METHOD(controller_name, dispatcher, "getcontrollername", PH_NO_CHECK); PHALCON_INIT_VAR(action_name); PHALCON_CALL_METHOD(action_name, dispatcher, "getactionname", PH_NO_CHECK); PHALCON_INIT_NVAR(params_action); PHALCON_CONCAT_VSV(params_action, controller_name, "/", action_name); } } else { PHALCON_INIT_NVAR(params_action); phalcon_array_fetch_long(¶ms_action, params, 0, PH_NOISY_CC); } eval_int = phalcon_array_isset_string(params, SS("method")); if (!eval_int) { phalcon_array_update_string_string(¶ms, SL("method"), SL("post"), PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(url); PHALCON_CALL_SELF(url, this_ptr, "geturlservice"); if (zend_is_true(action_parameters)) { PHALCON_INIT_VAR(action); PHALCON_CALL_METHOD_PARAMS_1(action, url, "get", params_action, PH_NO_CHECK); } else { PHALCON_INIT_VAR(form_action); PHALCON_CONCAT_VSV(form_action, params_action, "/", action_parameters); PHALCON_INIT_NVAR(action); PHALCON_CALL_METHOD_PARAMS_1(action, url, "get", form_action, PH_NO_CHECK); } eval_int = phalcon_array_isset_string(params, SS("parameters")); if (eval_int) { PHALCON_INIT_NVAR(parameters); phalcon_array_fetch_string(¶meters, params, SL("parameters"), PH_NOISY_CC); PHALCON_SCONCAT_SV(action, "?", parameters); } PHALCON_INIT_VAR(code); PHALCON_CONCAT_SVS(code, "<form action=\"", action, "\""); if (!phalcon_valid_foreach(params TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(params); 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_KEY(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(avalue); if (Z_TYPE_P(key) != IS_LONG) { PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", avalue, "\""); } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: phalcon_concat_self_str(code, SL(">") TSRMLS_CC); RETURN_CTOR(code); }
static PHP_METHOD(swoole_redis, __call) { zval *params; char *command; zend_size_t command_len; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &command, &command_len, ¶ms) == FAILURE) { return; } swRedisClient *redis = swoole_get_object(getThis()); if (!redis) { swoole_php_fatal_error(E_WARNING, "object is not instanceof swoole_redis."); RETURN_FALSE; } switch (redis->state) { case SWOOLE_REDIS_STATE_CONNECT: swoole_php_error(E_WARNING, "redis client is not connected."); RETURN_FALSE; break; case SWOOLE_REDIS_STATE_WAIT_RESULT: swoole_php_error(E_WARNING, "redis client is waiting for response."); RETURN_FALSE; break; case SWOOLE_REDIS_STATE_SUBSCRIBE: if (!swoole_redis_is_message_command(command, command_len)) { swoole_php_error(E_WARNING, "redis client is waiting for subscribe message."); RETURN_FALSE; } break; case SWOOLE_REDIS_STATE_CLOSED: swoole_php_error(E_WARNING, "redis client connection is closed."); RETURN_FALSE; break; default: break; } int argc = zend_hash_num_elements(Z_ARRVAL_P(params)); size_t stack_argvlen[SW_REDIS_COMMAND_BUFFER_SIZE]; char *stack_argv[SW_REDIS_COMMAND_BUFFER_SIZE]; size_t *argvlen; char **argv; zend_bool free_mm = 0; if (argc > SW_REDIS_COMMAND_BUFFER_SIZE) { argvlen = emalloc(sizeof(size_t) * argc); argv = emalloc(sizeof(char*) * argc); free_mm = 1; } else { argvlen = stack_argvlen; argv = stack_argv; } assert(command_len < SW_REDIS_COMMAND_KEY_SIZE - 1); char command_name[SW_REDIS_COMMAND_KEY_SIZE]; memcpy(command_name, command, command_len); command_name[command_len] = '\0'; argv[0] = command_name; argvlen[0] = command_len; zval *value; int i = 1; /** * subscribe command */ if (redis->state == SWOOLE_REDIS_STATE_SUBSCRIBE || (redis->subscribe && swoole_redis_is_message_command(command, command_len))) { redis->state = SWOOLE_REDIS_STATE_SUBSCRIBE; SW_HASHTABLE_FOREACH_START(Z_ARRVAL_P(params), value) convert_to_string(value); argvlen[i] = (size_t) Z_STRLEN_P(value); argv[i] = estrndup(Z_STRVAL_P(value), Z_STRLEN_P(value)); if (i == argc) { break; } i++; SW_HASHTABLE_FOREACH_END(); if (redisAsyncCommandArgv(redis->context, swoole_redis_onResult, NULL, argc + 1, (const char **) argv, (const size_t *) argvlen) < 0) { swoole_php_error(E_WARNING, "redisAsyncCommandArgv() failed."); RETURN_FALSE; } } /** * storage command */ else { redis->state = SWOOLE_REDIS_STATE_WAIT_RESULT; #if PHP_MAJOR_VERSION < 7 zval *callback; zval **cb_tmp; if (zend_hash_index_find(Z_ARRVAL_P(params), zend_hash_num_elements(Z_ARRVAL_P(params)) - 1, (void **) &cb_tmp) == FAILURE) { swoole_php_error(E_WARNING, "index out of array."); RETURN_FALSE; } callback = *cb_tmp; #else zval *callback = zend_hash_index_find(Z_ARRVAL_P(params), zend_hash_num_elements(Z_ARRVAL_P(params)) - 1); if (callback == NULL) { swoole_php_error(E_WARNING, "index out of array."); RETURN_FALSE; } #endif sw_zval_add_ref(&callback); redis->result_callback = sw_zval_dup(callback); SW_HASHTABLE_FOREACH_START(Z_ARRVAL_P(params), value) convert_to_string(value); argvlen[i] = (size_t) Z_STRLEN_P(value); argv[i] = estrndup(Z_STRVAL_P(value), Z_STRLEN_P(value)); if (i == argc - 1) { break; } i++; SW_HASHTABLE_FOREACH_END(); if (redisAsyncCommandArgv(redis->context, swoole_redis_onResult, NULL, argc, (const char **) argv, (const size_t *) argvlen) < 0) { swoole_php_error(E_WARNING, "redisAsyncCommandArgv() failed."); RETURN_FALSE; } } for (i = 1; i < argc; i++) { efree((void* )argv[i]); } if (free_mm) { efree(argvlen); efree(argv); } RETURN_TRUE; }
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(); }