These should not be enumerations.
Refactor these into defines.
build_sources_library validate.c
build_sources_headers common.h controller.h common/define.h common/enumeration.h common/print.h common/string.h common/thread.h common/type.h
-build_sources_headers common/define/control.h common/define/entry.h common/define/rule.h common/define/thread.h
+build_sources_headers common/define/control.h common/define/entry.h common/define/instance.h common/define/rule.h common/define/thread.h
build_sources_headers common/enumeration/control.h common/enumeration/entry.h common/enumeration/instance.h common/enumeration/process.h common/enumeration/rule.h common/enumeration/thread.h
build_sources_headers common/string/general.h common/string/rule.h
build_sources_headers common/type/cache.h common/type/control.h common/type/defs.h common/type/entry.h common/type/execute.h common/type/instance.h common/type/interrupt.h common/type/lock.h common/type/process.h common/type/rule.h common/type/thread.h
--- /dev/null
+/**
+ * FLL - Level 3
+ *
+ * Project: Controller
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Provides the common instance enumerations.
+ *
+ * This is auto-included and should not need to be explicitly included.
+ */
+#ifndef _controller_main_common_define_instance_h
+#define _controller_main_common_define_instance_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Instance options.
+ *
+ * controller_instance_option_*_d:
+ * - asynchronous: The Instance runs asynchronously.
+ * - require: The Instance is required.
+ * - simulate: The Instance is being simulated.
+ * - validate: The Instance is being validated.
+ * - wait: The Instance is blocking (waiting) for all asynchronous Instances before it to complete before running.
+ * - simulate_validate: A helper flag representing simulate and validate flag bits being set.
+ */
+#ifndef _di_controller_instance_option_d_
+ #define controller_instance_option_asynchronous_d 0x1
+ #define controller_instance_option_require_d 0x2
+ #define controller_instance_option_simulate_d 0x4
+ #define controller_instance_option_validate_d 0x8
+ #define controller_instance_option_wait_d 0x10
+ #define controller_instance_option_simulate_validate_d 0xc
+#endif // _di_controller_instance_option_d_
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // _controller_main_common_define_instance_h
#endif
/**
- * Instance options.
- *
- * @todo this should probably be defines rather than enums.
- *
- * controller_instance_option_*_e:
- * - asynchronous: The Instance runs asynchronously.
- * - require: The Instance is required.
- * - simulate: The Instance is being simulated.
- * - validate: The Instance is being validated.
- * - wait: The Instance is blocking (waiting) for all asynchronous Instances before it to complete before running.
- * - simulate_validate: A helper flag representing simulate and validate flag bits being set.
- */
-#ifndef _di_controller_instance_option_e_
- enum {
- controller_instance_option_asynchronous_e = 0x1,
- controller_instance_option_require_e = 0x2,
- controller_instance_option_simulate_e = 0x4,
- controller_instance_option_validate_e = 0x8,
- controller_instance_option_wait_e = 0x10,
- controller_instance_option_simulate_validate_e = 0xc,
- }; // enum
-#endif // _di_controller_instance_option_e_
-
-/**
* Instance states.
*
* controller_instance_state_*_e:
#include <program/controller/main/common/string/rule.h>
#include <program/controller/main/common/define/control.h>
#include <program/controller/main/common/define/entry.h>
+#include <program/controller/main/common/define/instance.h>
#include <program/controller/main/common/define/rule.h>
#include <program/controller/main/common/define/thread.h>
#include <program/controller/main/common/enumeration/control.h>
options_instance = 0;
if (main->setting.flag & controller_main_flag_simulate_d) {
- options_instance |= controller_instance_option_simulate_e;
+ options_instance |= controller_instance_option_simulate_d;
}
if (entry_action->code & controller_entry_rule_code_require_d) {
- options_instance |= controller_instance_option_require_e;
+ options_instance |= controller_instance_option_require_d;
}
if (entry_action->code & controller_entry_rule_code_wait_d) {
- options_instance |= controller_instance_option_wait_e;
+ options_instance |= controller_instance_option_wait_d;
}
if (main->setting.flag & controller_main_flag_validate_d) {
- options_instance |= controller_instance_option_validate_e;
+ options_instance |= controller_instance_option_validate_d;
}
if (entry_action->code & controller_entry_rule_code_asynchronous_d) {
if (!(main->setting.flag & controller_main_flag_validate_d)) {
- options_force |= controller_instance_option_asynchronous_e;
+ options_force |= controller_instance_option_asynchronous_d;
}
- options_instance |= controller_instance_option_asynchronous_e;
+ options_instance |= controller_instance_option_asynchronous_d;
}
status = controller_rule_instance_begin(main, cache, options_force, alias_rule, controller_entry_action_type_to_rule_action_type(entry_action->type), options_instance, is_entry ? controller_instance_type_entry_e : controller_instance_type_exit_e, stack);
fl_print_format("%rRule '", print->to, f_string_eol_s);
fl_print_format("%[%Q%]' has no '", print->to, print->set->title, rule->name, print->set->title);
fl_print_format("%[%r%]' Action to execute and would '", print->to, print->set->title, controller_convert_rule_action_type_string(action), print->set->title);
- fl_print_format("%[%r%]' because it is '", print->to, print->set->important, options & controller_instance_option_require_e ? controller_fail_s : controller_succeed_s, print->set->important);
- fl_print_format("%[%r%]'.%r", print->to, print->set->important, options & controller_instance_option_require_e ? controller_required_s : controller_optional_s, print->set->important, f_string_eol_s);
+ fl_print_format("%[%r%]' because it is '", print->to, print->set->important, options & controller_instance_option_require_d ? controller_fail_s : controller_succeed_s, print->set->important);
+ fl_print_format("%[%r%]'.%r", print->to, print->set->important, options & controller_instance_option_require_d ? controller_required_s : controller_optional_s, print->set->important, f_string_eol_s);
}
else {
fl_print_format("%rRule '", print->to, f_string_eol_s);
fl_print_format("'%[%r%]', ", print->to, print->set->title, controller_service_s, print->set->title);
fl_print_format("'%[%r%]', or ", print->to, print->set->title, controller_script_s, print->set->title);
fl_print_format("'%[%r%]'", print->to, print->set->title, controller_utility_s, print->set->title);
- fl_print_format(") and would '%[%r%]' because it is '", print->to, print->set->important, options & controller_instance_option_require_e ? controller_fail_s : controller_succeed_s, print->set->important);
- fl_print_format("%[%r%]'.%r", print->to, print->set->important, options & controller_instance_option_require_e ? controller_required_s : controller_optional_s, print->set->important, f_string_eol_s);
+ fl_print_format(") and would '%[%r%]' because it is '", print->to, print->set->important, options & controller_instance_option_require_d ? controller_fail_s : controller_succeed_s, print->set->important);
+ fl_print_format("%[%r%]'.%r", print->to, print->set->important, options & controller_instance_option_require_d ? controller_required_s : controller_optional_s, print->set->important, f_string_eol_s);
}
controller_unlock_print_flush(print->to, &main->thread);
f_print_dynamic_raw(f_string_eol_s, print->to);
// How.
- fl_print_format(" %[%r%] %r%r", print->to, print->set->important, controller_how_s, print->set->important, options & controller_instance_option_asynchronous_e ? controller_asynchronous_s : controller_synchronous_s, f_string_eol_s);
+ fl_print_format(" %[%r%] %r%r", print->to, print->set->important, controller_how_s, print->set->important, options & controller_instance_option_asynchronous_d ? controller_asynchronous_s : controller_synchronous_s, f_string_eol_s);
// Nice.
fl_print_format(" %[%r%]", print->to, print->set->important, controller_nice_s, print->set->important);
f_print_dynamic_raw(f_string_eol_s, print->to);
// Wait.
- fl_print_format(" %[%r%] %r%r", print->to, print->set->important, controller_wait_s, print->set->important, options & controller_instance_option_wait_e ? controller_yes_s : controller_no_s, f_string_eol_s);
+ fl_print_format(" %[%r%] %r%r", print->to, print->set->important, controller_wait_s, print->set->important, options & controller_instance_option_wait_d ? controller_yes_s : controller_no_s, f_string_eol_s);
// Affinity.
fl_print_format(" %[%r%] {%r", print->to, print->set->important, controller_affinity_s, print->set->important, f_string_eol_s);
* @param options
* A number using bits to represent specific boolean options.
* If no bits set, then operate normally in a synchronous manner.
- * If bit controller_instance_option_simulate_e, then the Rule execution is in simulation mode (printing a message that the Rule would be executed but does not execute the rule).
- * If bit controller_instance_option_asynchronous_e, then run asynchronously.
+ * If bit controller_instance_option_simulate_d, then the Rule execution is in simulation mode (printing a message that the Rule would be executed but does not execute the rule).
+ * If bit controller_instance_option_asynchronous_d, then run asynchronously.
*
* @return
* F_okay on success.
if (F_status_is_error(status)) {
instance->rule.items.array[i].actions.array[j].status = F_status_set_error(F_failure);
- if (!(options & controller_instance_option_simulate_e)) break;
+ if (!(options & controller_instance_option_simulate_d)) break;
success = F_status_set_error(F_failure);
}
if (F_status_is_error(status)) {
instance->rule.items.array[i].actions.array[j].status = F_status_set_error(F_failure);
- if (!(options & controller_instance_option_simulate_e)) break;
+ if (!(options & controller_instance_option_simulate_d)) break;
success = F_status_set_error(F_failure);
}
if (F_status_is_error(status)) {
instance->rule.items.array[i].actions.array[j].status = F_status_set_error(F_failure);
- if (!(options & controller_instance_option_simulate_e)) break;
+ if (!(options & controller_instance_option_simulate_d)) break;
success = F_status_set_error(F_failure);
}
if (F_status_is_error(status)) {
instance->rule.items.array[i].actions.array[j].status = F_status_set_error(F_failure);
- if (!(options & controller_instance_option_simulate_e)) break;
+ if (!(options & controller_instance_option_simulate_d)) break;
success = F_status_set_error(F_failure);
}
}
} // for
- if (status == F_child || F_status_set_fine(status) == F_interrupt || F_status_is_error(status) && !(options & controller_instance_option_simulate_e)) {
+ if (status == F_child || F_status_set_fine(status) == F_interrupt || F_status_is_error(status) && !(options & controller_instance_option_simulate_d)) {
break;
}
} // for
f_thread_unlock(&instance->use);
- if (options & controller_instance_option_simulate_e) {
+ if (options & controller_instance_option_simulate_d) {
controller_print_entry_output_execute_simulate(&main->program.output, instance, program, arguments);
// Sleep for less than a second to better show simulation of synchronous vs asynchronous.
return status;
}
- if (options & controller_instance_option_simulate_e) {
+ if (options & controller_instance_option_simulate_d) {
controller_print_entry_output_execute_simulate(&main->program.output, instance, program, arguments);
// Sleep for less than a second to better show simulation of synchronous vs asynchronous.
* - controller_rule_action_type_stop_e
* @param options
* Process options to consider when executing.
- * If bit controller_instance_option_simulate_e, then the Rule execution is in simulation mode (printing a message that the Rule would be executed but does not execute the rule).
+ * If bit controller_instance_option_simulate_d, then the Rule execution is in simulation mode (printing a message that the Rule would be executed but does not execute the rule).
*
* @return
* F_okay on success.
* The arguments to pass to the program.
* @param options
* Process options to consider when executing.
- * If bit controller_instance_option_simulate_e, then the Rule execution is in simulation mode (printing a message that the Rule would be executed but does not execute the rule).
+ * If bit controller_instance_option_simulate_d, then the Rule execution is in simulation mode (printing a message that the Rule would be executed but does not execute the rule).
* @param execute_set
* The execute parameter and as settings.
*
* The arguments to pass to the program.
* @param options
* Process options to consider when executing.
- * If bit controller_instance_option_simulate_e, then the Rule execution is in simulation mode (printing a message that the Rule would be executed but does not execute the rule).
+ * If bit controller_instance_option_simulate_d, then the Rule execution is in simulation mode (printing a message that the Rule would be executed but does not execute the rule).
* @param with
* The "with" option flags.
* @param execute_set
return status;
}
- if ((instance->options & controller_instance_option_simulate_validate_e) == controller_instance_option_simulate_validate_e) {
+ if ((instance->options & controller_instance_option_simulate_validate_d) == controller_instance_option_simulate_validate_d) {
switch (instance->action) {
case controller_rule_action_type_freeze_e:
case controller_rule_action_type_kill_e:
controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], dynamics[i]->array[j], "is not found");
- if (!(instance->options & controller_instance_option_simulate_e)) {
+ if (!(instance->options & controller_instance_option_simulate_d)) {
if (dependency) {
f_thread_unlock(&dependency->active);
}
status = controller_instance_wait(dependency);
- if (F_status_is_error(status) && !(instance->options & controller_instance_option_simulate_e)) break;
+ if (F_status_is_error(status) && !(instance->options & controller_instance_option_simulate_d)) break;
status_lock = controller_lock_read_instance(instance, &dependency->use);
options_instance = 0;
if (main->setting.flag & controller_main_flag_simulate_d) {
- options_instance |= controller_instance_option_simulate_e;
+ options_instance |= controller_instance_option_simulate_d;
}
- if (instance->options & controller_instance_option_validate_e) {
- options_instance |= controller_instance_option_validate_e;
+ if (instance->options & controller_instance_option_validate_d) {
+ options_instance |= controller_instance_option_validate_d;
}
// Synchronously execute dependency.
if (i == 0 || i == 1 || F_status_set_fine(status) == F_memory_not) {
controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], alias_other_buffer, "failed during execution");
- if (!(dependency->options & controller_instance_option_simulate_e) || F_status_set_fine(status) == F_memory_not) {
+ if (!(dependency->options & controller_instance_option_simulate_d) || F_status_set_fine(status) == F_memory_not) {
f_thread_unlock(&dependency->active);
break;
controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], alias_other_buffer, "is in a failed state");
- if (!(dependency->options & controller_instance_option_simulate_e)) {
+ if (!(dependency->options & controller_instance_option_simulate_d)) {
f_thread_unlock(&dependency->active);
break;
} // for
if (status == F_child || F_status_set_fine(status) == F_interrupt) break;
- if (F_status_is_error(status) && !(instance->options & controller_instance_option_simulate_e)) break;
+ if (F_status_is_error(status) && !(instance->options & controller_instance_option_simulate_d)) break;
} // for
}
if (status == F_child || F_status_set_fine(status) == F_interrupt) return status;
if (!controller_thread_is_enabled_instance(instance)) return F_status_set_error(F_interrupt);
- if ((instance->options & controller_instance_option_wait_e) && F_status_is_error_not(status) && (instance->options & controller_instance_option_validate_e)) {
+ if ((instance->options & controller_instance_option_wait_d) && F_status_is_error_not(status) && (instance->options & controller_instance_option_validate_d)) {
status_lock = controller_rule_wait_all_instance_type(main, instance->type, F_false);
if (F_status_set_fine(status_lock) == F_interrupt) return status_lock;
}
- if (!(instance->options & controller_instance_option_validate_e) && F_status_is_error_not(status)) {
+ if (!(instance->options & controller_instance_option_validate_d) && F_status_is_error_not(status)) {
// Find at least one of the requested Action when the Rule is required.
- if (instance->options & controller_instance_option_require_e) {
+ if (instance->options & controller_instance_option_require_d) {
uint8_t missing = F_true;
f_number_unsigned_t j = 0;
f_thread_unlock(&instance->use);
if (F_status_is_error_not(status)) {
- if (instance_action && (options_force & controller_instance_option_asynchronous_e)) {
+ if (instance_action && (options_force & controller_instance_option_asynchronous_d)) {
if (instance->type == controller_instance_type_exit_e) {
status = f_thread_create(0, &instance->thread, controller_thread_instance_other, (void *) instance);
}
return status;
}
- if (!action || (options_force & controller_instance_option_asynchronous_e)) {
+ if (!action || (options_force & controller_instance_option_asynchronous_d)) {
instance->state = controller_instance_state_done_e;
}
else {
{
f_status_t status_lock = F_okay;
- if (options_force & controller_instance_option_asynchronous_e) {
+ if (options_force & controller_instance_option_asynchronous_d) {
status_lock = controller_lock_read_instance(instance, &instance->active);
if (F_status_is_error(status_lock)) {
f_thread_unlock(&instance->main->thread.lock.rule);
}
- if (options_force & controller_instance_option_asynchronous_e) {
+ if (options_force & controller_instance_option_asynchronous_d) {
f_thread_unlock(&instance->active);
}
return status_lock;
}
- instance->state = (options_force & controller_instance_option_asynchronous_e) ? controller_instance_state_done_e : controller_instance_state_idle_e;
+ instance->state = (options_force & controller_instance_option_asynchronous_d) ? controller_instance_state_done_e : controller_instance_state_idle_e;
instance->stack.used = used_original_stack;
f_thread_unlock(&instance->use);
* @param options_force
* Force the given instance options, only supporting a subset of instance options.
*
- * If controller_instance_option_asynchronous_e, then asynchronously execute.
- * If not controller_instance_option_asynchronous_e, then synchronously execute.
+ * If controller_instance_option_asynchronous_d, then asynchronously execute.
+ * If not controller_instance_option_asynchronous_d, then synchronously execute.
* @param alias_rule
* The alias of the rule, such as "boot/init".
* @param action
* @param options_force
* Force the given instance options, only supporting a subset of instance options.
*
- * If controller_instance_option_asynchronous_e, then asynchronously execute.
- * If not controller_instance_option_asynchronous_e, then synchronously execute.
+ * If controller_instance_option_asynchronous_d, then asynchronously execute.
+ * If not controller_instance_option_asynchronous_d, then synchronously execute.
*
* @return
* Status from: controller_rule_instance_perform_details().
* @param options_force
* Force the given instance options, only supporting a subset of instance options.
*
- * If controller_instance_option_asynchronous_e, then asynchronously execute.
- * If not controller_instance_option_asynchronous_e, then synchronously execute.
+ * If controller_instance_option_asynchronous_d, then asynchronously execute.
+ * If not controller_instance_option_asynchronous_d, then synchronously execute.
* @param flag
* Designate lock states:
* - 0x1: Locking error.
locked |= 0x2;
// If the instance thread has been cleaned up and joined or if instance is not required when only processing "required", then skip.
- if (!instance_list[i]->thread || required && !(instance_list[i]->options & controller_instance_option_require_e)) {
+ if (!instance_list[i]->thread || required && !(instance_list[i]->options & controller_instance_option_require_d)) {
locked |= 0x8;
}
locked |= 0x2;
}
- if (instance_list[i]->options & controller_instance_option_require_e) {
+ if (instance_list[i]->options & controller_instance_option_require_d) {
if (controller_rule_status_is_error(instance_list[i]->action, instance_list[i]->rule)) {
status = F_status_set_error(F_require);
locked |= 0x2;
- if (instance_list[i]->options & controller_instance_option_require_e) {
+ if (instance_list[i]->options & controller_instance_option_require_d) {
if (controller_rule_status_is_error(instance_list[i]->action, instance_list[i]->rule)) {
status = F_status_set_error(F_require);
if (!instance || !instance->main) return;
if (!controller_thread_enable_is_normal(&instance->main->thread, is_normal)) return;
- const f_status_t status = controller_rule_instance_perform(instance, controller_instance_option_asynchronous_e);
+ const f_status_t status = controller_rule_instance_perform(instance, controller_instance_option_asynchronous_d);
// A forked child Instance should de-allocate memory on exit.
// It seems that this function doesn't return to the calling thread for a forked child Instance, even with the "return 0;" below.
projects / controller / commitdiff