f_state_t state = macro_f_state_t_initialize_1(controller_common_allocation_large_d, controller_common_allocation_small_d, F_okay, 0, 0, 0, &controller_thread_signal_state_fss, 0, (void *) &custom, 0);
f_range_t range = content_range;
- status = fll_fss_extended_read(cache->buffer_file, &range, &cache->object_actions, &cache->content_actions, 0, 0, &cache->delimits, 0, &state);
+ fll_fss_extended_read(cache->buffer_file, &range, &cache->object_actions, &cache->content_actions, 0, 0, &cache->delimits, 0, &state);
}
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "fll_fss_extended_read", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "fll_fss_extended_read", F_true, global.thread);
return status;
}
f_state_t state = f_state_t_initialize;
- status = f_fss_apply_delimit(state, cache->delimits, &cache->buffer_file);
+ f_fss_apply_delimit(cache->delimits, &cache->buffer_file, &state);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_fss_apply_delimit", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_fss_apply_delimit", F_true, global.thread);
return status;
}
status = controller_entry_actions_increase_by(cache->object_actions.used, actions);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "controller_entry_actions_increase_by", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "controller_entry_actions_increase_by", F_true, global.thread);
return status;
}
action->status = F_known_not;
action->parameters.used = 0;
- status = f_fss_count_lines(cache->buffer_file, cache->object_actions.array[i].start, &cache->action.line_action, &global->setting->state);
+ f_fss_count_lines(cache->buffer_file, cache->object_actions.array[i].start, &cache->action.line_action, &global.main->setting.state);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_fss_count_lines", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_fss_count_lines", F_true, global.thread);
break;
}
status = f_rip_dynamic_partial_nulless(cache->buffer_file, cache->object_actions.array[i], &cache->action.name_action);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true, global.thread);
break;
}
fl_print_format(f_string_format_Q_single_s.string, global.main->program.warning.to, global.main->program.warning.notable, cache->action.name_action, global.main->program.warning.notable);
fl_print_format(f_string_format_sentence_end_quote_s.string, global.main->program.warning.to, global.main->program.warning.context, global.main->program.warning.context, f_string_eol_s);
- controller_entry_print_error_cache(is_entry, global.main->program.warning, cache->action);
+ controller_entry_print_error_cache(is_entry, &global.main->program.warning, cache->action);
controller_unlock_print_flush(global.main->program.warning.to, global.thread);
}
status = f_memory_array_increase_by(allocate, sizeof(f_string_dynamic_t), (void **) &action->parameters.array, &action->parameters.used, &action->parameters.size);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase_by", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase_by", F_true, global.thread);
action->status = status;
status = f_memory_array_increase_by((cache->content_actions.array[i].array[j].stop - cache->content_actions.array[i].array[j].start) + 1, sizeof(f_char_t), (void **) &action->parameters.array[j].string, &action->parameters.array[j].used, &action->parameters.array[j].size);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase_by", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase_by", F_true, global.thread);
break;
}
status = f_string_dynamic_partial_append_nulless(cache->buffer_file, cache->content_actions.array[i].array[j], &action->parameters.array[j]);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, global.thread);
break;
}
status = controller_path_canonical_relative(global.setting, action->parameters.array[0], &cache->buffer_path);
if (F_status_is_error(status)) {
- controller_entry_print_error_file(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "controller_path_canonical_relative", F_true, cache->action.generic, f_file_operation_analyze_s, fll_error_file_type_path_e, global.thread);
+ controller_entry_print_error_file(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "controller_path_canonical_relative", F_true, cache->action.generic, f_file_operation_analyze_s, fll_error_file_type_path_e, global.thread);
action->status = status;
status = f_file_name_base(action->parameters.array[1], &cache->buffer_path);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_file_name_base", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_file_name_base", F_true, global.thread);
if (F_status_set_fine(status) == F_memory_not) {
status_action = status;
}
if (F_status_set_fine(status) == F_memory_not) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "fl_conversion_dynamic_to_unsigned_detect", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "fl_conversion_dynamic_to_unsigned_detect", F_true, global.thread);
status_action = status;
cache->action.name_action.used = 0;
cache->action.name_item.used = 0;
- macro_f_number_unsigneds_t_increase_by(status, cache->ats, controller_common_allocation_small_d)
+ status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_number_unsigned_t), (void **) &cache->ats.array, &cache->ats.used, &cache->ats.size);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "macro_f_number_unsigneds_t_increase_by", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase", F_true, global.thread);
return status;
}
cache->action.line_item = entry->items.array[0].line;
cache->action.name_item.used = 0;
- status = f_string_dynamic_append_nulless(entry->items.array[0].key, &cache->action.name_item);
+ status = f_string_dynamic_append_nulless(entry->items.array[0].name, &cache->action.name_item);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true, global.thread);
return status;
}
status2 = f_string_dynamic_append_nulless(controller_entry_action_type_name(actions->array[cache->ats.array[at_j]].type), &cache->action.name_action);
if (F_status_is_error(status2)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status2), "f_string_dynamic_append_nulless", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status2), "f_string_dynamic_append_nulless", F_true, global.thread);
return status2;
}
fl_print_format(f_string_format_r_single_s.string, global.main->program.warning.to, global.main->program.warning.notable, controller_ready_s, global.main->program.warning.notable);
fl_print_format("%[' %r item actions detected; only the first will be used.%]%r", global.main->program.warning.to, global.main->program.warning.context, is_entry ? controller_entry_s : controller_exit_s, global.main->program.warning.context, f_string_eol_s);
- controller_entry_print_error_cache(is_entry, global.main->program.warning, cache->action);
+ controller_entry_print_error_cache(is_entry, &global.main->program.warning, cache->action);
controller_unlock_print_flush(global.main->program.warning.to, global.thread);
}
// Walk though each items and check to see if the item actually exists.
for (i = 1; i < entry->items.used && controller_thread_is_enabled(is_entry, global.thread); ++i) {
- if (f_compare_dynamic(entry->items.array[i].key, actions->array[cache->ats.array[at_j]].parameters.array[0]) == F_equal_to) {
+ if (f_compare_dynamic(entry->items.array[i].name, actions->array[cache->ats.array[at_j]].parameters.array[0]) == F_equal_to) {
// Check to see if "i" is already in the stack (to prevent recursion) (skipping main).
for (j = 2; j < cache->ats.used; j += 2) {
controller_lock_print(global.main->program.error.to, global.thread);
fl_print_format("%r%[%QThe %r item named '%]", global.main->program.error.to, f_string_eol_s, global.main->program.error.context, is_entry ? controller_entry_s : controller_exit_s, global.main->program.error.prefix, global.main->program.error.context);
- fl_print_format(f_string_format_Q_single_s.string, global.main->program.error.to, global.main->program.error.notable, entry->items.array[i].key, global.main->program.error.notable);
+ fl_print_format(f_string_format_Q_single_s.string, global.main->program.error.to, global.main->program.error.notable, entry->items.array[i].name, global.main->program.error.notable);
fl_print_format("%[' cannot be executed because recursion is not allowed.%]%r", global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
- controller_entry_print_error_cache(is_entry, global.main->program.error, cache->action);
+ controller_entry_print_error_cache(is_entry, &global.main->program.error, cache->action);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
if (error_has) break;
- macro_f_number_unsigneds_t_increase_by(status2, cache->ats, controller_common_allocation_small_d)
+ status2 = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_number_unsigned_t), (void **) &cache->ats.array, &cache->ats.used, &cache->ats.size);
if (F_status_is_error(status2)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status2), "macro_f_number_unsigneds_t_increase_by", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status2), "f_memory_array_increase", F_true, global.thread);
return status2;
}
cache->action.name_item.used = 0;
cache->action.line_item = entry->items.array[i].line;
- status2 = f_string_dynamic_append_nulless(entry->items.array[i].key, &cache->action.name_item);
+ status2 = f_string_dynamic_append_nulless(entry->items.array[i].name, &cache->action.name_item);
if (F_status_is_error(status2)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status2), "f_string_dynamic_append_nulless", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status2), "f_string_dynamic_append_nulless", F_true, global.thread);
return status2;
}
fl_print_format(f_string_format_Q_single_s.string, global.main->program.error.to, global.main->program.error.notable, actions->array[cache->ats.array[at_j]].parameters.array[0], global.main->program.error.notable);
fl_print_format("%[' does not exist.%]%r", global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
- controller_entry_print_error_cache(is_entry, global.main->program.error, cache->action);
+ controller_entry_print_error_cache(is_entry, &global.main->program.error, cache->action);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
status2 = f_string_dynamic_append_nulless(entry->items.array[cache->ats.array[at_i]].name, &cache->action.name_item);
if (F_status_is_error(status2)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status2), "f_string_dynamic_append_nulless", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status2), "f_string_dynamic_append_nulless", F_true, global.thread);
return status2;
}
cache->action.name_action.used = 0;
cache->action.name_item.used = 0;
- macro_f_number_unsigneds_t_increase_by(status, cache->ats, controller_common_allocation_small_d)
+ status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_number_unsigned_t), (void **) &cache->ats.array, &cache->ats.used, &cache->ats.size);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global->main->program.error, cache->action, F_status_set_fine(status), "macro_f_number_unsigneds_t_increase_by", F_true, global->thread);
+ controller_entry_print_error(is_entry, &global->main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase", F_true, global->thread);
return status;
}
status = f_string_dynamic_append_nulless(entry->items.array[cache->ats.array[0]].name, &cache->action.name_item);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global->main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true, global->thread);
+ controller_entry_print_error(is_entry, &global->main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true, global->thread);
return status;
}
status = f_string_dynamic_append_nulless(controller_entry_action_type_name(entry_action->type), &cache->action.name_action);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global->main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true, global->thread);
+ controller_entry_print_error(is_entry, &global->main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true, global->thread);
return status;
}
if (entry_action->parameters.used) {
fl_print_format(" %[", global->main->program.output.to, global->main->program.context.set.notable);
- controller_entry_action_parameters_print(global->main->program.output.to, *entry_action);
+ controller_entry_action_parameters_print(&global->main->program.output, *entry_action);
fl_print_format("%]", global->main->program.output.to, global->main->program.context.set.notable);
}
}
else {
if ((entry_action->code & controller_entry_rule_code_require_d) && global->main->program.error.verbosity > f_console_verbosity_quiet_e || !(entry_action->code & controller_entry_rule_code_require_d) && (global->main->program.warning.verbosity == f_console_verbosity_verbose_e || global->main->program.warning.verbosity == f_console_verbosity_debug_e)) {
- fl_print_t *output = 0;
+ fl_print_t *print = 0;
if (entry_action->code & controller_entry_rule_code_require_d) {
- output = &global->main->program.error;
+ print = &global->main->program.error;
}
else if (global->main->program.error.verbosity != f_console_verbosity_error_e) {
- output = &global->main->program.warning;
+ print = &global->main->program.warning;
}
- if (output) {
- controller_lock_print(output->to, global->thread);
+ if (print) {
+ controller_lock_print(print->to, global->thread);
- fl_print_format("%r%[%QThe %r item action '%]", output->to, f_string_eol_s, output->context, output->prefix, is_entry ? controller_entry_s : controller_exit_s, output->context);
- fl_print_format(f_string_format_Q_single_s.string, output->to, output->notable, cache->action.name_action, output->notable);
+ fl_print_format("%r%[%QThe %r item action '%]", print->to, f_string_eol_s, print->context, print->prefix, is_entry ? controller_entry_s : controller_exit_s, print->context);
+ fl_print_format(f_string_format_Q_single_s.string, print->to, print->notable, cache->action.name_action, print->notable);
if (entry_action->parameters.used) {
- fl_print_format(" %[", output->to, global->main->program.context.set.notable);
+ fl_print_format(" %[", print->to, global->main->program.context.set.notable);
- controller_entry_action_parameters_print(output->to, *entry_action);
+ controller_entry_action_parameters_print(print, *entry_action);
- fl_print_format("%]", output->to, global->main->program.context.set.notable);
+ fl_print_format("%]", print->to, global->main->program.context.set.notable);
}
if (entry_action->code & controller_entry_rule_code_require_d) {
- fl_print_format("%[' is%] %[required%]", output->to, output->context, output->context, output->notable, output->notable);
+ fl_print_format("%[' is%] %[required%]", print->to, print->context, print->context, print->notable, print->notable);
}
else {
- fl_print_format("%[' is%] %[optional%]", output->to, output->context, output->context, output->notable, output->notable);
+ fl_print_format("%[' is%] %[optional%]", print->to, print->context, print->context, print->notable, print->notable);
}
- fl_print_format(" %[and is in a%] %[failed%]", output->to, output->context, output->context, output->notable, output->notable);
+ fl_print_format(" %[and is in a%] %[failed%]", print->to, print->context, print->context, print->notable, print->notable);
if (entry_action->code & controller_entry_rule_code_require_d) {
- fl_print_format(" %[state, aborting.%]%r", output->to, output->context, output->context, f_string_eol_s);
+ fl_print_format(" %[state, aborting.%]%r", print->to, print->context, print->context, f_string_eol_s);
}
else {
- fl_print_format(" %[state, skipping.%]%r", output->to, output->context, output->context, f_string_eol_s);
+ fl_print_format(" %[state, skipping.%]%r", print->to, print->context, print->context, f_string_eol_s);
}
- controller_entry_print_error_cache(is_entry, *output, cache->action);
+ controller_entry_print_error_cache(is_entry, print, cache->action);
- controller_unlock_print_flush(output->to, global->thread);
+ controller_unlock_print_flush(print->to, global->thread);
}
}
fl_print_format("%[%un%]", global->main->program.error.to, global->main->program.error.notable, entry_action->number, global->main->program.error.notable);
fl_print_format("%[' detected.%]%r", global->main->program.error.to, global->main->program.error.context, global->main->program.error.context, f_string_eol_s);
- controller_entry_print_error_cache(is_entry, global->main->program.error, cache->action);
+ controller_entry_print_error_cache(is_entry, &global->main->program.error, cache->action);
controller_unlock_print_flush(global->main->program.error.to, global->thread);
}
return F_status_is_error(F_critical);
}
- macro_f_number_unsigneds_t_increase_by(status, cache->ats, controller_common_allocation_small_d)
+ status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_number_unsigned_t), (void **) &cache->ats.array, &cache->ats.used, &cache->ats.size);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global->main->program.error, cache->action, F_status_set_fine(status), "macro_f_number_unsigneds_t_increase_by", F_true, global->thread);
+ controller_entry_print_error(is_entry, &global->main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase", F_true, global->thread);
return status;
}
status = f_string_dynamic_append_nulless(entry->items.array[cache->ats.array[at_i]].name, &cache->action.name_item);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global->main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true, global->thread);
+ controller_entry_print_error(is_entry, &global->main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true, global->thread);
return status;
}
status_lock = controller_lock_write(is_entry, global->thread, &global->thread->lock.rule);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global->main->program.error, F_status_set_fine(status_lock), F_false, global->thread);
+ controller_lock_print_error_critical(&global->main->program.error, F_status_set_fine(status_lock), F_false, global->thread);
break;
}
f_thread_unlock(&global->thread->lock.rule);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global->main->program.error, cache->action, F_status_set_fine(status), "controller_rules_increase", F_true, global->thread);
+ controller_entry_print_error(is_entry, &global->main->program.error, cache->action, F_status_set_fine(status), "controller_rules_increase", F_true, global->thread);
return status;
}
status_lock = controller_lock_read(is_entry, global->thread, &global->thread->lock.rule);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global->main->program.error, F_status_set_fine(status_lock), F_true, global->thread);
+ controller_lock_print_error_critical(&global->main->program.error, F_status_set_fine(status_lock), F_true, global->thread);
break;
}
cache->action.line_item = cache_line_item;
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global->main->program.error, F_status_set_fine(status_lock), F_false, global->thread);
+ controller_lock_print_error_critical(&global->main->program.error, F_status_set_fine(status_lock), F_false, global->thread);
break;
}
if (global->main->program.error.verbosity > f_console_verbosity_quiet_e) {
controller_lock_print(global->main->program.error.to, global->thread);
- controller_entry_print_error_cache(is_entry, global->main->program.error, cache->action);
+ controller_entry_print_error_cache(is_entry, &global->main->program.error, cache->action);
controller_unlock_print_flush(global->main->program.error.to, global->thread);
}
fl_print_format(f_string_format_Q_single_s.string, global->main->program.error.to, global->main->program.error.notable, entry_action->parameters.array[0], global->main->program.error.notable);
fl_print_format(f_string_format_sentence_end_quote_s.string, global->main->program.error.to, global->main->program.error.context, global->main->program.error.context, f_string_eol_s);
- controller_entry_print_error_cache(is_entry, global->main->program.error, cache->action);
+ controller_entry_print_error_cache(is_entry, &global->main->program.error, cache->action);
controller_unlock_print_flush(global->main->program.error.to, global->thread);
}
}
else {
- controller_entry_print_error(is_entry, global->main->program.error, cache->action, F_status_set_fine(status), "fll_execute_into", F_true, global->thread);
+ controller_entry_print_error(is_entry, &global->main->program.error, cache->action, F_status_set_fine(status), "fll_execute_into", F_true, global->thread);
}
return F_status_set_error(F_execute);
fl_print_format("%[%i%]", global->main->program.error.to, global->main->program.error.notable, result, global->main->program.error.notable);
fl_print_format("$['.%]%r", global->main->program.error.to, global->main->program.error.context, global->main->program.error.context, f_string_eol_s);
- controller_entry_print_error_cache(is_entry, global->main->program.error, cache->action);
+ controller_entry_print_error_cache(is_entry, &global->main->program.error, cache->action);
controller_unlock_print_flush(global->main->program.error.to, global->thread);
}
fl_print_format("%r%[%QFailsafe may not be specified when running in failsafe, ignoring.%]%r", global->main->program.warning.to, f_string_eol_s, global->main->program.warning.context, global->main->program.warning.prefix, global->main->program.warning.context, f_string_eol_s);
- controller_entry_print_error_cache(is_entry, global->main->program.warning, cache->action);
+ controller_entry_print_error_cache(is_entry, &global->main->program.warning, cache->action);
controller_unlock_print_flush(global->main->program.warning.to, global->thread);
}
fl_print_format("%[%un%]", global->main->program.error.to, global->main->program.error.notable, entry_action->number, global->main->program.error.notable);
fl_print_format("%[' detected.%]%r", global->main->program.error.to, global->main->program.error.context, global->main->program.error.context, f_string_eol_s);
- controller_entry_print_error_cache(is_entry, global->main->program.error, cache->action);
+ controller_entry_print_error_cache(is_entry, &global->main->program.error, cache->action);
controller_unlock_print_flush(global->main->program.error.to, global->thread);
}
status = f_string_dynamic_append_nulless(entry->items.array[cache->ats.array[at_i]].name, &cache->action.name_item);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global->main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true, global->thread);
+ controller_entry_print_error(is_entry, &global->main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true, global->thread);
break;
}
entry->status = F_known_not;
entry->items.used = 0;
- if (global.main->as_init) {
+ if (global.main->setting.flag & controller_main_flag_init_e) {
entry->session = controller_entry_session_new_e;
}
else {
f_state_t state = macro_f_state_t_initialize_1(controller_common_allocation_large_d, controller_common_allocation_small_d, F_okay, 0, 0, 0, &controller_thread_signal_state_fss, 0, (void *) &custom, 0);
f_range_t range = macro_f_range_t_initialize_2(cache->buffer_file.used);
- status = fll_fss_basic_list_read(cache->buffer_file, state, &range, &cache->object_items, &cache->content_items, &cache->delimits, 0, &cache->comments);
+ fll_fss_basic_list_read(cache->buffer_file, &range, &cache->object_items, &cache->content_items, &cache->delimits, 0, &cache->comments, &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "fll_fss_basic_list_read", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "fll_fss_basic_list_read", F_true);
}
else {
- status = f_fss_apply_delimit(state, cache->delimits, &cache->buffer_file);
+ f_fss_apply_delimit(cache->delimits, &cache->buffer_file, &state);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_fss_apply_delimit", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_fss_apply_delimit", F_true, global.thread);
}
}
}
status = controller_entry_items_increase_by(cache->object_items.used, &entry->items);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "controller_entry_items_increase_by", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "controller_entry_items_increase_by", F_true, global.thread);
}
else {
status = controller_entry_items_increase_by(controller_common_allocation_small_d, &entry->items);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "controller_entry_items_increase_by", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "controller_entry_items_increase_by", F_true, global.thread);
break;
}
status = f_string_dynamic_partial_append(cache->buffer_file, cache->object_items.array[i], &cache->action.name_item);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append", F_true, global.thread);
break;
}
- status = f_fss_count_lines(cache->buffer_file, cache->object_items.array[i].start, &cache->action.line_item, &global.main->setting.state);
+ f_fss_count_lines(cache->buffer_file, cache->object_items.array[i].start, &cache->action.line_item, &global.main->setting.state);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_fss_count_lines", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_fss_count_lines", F_true, global.thread);
break;
}
fl_print_format(f_string_format_Q_single_s.string, global.main->program.warning.to, global.main->program.warning.notable, cache->action.name_file, global.main->program.warning.notable);
fl_print_format(f_string_format_sentence_end_quote_s.string, global.main->program.warning.to, global.main->program.warning.context, global.main->program.warning.context, f_string_eol_s);
- controller_entry_print_error_cache(is_entry, global.main->program.warning, cache->action);
+ controller_entry_print_error_cache(is_entry, &global.main->program.warning, cache->action);
controller_unlock_print_flush(global.main->program.warning.to, global.thread);
}
else {
// skip position 0, which is reserved for "main".
- entry->items.array[0].key.used = 0;
+ entry->items.array[0].name.used = 0;
at = 1;
entry->items.used = 2;
status = f_string_dynamic_append_nulless(cache->action.name_item, &entry->items.array[at].name);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true);
break;
}
if (F_status_set_fine(status) != F_interrupt) {
controller_lock_print(global.main->program.error.to, global.thread);
- controller_entry_print_error_cache(is_entry, global.main->program.error, cache->action);
+ controller_entry_print_error_cache(is_entry, &global.main->program.error, cache->action);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
cache->action.line_action = action->line;
cache->action.line_item = entry->items.array[i].line;
- status = f_string_dynamic_append_nulless(entry->items.array[i].key, &cache->action.name_item);
+ status = f_string_dynamic_append_nulless(entry->items.array[i].name, &cache->action.name_item);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true);
break;
}
fl_print_format(f_string_format_Q_single_s.string, global.main->program.error.to, global.main->program.error.notable, action->parameters.array[0], global.main->program.error.notable);
fl_print_format("%[' does not exist.%]%r", global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
- controller_entry_print_error_cache(is_entry, global.main->program.error, cache->action);
+ controller_entry_print_error_cache(is_entry, &global.main->program.error, cache->action);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
if (F_status_is_error(status)) {
if (F_status_set_fine(status) != F_interrupt) {
- controller_entry_print_error_cache(is_entry, global.main->program.error, cache->action);
+ controller_entry_print_error_cache(is_entry, &global.main->program.error, cache->action);
}
entry->status = controller_status_simplify_error(F_status_set_fine(status));
f_state_t state = macro_f_state_t_initialize_1(controller_common_allocation_large_d, controller_common_allocation_small_d, F_okay, 0, 0, 0, &controller_thread_signal_state_fss, 0, (void *) &custom, 0);
f_range_t range = content_range;
- status = fll_fss_extended_read(cache->buffer_file, &range, &cache->object_actions, &cache->content_actions, 0, 0, &cache->delimits, 0, &state);
+ fll_fss_extended_read(cache->buffer_file, &range, &cache->object_actions, &cache->content_actions, 0, 0, &cache->delimits, 0, &state);
}
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "fll_fss_extended_read", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "fll_fss_extended_read", F_true, global.thread);
return status;
}
{
f_state_t state = f_state_t_initialize;
- status = f_fss_apply_delimit(state, cache->delimits, &cache->buffer_file);
+ f_fss_apply_delimit(cache->delimits, &cache->buffer_file, &state);
}
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_fss_apply_delimit", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_fss_apply_delimit", F_true, global.thread);
return status;
}
cache->action.line_action = 0;
- status = f_fss_count_lines(cache->buffer_file, cache->object_actions.array[i].start, &cache->action.line_action, &global->setting->state);
+ f_fss_count_lines(cache->buffer_file, cache->object_actions.array[i].start, &cache->action.line_action, &global.main->setting.state);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_fss_count_lines", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_fss_count_lines", F_true, global.thread);
break;
}
status = f_rip_dynamic_partial_nulless(cache->buffer_file, cache->object_actions.array[i], &cache->action.name_action);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true, global.thread);
break;
}
fl_print_format(f_string_format_sentence_end_quote_s.string, global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
- controller_entry_print_error_cache(is_entry, global.main->program.error, cache->action);
+ controller_entry_print_error_cache(is_entry, &global.main->program.error, cache->action);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
status = f_rip_dynamic_partial_nulless(cache->buffer_file, cache->content_actions.array[i].array[0], &cache->action.generic);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true, global.thread);
break;
}
status = controller_path_canonical_relative(global.setting, cache->action.generic, &global.setting->path_control);
if (F_status_is_error(status)) {
- controller_entry_print_error_file(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "controller_path_canonical_relative", F_true, cache->action.generic, f_file_operation_analyze_s, fll_error_file_type_path_e, global.thread);
+ controller_entry_print_error_file(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "controller_path_canonical_relative", F_true, cache->action.generic, f_file_operation_analyze_s, fll_error_file_type_path_e, global.thread);
continue;
}
status = F_status_set_fine(status);
if (status == F_exist_not) {
- controller_entry_setting_read_print_error_with_range(is_entry, global.main->program.error, " has an invalid group", cache->content_actions.array[i].array[0], ", because no group was found by that name", global.thread, cache);
+ controller_entry_setting_read_print_error_with_range(is_entry, &global.main->program.error, " has an invalid group", cache->content_actions.array[i].array[0], ", because no group was found by that name", global.thread, cache);
}
else if (status == F_number_too_large) {
- controller_entry_setting_read_print_error_with_range(is_entry, global.main->program.error, " has an invalid group", cache->content_actions.array[i].array[0], ", because the given ID is too large", global.thread, cache);
+ controller_entry_setting_read_print_error_with_range(is_entry, &global.main->program.error, " has an invalid group", cache->content_actions.array[i].array[0], ", because the given ID is too large", global.thread, cache);
}
else if (status == F_number) {
- controller_entry_setting_read_print_error_with_range(is_entry, global.main->program.error, " has an invalid group", cache->content_actions.array[i].array[0], ", because the given ID is not a valid supported number", global.thread, cache);
+ controller_entry_setting_read_print_error_with_range(is_entry, &global.main->program.error, " has an invalid group", cache->content_actions.array[i].array[0], ", because the given ID is not a valid supported number", global.thread, cache);
}
else {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "controller_get_id_group", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "controller_get_id_group", F_true, global.thread);
}
continue;
status = f_rip_dynamic_partial_nulless(cache->buffer_file, cache->content_actions.array[i].array[0], &cache->action.generic);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true, global.thread);
break;
}
- status = f_file_mode_from_string(cache->action.generic, global.main->umask, &mode_file, &replace);
+ status = f_file_mode_from_string(cache->action.generic, global.main->program.umask, &mode_file, &replace);
if (F_status_is_error(status)) {
- controller_entry_setting_read_print_error_with_range(is_entry, global.main->program.error, " has an unsupported mode", cache->content_actions.array[i].array[0], ", because the format is unknown or contains invalid data", global.thread, cache);
+ controller_entry_setting_read_print_error_with_range(is_entry, &global.main->program.error, " has an unsupported mode", cache->content_actions.array[i].array[0], ", because the format is unknown or contains invalid data", global.thread, cache);
continue;
}
status = f_file_mode_to_mode(mode_file, &mode);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_file_mode_to_mode", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_file_mode_to_mode", F_true, global.thread);
continue;
}
status = F_status_set_fine(status);
if (status == F_exist_not) {
- controller_entry_setting_read_print_error_with_range(is_entry, global.main->program.error, " has an invalid user", cache->content_actions.array[i].array[0], ", because no user was found by that name", global.thread, cache);
+ controller_entry_setting_read_print_error_with_range(is_entry, &global.main->program.error, " has an invalid user", cache->content_actions.array[i].array[0], ", because no user was found by that name", global.thread, cache);
}
else if (status == F_number_too_large) {
- controller_entry_setting_read_print_error_with_range(is_entry, global.main->program.error, " has an invalid user", cache->content_actions.array[i].array[0], ", because the given ID is too large", global.thread, cache);
+ controller_entry_setting_read_print_error_with_range(is_entry, &global.main->program.error, " has an invalid user", cache->content_actions.array[i].array[0], ", because the given ID is too large", global.thread, cache);
}
else if (status == F_number) {
- controller_entry_setting_read_print_error_with_range(is_entry, global.main->program.error, " has an invalid user", cache->content_actions.array[i].array[0], ", because the given ID is not a valid supported number", global.thread, cache);
+ controller_entry_setting_read_print_error_with_range(is_entry, &global.main->program.error, " has an invalid user", cache->content_actions.array[i].array[0], ", because the given ID is not a valid supported number", global.thread, cache);
}
else {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "controller_get_id_user", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "controller_get_id_user", F_true, global.thread);
}
continue;
status = controller_entry_settings_read_map(cache->buffer_file, cache->content_actions.array[i], &entry->define);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "controller_entry_settings_read_map", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "controller_entry_settings_read_map", F_true, global.thread);
continue;
}
status = controller_entry_settings_read_map(cache->buffer_file, cache->content_actions.array[i], &entry->parameter);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "controller_entry_settings_read_map", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "controller_entry_settings_read_map", F_true, global.thread);
continue;
}
status = f_rip_dynamic_partial_nulless(cache->buffer_file, cache->content_actions.array[i].array[0], &cache->action.generic);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true, global.thread);
continue;
}
status = controller_path_canonical_relative(global.setting, cache->action.generic, &global.setting->path_pid);
if (F_status_is_error(status)) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "controller_path_canonical_relative", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "controller_path_canonical_relative", F_true, global.thread);
continue;
}
*time = time_previous;
if (F_status_set_fine(status) == F_memory_not) {
- controller_entry_print_error(is_entry, global.main->program.error, cache->action, F_status_set_fine(status), "fl_conversion_dynamic_partial_to_unsigned_detect", F_true, global.thread);
+ controller_entry_print_error(is_entry, &global.main->program.error, cache->action, F_status_set_fine(status), "fl_conversion_dynamic_partial_to_unsigned_detect", F_true, global.thread);
continue;
}
for (i = 0; i < entry->items.used; ++i) {
- fl_print_format("%r%Q %Q %[%Q%] {%r", global.main->program.output.to, f_string_eol_s, is_entry ? controller_Entry_s : controller_Exit_s, controller_Item_s, global.main->program.context.set.title, entry->items.array[i].key, global.main->program.context.set.title, f_string_eol_s);
+ fl_print_format("%r%Q %Q %[%Q%] {%r", global.main->program.output.to, f_string_eol_s, is_entry ? controller_Entry_s : controller_Exit_s, controller_Item_s, global.main->program.context.set.title, entry->items.array[i].name, global.main->program.context.set.title, f_string_eol_s);
for (j = 0; j < entry->items.array[i].actions.used; ++j) {
}
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), content ? "f_memory_array_increase_by" : "f_memory_array_increase", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), content ? "f_memory_array_increase_by" : "f_memory_array_increase", F_true);
return status;
}
}
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), content ? "f_memory_array_increase_by" : "f_memory_array_increase", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), content ? "f_memory_array_increase_by" : "f_memory_array_increase", F_true);
return status;
}
status = f_string_dynamic_partial_append_nulless(buffer, *object, &action->parameters.array[0]);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true);
return status;
}
status = f_memory_array_increase_by(content->used, sizeof(f_string_dynamic_t), (void **) &action->parameters.array, &action->parameters.used, &action->parameters.size);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_memory_array_increase_by", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_memory_array_increase_by", F_true);
return status;
}
status = f_memory_array_increase_by(content->used, sizeof(f_iki_data_t), (void **) &action->ikis.array, &action->ikis.used, &action->ikis.size);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_memory_array_increase_by", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_memory_array_increase_by", F_true);
return status;
}
status = f_string_dynamic_partial_append_nulless(buffer, content->array[i], &action->parameters.array[action->parameters.used]);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true);
return status;
}
range.start = 0;
range.stop = action->parameters.array[action->parameters.used].used - 1;
- status = fl_iki_read(&action->parameters.array[action->parameters.used], &range, &action->ikis.array[action->ikis.used], state);
+ fl_iki_read(&action->parameters.array[action->parameters.used], &range, &action->ikis.array[action->ikis.used], state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "fl_iki_read", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "fl_iki_read", F_true);
action->parameters.array[action->parameters.used].used = 0;
cache->content_action.used = 0;
if (method == controller_rule_action_method_extended_list_e) {
- status = fl_fss_extended_list_content_read(cache->buffer_item, state, range, &cache->content_action, &cache->delimits, &cache->comments);
+ fl_fss_extended_list_content_read(cache->buffer_item, range, &cache->content_action, &cache->delimits, &cache->comments, &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "fl_fss_extended_list_content_read", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "fl_fss_extended_list_content_read", F_true);
return status;
}
if (status == F_fss_found_content) {
- status = f_fss_apply_delimit(state, cache->delimits, &cache->buffer_item);
+ f_fss_apply_delimit(cache->delimits, &cache->buffer_item, &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_fss_apply_delimit", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_fss_apply_delimit", F_true);
return status;
}
status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_string_dynamic_t), (void **) &actions->array[actions->used].parameters.array, &actions->array[actions->used].parameters.used, &actions->array[actions->used].parameters.size);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_memory_array_increase", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_memory_array_increase", F_true);
return status;
}
status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_iki_data_t), (void **) &actions->array[actions->used].ikis.array, &actions->array[actions->used].ikis.used, &actions->array[actions->used].ikis.size);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_memory_array_increase", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_memory_array_increase", F_true);
return status;
}
status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->content_action.array[0], &actions->array[actions->used].parameters.array[0]);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true);
actions->array[actions->used++].status = controller_status_simplify_error(F_status_set_fine(status));
f_range_t range_iki = macro_f_range_t_initialize_2(actions->array[actions->used].parameters.array[0].used);
- status = fl_iki_read(&actions->array[actions->used].parameters.array[0], &range_iki, &actions->array[actions->used].ikis.array[0], state);
+ fl_iki_read(&actions->array[actions->used].parameters.array[0], &range_iki, &actions->array[actions->used].ikis.array[0], &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "fl_iki_read", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "fl_iki_read", F_true);
actions->array[actions->used++].status = controller_status_simplify_error(F_status_set_fine(status));
cache->delimits.used = 0;
// The object_actions and content_actions caches are being used for the purposes of getting the parameters a given the action.
- status = fll_fss_extended_read(cache->buffer_item, state, &cache->content_action.array[0], &cache->object_actions, &cache->content_actions, 0, 0, &cache->delimits, 0);
+ fll_fss_extended_read(cache->buffer_item, &cache->content_action.array[0], &cache->object_actions, &cache->content_actions, 0, 0, &cache->delimits, 0, &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "fll_fss_extended_read", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "fll_fss_extended_read", F_true);
return status;
}
- status = f_fss_apply_delimit(state, cache->delimits, &cache->buffer_item);
+ f_fss_apply_delimit(cache->delimits, &cache->buffer_item, &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_fss_apply_delimit", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_fss_apply_delimit", F_true);
return status;
}
status = controller_rule_actions_increase_by(controller_common_allocation_small_d, actions);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "controller_rule_actions_increase_by", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "controller_rule_actions_increase_by", F_true);
return status;
}
- status = f_fss_count_lines(cache->buffer_item, cache->object_actions.array[i].start, &actions->array[actions->used].line, &setting->state);
+ f_fss_count_lines(cache->buffer_item, cache->object_actions.array[i].start, &actions->array[actions->used].line, &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_fss_count_lines", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_fss_count_lines", F_true);
return status;
}
actions->array[actions->used].line += ++item->line;
actions->array[actions->used].status = F_known_not;
- status = controller_rule_parameters_read(global, cache->buffer_item, state, &cache->object_actions.array[i], &cache->content_actions.array[i], &actions->array[actions->used]);
+ status = controller_rule_parameters_read(global, cache->buffer_item, &cache->object_actions.array[i], &cache->content_actions.array[i], &actions->array[actions->used], &state);
if (F_status_is_error(status)) {
actions->array[actions->used++].status = controller_status_simplify_error(F_status_set_fine(status));
}
}
else {
- status = fl_fss_extended_content_read(cache->buffer_item, state, range, &cache->content_action, 0, &cache->delimits);
+ fl_fss_extended_content_read(cache->buffer_item, range, &cache->content_action, 0, &cache->delimits, &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "fll_fss_extended_content_read", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "fll_fss_extended_content_read", F_true);
}
else if (status == F_fss_found_content) {
- status = f_fss_apply_delimit(state, cache->delimits, &cache->buffer_item);
+ f_fss_apply_delimit(cache->delimits, &cache->buffer_item, &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_fss_apply_delimit", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_fss_apply_delimit", F_true);
}
else if (type == controller_rule_action_type_pid_file_e) {
item->pid_file.used = 0;
status = f_rip_dynamic_partial(cache->buffer_item, cache->content_action.array[0], &item->pid_file);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_rip_dynamic_partial", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_rip_dynamic_partial", F_true);
}
}
else if (type == controller_rule_action_type_rerun_e) {
fl_print_format(f_string_format_r_single_s.string, global.main->program.error.to, global.main->program.error.notable, controller_thaw_s, global.main->program.error.notable, global.main->program.error.context);
fl_print_format(f_string_format_sentence_end_quote_s.string, global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_true);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_true);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
fl_print_format(f_string_format_r_single_s.string, global.main->program.error.to, global.main->program.error.notable, controller_thaw_s, global.main->program.error.notable, global.main->program.error.context);
fl_print_format(f_string_format_sentence_end_quote_s.string, global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_true);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_true);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
fl_print_format(f_string_format_Q_range_single_s.string, global.main->program.error.to, global.main->program.error.notable, cache->buffer_item, cache->content_action.array[i], global.main->program.error.notable);
fl_print_format(f_string_format_sentence_end_quote_s.string, global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_true);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_true);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
fl_print_format("%[' for rule item action '%]%[%r%]", global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, global.main->program.error.notable, controller_with_s, global.main->program.error.notable);
fl_print_format(f_string_format_sentence_end_quote_s.string, global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_true);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_true);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_string_dynamic_t), (void **) &actions->array[actions->used].parameters.array, &actions->array[actions->used].parameters.used, &actions->array[actions->used].parameters.size);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_memory_array_increase", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_memory_array_increase", F_true);
return status;
}
status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_iki_data_t), (void **) &actions->array[actions->used].ikis.array, &actions->array[actions->used].ikis.used, &actions->array[actions->used].ikis.size);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_memory_array_increase", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_memory_array_increase", F_true);
return status;
}
} // for
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_dynamic_partial_mash_nulless", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_dynamic_partial_mash_nulless", F_true);
actions->array[actions->used++].status = controller_status_simplify_error(F_status_set_fine(status));
f_range_t range_iki = macro_f_range_t_initialize_2(actions->array[actions->used].parameters.array[0].used);
- status = fl_iki_read(&actions->array[actions->used].parameters.array[0], &range_iki, &actions->array[actions->used].ikis.array[0], state);
+ fl_iki_read(&actions->array[actions->used].parameters.array[0], &range_iki, &actions->array[actions->used].ikis.array[0], &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "fl_iki_read", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "fl_iki_read", F_true);
actions->array[actions->used++].status = controller_status_simplify_error(F_status_set_fine(status));
actions->array[actions->used++].parameters.used = 1;
}
else {
- status = f_fss_count_lines(cache->buffer_item, range->start, &actions->array[actions->used].line, &setting->state);
+ f_fss_count_lines(cache->buffer_item, range->start, &actions->array[actions->used].line, &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_fss_count_lines", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_fss_count_lines", F_true);
return status;
}
actions->array[actions->used].line += ++item->line;
actions->array[actions->used].status = F_known_not;
- status = controller_rule_parameters_read(global, cache->buffer_item, state, 0, &cache->content_action, &actions->array[actions->used]);
+ status = controller_rule_parameters_read(global, cache->buffer_item, 0, &cache->content_action, &actions->array[actions->used], &state);
if (F_status_is_error(status)) {
actions->array[actions->used++].status = controller_status_simplify_error(F_status_set_fine(status));
fl_print_format("%r%[%QAction is empty, nothing to do.%]%r", global.main->program.warning.to, f_string_eol_s, global.main->program.warning.context, global.main->program.warning.prefix, global.main->program.warning.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.warning, cache->action, F_true);
+ controller_rule_print_error_cache(&global.main->program.warning, cache->action, F_true);
controller_unlock_print_flush(global.main->program.warning.to, global.thread);
}
status = F_status_set_fine(status);
if (status != F_valid_not && status != F_number && status != F_number_decimal && status != F_number_overflow && status != F_number_underflow && status != F_number_negative) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "fl_conversion_dynamic_partial_to_signed_detect", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "fl_conversion_dynamic_partial_to_signed_detect", F_true);
}
else {
controller_lock_print(global.main->program.error.to, global.thread);
}
}
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_true);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_true);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
destination->group = source.group;
destination->timestamp.seconds = source.timestamp.seconds;
- destination->timestamp.nanoseconds = source.timestamp.nanoseconds;
+ destination->timestamp.seconds_nano = source.timestamp.seconds_nano;
destination->alias.used = 0;
destination->engine.used = 0;
destination->ons.used = source.ons.used;
}
- status = f_int32s_append_all(source.affinity, &destination->affinity);
+ status = f_memory_array_append_all(source.affinity.array, source.affinity.used, sizeof(int32_t), (void **) &destination->affinity.array, &destination->affinity.used, &destination->affinity.size);
if (F_status_is_error(status)) return status;
if (source.capability) {
status = f_control_group_copy(source.cgroup, &destination->cgroup);
if (F_status_is_error(status)) return status;
- status = f_int32s_append_all(source.groups, &destination->groups);
+ status = f_memory_array_append_all(source.groups.array, source.groups.used, sizeof(int32_t), (void **) &destination->groups.array, &destination->groups.used, &destination->groups.size);
if (F_status_is_error(status)) return status;
destination->limits.used = 0;
- status = f_limit_sets_append_all(source.limits, &destination->limits);
+ status = f_memory_array_append_all(source.limits.array, source.limits.used, sizeof(f_limit_set_t), (void **) &destination->limits.array, &destination->limits.used, &destination->limits.size);
if (F_status_is_error(status)) return status;
if (source.items.used) {
status = fll_control_group_prepare(process->rule.cgroup);
if (F_status_is_error(status)) {
- controller_print_error_file(global.thread, global.main->program.error, F_status_set_fine(status), "fll_control_group_prepare", F_true, process->rule.cgroup.path, controller_rule_print_control_groups_prepare_s, fll_error_file_type_directory_e);
+ controller_print_error_file(global.thread, &global.main->program.error, F_status_set_fine(status), "fll_control_group_prepare", F_true, process->rule.cgroup.path, controller_rule_print_control_groups_prepare_s, fll_error_file_type_directory_e);
return status;
}
status = fl_environment_load_names(process->rule.environment, &environment);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "fl_environment_load_names", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "fl_environment_load_names", F_true);
return status;
}
for (k = 0; k < environment.used; ++k) {
- if (f_compare_dynamic(entry->define.array[i].key, environment.array[k].name) == F_equal_to) {
+ if (f_compare_dynamic(entry->define.array[i].key, environment.array[k].key) == F_equal_to) {
environment.array[k].value.used = 0;
status = f_string_dynamic_append(entry->define.array[i].value, &environment.array[k].value);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append", F_true);
return status;
}
status = f_string_maps_append(entry->define.array[i], &environment);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_maps_append", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_maps_append", F_true);
return status;
}
for (k = 0; k < environment.used; ++k) {
- if (f_compare_dynamic(process->rule.define.array[i].key, environment.array[k].name) == F_equal_to) {
+ if (f_compare_dynamic(process->rule.define.array[i].key, environment.array[k].key) == F_equal_to) {
environment.array[k].value.used = 0;
status = f_string_dynamic_append(process->rule.define.array[i].value, &environment.array[k].value);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append", F_true);
return status;
}
status = f_string_maps_append(process->rule.define.array[i], &environment);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_maps_append", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_maps_append", F_true);
return status;
}
status = f_environment_get_all(&environment);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_environment_get_all", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_environment_get_all", F_true);
return status;
}
status = f_string_maps_append(entry->define.array[i], &environment);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_maps_append", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_maps_append", F_true);
return status;
}
status = f_string_maps_append(process->rule.define.array[i], &environment);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_maps_append", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_maps_append", F_true);
return status;
}
status = controller_rule_expand(global, process->rule.items.array[i].actions.array[j], process);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, process->cache.action, F_status_set_fine(status), "controller_rule_expand", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, process->cache.action, F_status_set_fine(status), "controller_rule_expand", F_true, F_false);
break;
}
status = controller_rule_expand(global, process->rule.items.array[i].actions.array[j], process);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, process->cache.action, F_status_set_fine(status), "controller_rule_expand", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, process->cache.action, F_status_set_fine(status), "controller_rule_expand", F_true, F_false);
break;
}
status = controller_rule_expand(global, process->rule.items.array[i].actions.array[j], process);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, process->cache.action, F_status_set_fine(status), "controller_rule_expand", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, process->cache.action, F_status_set_fine(status), "controller_rule_expand", F_true, F_false);
break;
}
else {
success = F_status_set_error(F_failure);
- controller_rule_action_print_error_missing_pid(global.main->program.error, process->rule.alias);
+ controller_rule_action_print_error_missing_pid(&global.main->program.error, process->rule.alias);
}
}
else if (process->rule.items.array[i].type == controller_rule_item_type_utility_e) {
status = controller_rule_expand(global, process->rule.items.array[i].actions.array[j], process);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, process->cache.action, F_status_set_fine(status), "controller_rule_expand", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, process->cache.action, F_status_set_fine(status), "controller_rule_expand", F_true, F_false);
break;
}
else {
success = F_status_set_error(F_failure);
- controller_rule_action_print_error_missing_pid(global.main->program.error, process->rule.alias);
+ controller_rule_action_print_error_missing_pid(&global.main->program.error, process->rule.alias);
}
}
else {
fl_print_format("%r%[%QAction type is unknown, ignoring.%]%r", global.main->program.warning.to, f_string_eol_s, global.main->program.warning.context, global.main->program.warning.prefix, global.main->program.warning.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.warning, process->cache.action, F_true);
+ controller_rule_print_error_cache(&global.main->program.warning, process->cache.action, F_true);
controller_unlock_print_flush(global.main->program.warning.to, global.thread);
}
}
} // for
- macro_f_string_maps_t_delete_simple(environment);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &environment.array, &environment.used, &environment.size, &f_string_maps_delete_callback);
// Lock failed, attempt to re-establish lock before returning.
if (F_status_set_fine(status) == F_lock) {
status = controller_pids_increase(&process->childs);
if (F_status_is_error(status)) {
- controller_print_error(thread, main->program.error, F_status_set_fine(status), "controller_pids_increase", F_true);
+ controller_print_error(thread, &main->program.error, F_status_set_fine(status), "controller_pids_increase", F_true);
return status;
}
controller_rule_item_print_error_execute(type == controller_rule_item_type_script_e, program.used ? program : arguments.array[0], status, process);
}
else {
- controller_print_error(thread, main->program.error, F_status_set_fine(status), "fll_execute_program", F_true);
+ controller_print_error(thread, &main->program.error, F_status_set_fine(status), "fll_execute_program", F_true);
}
status = F_status_set_error(status);
status = controller_pids_increase(&process->childs);
if (F_status_is_error(status)) {
- controller_print_error(thread, main->program.error, F_status_set_fine(status), "controller_pids_increase", F_true);
+ controller_print_error(thread, &main->program.error, F_status_set_fine(status), "controller_pids_increase", F_true);
return status;
}
status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_string_dynamic_t), (void **) &process->path_pids.array, &process->path_pids.used, &process->path_pids.size);
if (F_status_is_error(status)) {
- controller_print_error(thread, main->program.error, F_status_set_fine(status), "f_memory_array_increase", F_true);
+ controller_print_error(thread, &main->program.error, F_status_set_fine(status), "f_memory_array_increase", F_true);
return status;
}
status = f_file_exists(pid_file, F_true);
if (F_status_is_error(status)) {
- controller_print_error_file(thread, main->program.error, F_status_set_fine(status), "f_file_exists", F_true, pid_file, f_file_operation_find_s, fll_error_file_type_file_e);
+ controller_print_error_file(thread, &main->program.error, F_status_set_fine(status), "f_file_exists", F_true, pid_file, f_file_operation_find_s, fll_error_file_type_file_e);
return status;
}
if (status == F_true) {
- controller_print_error_file(thread, main->program.error, F_file_found, "f_file_exists", F_true, pid_file, f_file_operation_find_s, fll_error_file_type_file_e);
+ controller_print_error_file(thread, &main->program.error, F_file_found, "f_file_exists", F_true, pid_file, f_file_operation_find_s, fll_error_file_type_file_e);
return F_status_set_error(F_file_found);
}
status = f_string_dynamic_append_nulless(pid_file, child_pid_file);
if (F_status_is_error(status)) {
- controller_print_error(thread, main->program.error, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true);
+ controller_print_error(thread, &main->program.error, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true);
return status;
}
controller_rule_item_print_error_execute(type == controller_rule_item_type_utility_e, program.used ? program : arguments.array[0], status, process);
}
else {
- controller_print_error(thread, main->program.error, F_status_set_fine(status), "fll_execute_program", F_true);
+ controller_print_error(thread, &main->program.error, F_status_set_fine(status), "fll_execute_program", F_true);
}
return F_status_set_error(status);
}
}
else if (f_compare_dynamic_partial_string(controller_program_s.string, source, controller_program_s.used, vocabulary) == F_equal_to) {
- f_string_static_t * const argv = ((controller_main_t *) process->main_data)->parameters.arguments.array;
- f_console_parameters_t * const parameters = &((controller_main_t *) process->main_data)->parameters;
+ f_string_static_t * const argv = ((controller_main_t *) process->main_data)->program.parameters.arguments.array;
+ f_console_parameters_t * const parameters = &((controller_main_t *) process->main_data)->program.parameters;
const f_string_static_t options[] = {
f_console_standard_long_light_s,
status = f_string_dynamic_partial_append_nulless(source, directory, alias);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true);
return status;
}
status = f_string_dynamic_append(f_path_separator_s, alias);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append", F_true);
return status;
}
status = f_string_dynamic_partial_append_nulless(source, basename, alias);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true);
return status;
}
for (; range.start < cache->buffer_item.used && range.start <= range.stop; last = range.start, cache->delimits.used = 0, cache->comments.used = 0) {
- status = fl_fss_extended_list_object_read(cache->buffer_item, state, &range, &cache->range_action, &cache->delimits);
+ fl_fss_extended_list_object_read(cache->buffer_item, &range, &cache->range_action, &cache->delimits, &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "fl_fss_extended_list_object_read", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "fl_fss_extended_list_object_read", F_true);
break;
}
cache->delimits.used = 0;
// The current line is not an Extended List object, so the next possibility is a Basic List (and Extended List, both use the same Object structure).
- fl_fss_extended_object_read(cache->buffer_item, &range, &cache->range_action, 0, &cache->delimits, state);
+ fl_fss_extended_object_read(cache->buffer_item, &range, &cache->range_action, 0, &cache->delimits, &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "fl_fss_extended_object_read", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "fl_fss_extended_object_read", F_true);
break;
}
if (status != F_fss_found_object) continue;
}
- status = f_fss_apply_delimit(state, cache->delimits, &cache->buffer_item);
+ f_fss_apply_delimit(cache->delimits, &cache->buffer_item, &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_fss_apply_delimit", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_fss_apply_delimit", F_true);
break;
}
- status = f_fss_count_lines(cache->buffer_item, cache->range_action.start, &cache->action.line_action, &setting->state);
+ f_fss_count_lines(cache->buffer_item, cache->range_action.start, &cache->action.line_action, &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_fss_count_lines", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_fss_count_lines", F_true);
break;
}
status = f_rip_dynamic_partial_nulless(cache->buffer_item, cache->range_action, &cache->action.name_action);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true);
break;
}
fl_print_format(f_string_format_Q_single_s.string, global.main->program.warning.to, global.main->program.warning.notable, cache->action.name_action, global.main->program.warning.notable);
fl_print_format(f_string_format_sentence_end_quote_s.string, global.main->program.warning.to, global.main->program.warning.context, global.main->program.warning.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.warning, cache->action, F_true);
+ controller_rule_print_error_cache(&global.main->program.warning, cache->action, F_true);
controller_unlock_print_flush(global.main->program.warning.to, global.thread);
}
status = controller_rule_actions_increase_by(controller_common_allocation_small_d, &item->actions);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "controller_rule_actions_increase_by", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "controller_rule_actions_increase_by", F_true);
break;
}
fl_print_format(f_string_format_r_single_s.string, global.main->program.error.to, global.main->program.error.notable, controller_rule_action_type_name(process->action), global.main->program.error.notable);
fl_print_format("%[' while attempting to execute rule.%]%r", global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.error, process->cache.action, F_true);
+ controller_rule_print_error_cache(&global.main->program.error, process->cache.action, F_true);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
}
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, process->cache.action, F_status_set_fine(status), "f_string_dynamic_append", F_true, F_true);
+ controller_rule_print_error(global.thread, &global.main->program.error, process->cache.action, F_status_set_fine(status), "f_string_dynamic_append", F_true, F_true);
return status;
}
status = f_string_dynamic_append(process->rule.alias, &process->cache.action.name_file);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, process->cache.action, F_status_set_fine(status), "f_string_dynamic_append", F_true, F_true);
+ controller_rule_print_error(global.thread, &global.main->program.error, process->cache.action, F_status_set_fine(status), "f_string_dynamic_append", F_true, F_true);
return status;
}
}
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, process->cache.action, F_status_set_fine(status), "f_string_dynamic_append", F_true, F_true);
+ controller_rule_print_error(global.thread, &global.main->program.error, process->cache.action, F_status_set_fine(status), "f_string_dynamic_append", F_true, F_true);
return status;
}
status_lock = controller_lock_read_process(process, global.thread, &global.thread->lock.process);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
}
else {
status = controller_process_prepare_process_type(global, process->type, process->action, dynamics[i]->array[j], &id_dependency);
if (global.main->program.error.verbosity > f_console_verbosity_quiet_e) {
controller_lock_print(global.main->program.error.to, global.thread);
- controller_rule_item_print_error_rule_not_loaded(global.main->program.error, dynamics[i]->array[j]);
- controller_rule_print_error_cache(global.main->program.error, process->cache.action, F_false);
+ controller_rule_item_print_error_rule_not_loaded(&global.main->program.error, dynamics[i]->array[j]);
+ controller_rule_print_error_cache(&global.main->program.error, process->cache.action, F_false);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
status_lock = controller_lock_read_process(process, global.thread, &dependency->active);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
status = F_false;
dependency = 0;
status_lock = controller_lock_read_process(process, global.thread, &global.thread->lock.rule);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
status = F_false;
}
if (i == 0) {
controller_lock_print(global.main->program.error.to, global.thread);
- controller_rule_item_print_error_need_want_wish(global.main->program.error, strings[i], dynamics[i]->array[j], "is not found");
- controller_rule_print_error_cache(global.main->program.error, process->cache.action, F_true);
+ controller_rule_item_print_error_need_want_wish(&global.main->program.error, strings[i], dynamics[i]->array[j], "is not found");
+ controller_rule_print_error_cache(&global.main->program.error, process->cache.action, F_true);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
if (global.main->program.warning.verbosity == f_console_verbosity_debug_e) {
controller_lock_print(global.main->program.warning.to, global.thread);
- controller_rule_item_print_error_need_want_wish(global.main->program.warning, strings[i], dynamics[i]->array[j], "is not found");
+ controller_rule_item_print_error_need_want_wish(&global.main->program.warning, strings[i], dynamics[i]->array[j], "is not found");
- controller_rule_print_error_cache(global.main->program.warning, process->cache.action, F_true);
+ controller_rule_print_error_cache(&global.main->program.warning, process->cache.action, F_true);
controller_unlock_print_flush(global.main->program.warning.to, global.thread);
}
status_lock = controller_lock_read_process(process, global.thread, &global.thread->lock.rule);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
found = F_false;
status = status_lock;
status_lock = controller_lock_read_process(process, global.thread, &dependency->lock);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
status = status_lock;
}
status_lock = controller_lock_read_process(process, global.thread, &global.thread->lock.rule);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
f_thread_unlock(&dependency->lock);
if (i == 0 || i == 1 || F_status_set_fine(status) == F_memory_not) {
controller_lock_print(global.main->program.error.to, global.thread);
- controller_rule_item_print_error_need_want_wish(global.main->program.error, strings[i], alias_other_buffer, "failed during execution");
- controller_rule_print_error_cache(global.main->program.error, process->cache.action, F_true);
+ controller_rule_item_print_error_need_want_wish(&global.main->program.error, strings[i], alias_other_buffer, "failed during execution");
+ controller_rule_print_error_cache(&global.main->program.error, process->cache.action, F_true);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
if (global.main->program.warning.verbosity == f_console_verbosity_debug_e) {
controller_lock_print(global.main->program.warning.to, global.thread);
- controller_rule_item_print_error_need_want_wish(global.main->program.warning, strings[i], alias_other_buffer, "failed during execution");
+ controller_rule_item_print_error_need_want_wish(&global.main->program.warning, strings[i], alias_other_buffer, "failed during execution");
- controller_rule_print_error_cache(global.main->program.warning, process->cache.action, F_true);
+ controller_rule_print_error_cache(&global.main->program.warning, process->cache.action, F_true);
controller_unlock_print_flush(global.main->program.warning.to, global.thread);
}
status_lock = controller_lock_read_process(process, global.thread, &global.thread->lock.rule);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
}
}
if (F_status_is_error(status_lock)) {
if (F_status_is_error(status_lock)) {
- controller_rule_item_print_error_need_want_wish(global.main->program.error, strings[i], alias_other_buffer, "due to lock failure");
+ controller_rule_item_print_error_need_want_wish(&global.main->program.error, strings[i], alias_other_buffer, "due to lock failure");
}
status = status_lock;
if (i == 0 || i == 1) {
controller_lock_print(global.main->program.error.to, global.thread);
- controller_rule_item_print_error_need_want_wish(global.main->program.error, strings[i], alias_other_buffer, "is in a failed state");
+ controller_rule_item_print_error_need_want_wish(&global.main->program.error, strings[i], alias_other_buffer, "is in a failed state");
- controller_rule_print_error_cache(global.main->program.error, process->cache.action, F_true);
+ controller_rule_print_error_cache(&global.main->program.error, process->cache.action, F_true);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
if (global.main->program.warning.verbosity == f_console_verbosity_debug_e) {
controller_lock_print(global.main->program.warning.to, global.thread);
- controller_rule_item_print_error_need_want_wish(global.main->program.warning, strings[i], alias_other_buffer, "is in a failed state");
+ controller_rule_item_print_error_need_want_wish(&global.main->program.warning, strings[i], alias_other_buffer, "is in a failed state");
- controller_rule_print_error_cache(global.main->program.warning, process->cache.action, F_true);
+ controller_rule_print_error_cache(&global.main->program.warning, process->cache.action, F_true);
controller_unlock_print_flush(global.main->program.warning.to, global.thread);
}
}
if ((process->options & controller_process_option_wait_d) && F_status_is_error_not(status) && (process->options & controller_process_option_validate_d)) {
- status_lock = controller_rule_wait_all_process_type(global, process->type, F_false, process);
+ status_lock = controller_rule_wait_all_process_type(global, process->type, F_false);
if (F_status_set_fine(status_lock) == F_interrupt) {
return status_lock;
fl_print_format("%[') to execute.%]%r", global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
}
- controller_rule_print_error_cache(global.main->program.error, process->cache.action, F_true);
+ controller_rule_print_error_cache(&global.main->program.error, process->cache.action, F_true);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
}
if (F_status_is_error(status)) {
- controller_rule_item_print_error(global.thread, global.main->program.error, process->cache.action, F_true, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, process->cache.action, F_true, F_status_set_fine(status));
}
}
}
status_lock = controller_lock_write_process(process, global.thread, &process->lock);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
if (F_status_set_fine(status) != F_interrupt) {
status = controller_lock_read_process(process, global.thread, &process->lock);
status_lock = controller_lock_write_process(process, global.thread, &global.thread->lock.rule);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
f_thread_unlock(&process->lock);
status_lock = controller_lock_read_process(process, global.thread, &process->lock);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
return F_status_set_error(F_lock);
}
status = controller_lock_read_process_type(type, global.thread, &global.thread->lock.process);
if (F_status_is_error(status)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status), F_true, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status), F_true, global.thread);
return status;
}
if (global.main->program.error.verbosity > f_console_verbosity_quiet_e) {
controller_lock_print(global.main->program.error.to, global.thread);
- controller_rule_item_print_error_rule_not_loaded(global.main->program.error, alias_rule);
- controller_rule_print_error_cache(global.main->program.error, cache.action, F_false);
+ controller_rule_item_print_error_rule_not_loaded(&global.main->program.error, alias_rule);
+ controller_rule_print_error_cache(&global.main->program.error, cache.action, F_false);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
status = controller_lock_read_process_type(type, global.thread, &process->active);
if (F_status_is_error(status)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status), F_true, global.thread);
- controller_rule_item_print_error(global.thread, global.main->program.error, cache.action, F_false, F_status_set_fine(status));
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status), F_true, global.thread);
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache.action, F_false, F_status_set_fine(status));
f_thread_unlock(&global.thread->lock.process);
status_lock = controller_lock_write_process(process, global.thread, &process->lock);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
f_thread_unlock(&process->active);
f_thread_unlock(&global.thread->lock.process);
status_lock = controller_lock_write_process(process, global.thread, &process->lock);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
f_thread_unlock(&process->active);
}
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_memory_array_resize", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_memory_array_resize", F_true);
}
else {
for (f_number_unsigned_t i = 0; i < stack.used; ++i) {
status = f_string_dynamic_append(cache.action.name_item, &process->cache.action.name_item);
}
else {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append", F_true);
}
}
}
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_thread_create", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_thread_create", F_true);
}
}
else {
status_lock = controller_lock_write_process(process, global.thread, &process->lock);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
f_thread_unlock(&process->active);
status_lock = controller_lock_read_process(process, global.thread, &process->active);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
return status_lock;
}
status_lock = controller_lock_read_process(process, global.thread, &process->lock);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
if (options_force & controller_process_option_asynchronous_d) {
f_thread_unlock(&process->active);
status_lock = controller_lock_read_process(process, global.thread, &global.thread->lock.rule);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
f_thread_unlock(&process->lock);
status_lock = controller_lock_write_process(process, global.thread, &process->lock);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
f_thread_unlock(&global.thread->lock.rule);
status_lock = controller_lock_read_process(process, global.thread, &process->lock);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
f_thread_unlock(&global.thread->lock.rule);
f_thread_unlock(&global.thread->lock.rule);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "controller_rule_copy", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "controller_rule_copy", F_true);
}
else if (!process->action) {
fl_print_format(f_string_format_Q_single_s.string, global.main->program.error.to, global.main->program.error.notable, process->rule.alias, global.main->program.error.notable);
fl_print_format("%[' is already on the execution dependency stack, this recursion is prohibited.%]%r", global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.error, process->cache.action, F_true);
+ controller_rule_print_error_cache(&global.main->program.error, process->cache.action, F_true);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_number_unsigned_t), (void **) &process->stack.array, &process->stack.used, &process->stack.size);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_memory_array_increase", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_memory_array_increase", F_true);
}
else {
f_thread_unlock(&process->lock);
status_lock = controller_lock_write_process(process, global.thread, &process->lock);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
if (options_force & controller_process_option_asynchronous_d) {
f_thread_unlock(&process->active);
status_lock = controller_lock_read_process(process, global.thread, &process->lock);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
if (options_force & controller_process_option_asynchronous_d) {
f_thread_unlock(&process->active);
if (global.main->program.error.verbosity > f_console_verbosity_quiet_e) {
controller_lock_print(global.main->program.error.to, global.thread);
- controller_rule_item_print_error_rule_not_loaded(global.main->program.error, process->rule.alias);
- controller_rule_print_error_cache(global.main->program.error, process->cache.action, F_false);
+ controller_rule_item_print_error_rule_not_loaded(&global.main->program.error, process->rule.alias);
+ controller_rule_print_error_cache(&global.main->program.error, process->cache.action, F_false);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
status_lock = controller_lock_write_process(process, global.thread, &global.thread->lock.rule);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
if (F_status_set_fine(status) != F_lock) {
f_thread_unlock(&process->lock);
status_lock = controller_lock_write_process(process, global.thread, &process->lock);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
if (options_force & controller_process_option_asynchronous_d) {
f_thread_unlock(&process->active);
status = f_string_dynamic_append_nulless(alias, &rule->alias);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_dynamic_append_nulless", F_true);
}
else {
status = controller_file_load(global, F_true, controller_rules_s, rule->alias, controller_rule_s, cache);
f_state_t state = macro_f_state_t_initialize_1(controller_common_allocation_large_d, controller_common_allocation_small_d, F_okay, 0, 0, 0, &controller_thread_signal_state_fss, 0, (void *) &custom, 0);
f_range_t range = macro_f_range_t_initialize_2(cache->buffer_file.used);
- status = fll_fss_basic_list_read(cache->buffer_file, state, &range, &cache->object_items, &cache->content_items, &cache->delimits, 0, &cache->comments);
+ fll_fss_basic_list_read(cache->buffer_file, &range, &cache->object_items, &cache->content_items, &cache->delimits, 0, &cache->comments, &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "fll_fss_basic_list_read", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "fll_fss_basic_list_read", F_true);
}
else {
- status = f_fss_apply_delimit(state, cache->delimits, &cache->buffer_file);
+ f_fss_apply_delimit(cache->delimits, &cache->buffer_file, &state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_fss_apply_delimit", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_fss_apply_delimit", F_true);
}
}
}
status = controller_rule_items_increase_by(cache->object_items.used, &rule->items);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "controller_rule_items_increase_by", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "controller_rule_items_increase_by", F_true);
}
else {
f_number_unsigned_t i = 0;
for_item = F_true;
- status = f_fss_count_lines(cache->buffer_file, cache->object_items.array[i].start, &cache->action.line_item, &global.main->setting.state);
+ f_fss_count_lines(cache->buffer_file, cache->object_items.array[i].start, &cache->action.line_item, &global.main->setting.state);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_fss_count_lines", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_fss_count_lines", F_true);
break;
}
status = f_rip_dynamic_partial_nulless(cache->buffer_file, cache->object_items.array[i], &cache->action.name_item);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true);
break;
}
fl_print_format(f_string_format_Q_single_s.string, global.main->program.warning.to, global.main->program.warning.notable, cache->action.name_item, global.main->program.warning.notable);
fl_print_format(f_string_format_sentence_end_quote_s.string, global.main->program.warning.to, global.main->program.warning.context, global.main->program.warning.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.warning, cache->action, F_true);
+ controller_rule_print_error_cache(&global.main->program.warning, cache->action, F_true);
controller_unlock_print_flush(global.main->program.warning.to, global.thread);
}
status = f_string_dynamic_partial_append(cache->buffer_file, cache->content_items.array[i].array[0], &cache->buffer_item);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_string_dynamic_partial_append", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_string_dynamic_partial_append", F_true);
break;
}
}
if (F_status_is_error(status)) {
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, for_item, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, for_item, F_status_set_fine(status));
rule->status[0] = controller_status_simplify_error(F_status_set_fine(status));
controller_state_interrupt_t custom = macro_controller_state_interrupt_t_initialize_1(is_normal, global.thread);
f_state_t state = macro_f_state_t_initialize_1(controller_common_allocation_large_d, controller_common_allocation_small_d, F_okay, 0, 0, 0, &controller_thread_signal_state_fss, 0, (void *) &custom, 0);
- status = fll_fss_extended_read(cache->buffer_item, state, &range, &cache->object_actions, &cache->content_actions, 0, 0, &cache->delimits, 0);
+ fll_fss_extended_read(cache->buffer_item, &range, &cache->object_actions, &cache->content_actions, 0, 0, &cache->delimits, 0, &state);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "fll_fss_extended_read", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "fll_fss_extended_read", F_true, F_false);
return status;
}
status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->object_actions.array[i], &cache->action.name_item);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
if (F_status_set_fine(status) == F_memory_not) {
status_return = status;
cache->action.line_action = ++cache->action.line_item;
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
continue;
}
fl_print_format(f_string_format_Q_single_s.string, global.main->program.warning.to, global.main->program.warning.notable, cache->action.name_item, global.main->program.warning.notable);
fl_print_format(f_string_format_sentence_end_quote_s.string, global.main->program.warning.to, global.main->program.warning.context, global.main->program.warning.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.warning, cache->action, F_false);
+ controller_rule_print_error_cache(&global.main->program.warning, cache->action, F_false);
controller_unlock_print_flush(global.main->program.warning.to, global.thread);
}
status = f_string_dynamic_partial_append_nulless(cache->buffer_item, range2, &cache->action.name_action);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
// Get the current line number within the settings item.
cache->action.line_item = line_item;
cache->action.line_action = ++cache->action.line_item;
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
if (F_status_set_fine(status) == F_memory_not) {
status_return = status;
fl_print_format("%r%[%QEmpty rule setting.%]%r", global.main->program.warning.to, f_string_eol_s, global.main->program.warning.context, global.main->program.warning.prefix, global.main->program.warning.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.warning, cache->action, F_false);
+ controller_rule_print_error_cache(&global.main->program.warning, cache->action, F_false);
controller_unlock_print_flush(global.main->program.warning.to, global.thread);
}
if (type == controller_rule_setting_type_affinity_e) {
if (!cache->content_actions.array[i].used) {
- controller_rule_setting_read_print_error(global.main->program.error, "requires one or more Content", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error(&global.main->program.error, "requires one or more Content", i, line_item, global.thread, cache);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
for (j = 0; j < cache->content_actions.array[i].used; ++j, number = 0) {
- status = f_int32s_increase(controller_common_allocation_small_d, &rule->affinity);
+ status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(int32_t), (void **) &rule->affinity.array, &rule->affinity.used, &rule->affinity.size);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_int32s_increase", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase", F_true, F_false);
break;
}
if (status == F_data_not || status == F_number || status == F_number_overflow || status == F_number_underflow || status == F_number_negative || status == F_number_decimal) {
if (status == F_number_underflow) {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an unsupported number", cache->content_actions.array[i].array[j], ", the number is too small for this system", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an unsupported number", cache->content_actions.array[i].array[j], ", the number is too small for this system", i, line_item, global.thread, cache);
}
else if (status == F_number_overflow || status == F_number_positive) {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an unsupported number", cache->content_actions.array[i].array[j], ", the number is too large for this system", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an unsupported number", cache->content_actions.array[i].array[j], ", the number is too large for this system", i, line_item, global.thread, cache);
}
else {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an invalid number", cache->content_actions.array[i].array[j], ", only whole numbers are allowed for an affinity value", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an invalid number", cache->content_actions.array[i].array[j], ", only whole numbers are allowed for an affinity value", i, line_item, global.thread, cache);
}
status = F_status_set_error(F_valid_not);
}
}
else {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "fl_conversion_dynamic_partial_to_signed_detect", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "fl_conversion_dynamic_partial_to_signed_detect", F_true, F_false);
status = F_status_set_error(status);
if (type == controller_rule_setting_type_define_e || type == controller_rule_setting_type_parameter_e) {
if (cache->content_actions.array[i].used != 2) {
- controller_rule_setting_read_print_error(global.main->program.error, "requires exactly two Content", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error(&global.main->program.error, "requires exactly two Content", i, line_item, global.thread, cache);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_string_map_t), (void **) &setting_maps->array, &setting_maps->used, &setting_maps->size);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase", F_true, F_false);
if (F_status_set_fine(status) == F_memory_not) {
status_return = status;
cache->action.line_action = ++cache->action.line_item;
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
continue;
}
- setting_maps->array[setting_maps->used].name.used = 0;
+ setting_maps->array[setting_maps->used].key.used = 0;
setting_maps->array[setting_maps->used].value.used = 0;
- status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->content_actions.array[i].array[0], &setting_maps->array[setting_maps->used].name);
+ status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->content_actions.array[i].array[0], &setting_maps->array[setting_maps->used].key);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
if (F_status_set_fine(status) == F_memory_not) {
status_return = status;
cache->action.line_action = ++cache->action.line_item;
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
continue;
}
status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->content_actions.array[i].array[1], &setting_maps->array[setting_maps->used].value);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
if (F_status_set_fine(status) == F_memory_not) {
status_return = status;
cache->action.line_action = ++cache->action.line_item;
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
continue;
}
if (type == controller_rule_setting_type_cgroup_e) {
if (cache->content_actions.array[i].used < 2 || rule->has & controller_rule_has_cgroup_d) {
- controller_rule_setting_read_print_error(global.main->program.error, "requires two or more Content", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error(&global.main->program.error, "requires two or more Content", i, line_item, global.thread, cache);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
rule->cgroup.as_new = F_true;
}
else {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an unknown option", cache->content_actions.array[i].array[0], "", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an unknown option", cache->content_actions.array[i].array[0], "", i, line_item, global.thread, cache);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
status = f_string_dynamic_append(global.setting->path_cgroup, &rule->cgroup.path);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_append", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_append", F_true, F_false);
}
else {
rule->cgroup.groups.used = 0;
status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_string_dynamic_t), (void **) &rule->cgroup.groups.array, &rule->cgroup.groups.used, &rule->cgroup.groups.size);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase", F_true, F_false);
break;
}
status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->content_actions.array[i].array[j], &rule->cgroup.groups.array[rule->cgroup.groups.used]);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
break;
}
cache->action.line_action = ++cache->action.line_item;
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
continue;
}
if (type == controller_rule_setting_type_limit_e) {
if (cache->content_actions.array[i].used != 3) {
- controller_rule_setting_read_print_error(global.main->program.error, "requires three Content", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error(&global.main->program.error, "requires three Content", i, line_item, global.thread, cache);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
fl_print_format(f_string_format_Q_single_s.string, global.main->program.error.to, global.main->program.error.notable, cache->action.name_action, global.main->program.error.notable);
fl_print_format(f_string_format_sentence_end_quote_s.string, global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_true);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_true);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
fl_print_format("%r%[%QThe resource limit type is already specified%]%r", global.main->program.error.to, f_string_eol_s, global.main->program.error.context, global.main->program.error.prefix, global.main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_false);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_false);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
if (F_status_is_error(status)) continue;
- macro_f_limit_sets_t_increase(status, controller_common_allocation_small_d, rule->limits);
+ status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_limit_set_t), (void **) &rule->limits.array, &rule->limits.used, &rule->limits.size);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_limit_sets_increase", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase", F_true, F_false);
if (F_status_set_fine(status) == F_memory_not) {
status_return = status;
cache->action.line_action = ++cache->action.line_item;
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
continue;
}
if (status == F_data_not || status == F_number || status == F_number_overflow || status == F_number_underflow || status == F_number_negative || status == F_number_positive || status == F_number_decimal) {
if (status == F_number_underflow) {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an unsupported number", cache->content_actions.array[i].array[j], ", the number is too small for this system", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an unsupported number", cache->content_actions.array[i].array[j], ", the number is too small for this system", i, line_item, global.thread, cache);
}
else if (status == F_number_overflow) {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an unsupported number", cache->content_actions.array[i].array[j], ", the number is too large for this system", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an unsupported number", cache->content_actions.array[i].array[j], ", the number is too large for this system", i, line_item, global.thread, cache);
}
else {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an unsupported number", cache->content_actions.array[i].array[j], ", only whole numbers are allowed for a resource limit value", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an unsupported number", cache->content_actions.array[i].array[j], ", only whole numbers are allowed for a resource limit value", i, line_item, global.thread, cache);
}
status = F_status_set_error(F_valid_not);
}
}
else {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "fl_conversion_dynamic_partial_to_signed_detect", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "fl_conversion_dynamic_partial_to_signed_detect", F_true, F_false);
status = F_status_set_error(status);
}
if (setting_value->used || !cache->content_actions.array[i].used) {
- controller_rule_setting_read_print_error(global.main->program.error, "requires one or more Content", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error(&global.main->program.error, "requires one or more Content", i, line_item, global.thread, cache);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
cache->action.line_action = ++cache->action.line_item;
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
continue;
}
fl_print_format(f_string_format_Q_single_s.string, global.main->program.error.to, global.main->program.error.notable, *setting_value, global.main->program.error.notable);
fl_print_format("%[', there must be at least 1 graph character.%]%r", global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_false);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_false);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
else {
// This function should only return F_complete_not_utf on error.
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_complete_not_utf, "controller_validate_has_graph", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_complete_not_utf, "controller_validate_has_graph", F_true, F_false);
if (F_status_is_error_not(status_return)) {
status_return = status;
}
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
}
setting_value->used = 0;
status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->content_actions.array[i].array[0], setting_value);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
if (F_status_set_fine(status) == F_memory_not) {
status_return = status;
cache->action.line_action = ++cache->action.line_item;
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
continue;
}
if (type == controller_rule_setting_type_scheduler_e) {
if (cache->content_actions.array[i].used < 1 || cache->content_actions.array[i].used > 2 || rule->has & controller_rule_has_scheduler_d) {
- controller_rule_setting_read_print_error(global.main->program.error, "requires either one or two Content", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error(&global.main->program.error, "requires either one or two Content", i, line_item, global.thread, cache);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
rule->scheduler.priority = 49;
}
else {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an unknown scheduler", cache->content_actions.array[i].array[0], "", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an unknown scheduler", cache->content_actions.array[i].array[0], "", i, line_item, global.thread, cache);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
fl_print_format(" allowed for the designated scheduler.%]%r", global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_false);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_false);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
}
}
else {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, status, "fl_conversion_dynamic_partial_to_signed_detect", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, status, "fl_conversion_dynamic_partial_to_signed_detect", F_true, F_false);
status = F_status_set_error(status);
if (F_status_is_error_not(status_return)) {
if (type == controller_rule_setting_type_timeout_e) {
if (cache->content_actions.array[i].used != 2) {
- controller_rule_setting_read_print_error(global.main->program.error, "requires exactly two Content", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error(&global.main->program.error, "requires exactly two Content", i, line_item, global.thread, cache);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
fl_print_format(f_string_format_Q_range_single_s.string, global.main->program.error.to, global.main->program.error.notable, cache->buffer_item, cache->content_actions.array[i].array[0], global.main->program.error.notable);
fl_print_format("%[' but only supports %r, %r, and %r.%]%r", global.main->program.error.to, global.main->program.error.context, controller_kill_s, controller_start_s, controller_stop_s, global.main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_false);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_false);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
status = F_status_set_fine(status);
if (status == F_number_overflow) {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an unsupported number", cache->content_actions.array[i].array[1], ", the number is too large for this system", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an unsupported number", cache->content_actions.array[i].array[1], ", the number is too large for this system", i, line_item, global.thread, cache);
}
else if (status == F_data_not || status == F_number || status == F_number_underflow || status == F_number_negative || status == F_number_positive || status == F_number_decimal) {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an invalid number", cache->content_actions.array[i].array[1], ", only positive whole numbers are allowed", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an invalid number", cache->content_actions.array[i].array[1], ", only positive whole numbers are allowed", i, line_item, global.thread, cache);
}
else {
cache->action.line_action = ++cache->action.line_item;
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, status, "fl_conversion_dynamic_partial_to_signed_detect", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, status, "fl_conversion_dynamic_partial_to_signed_detect", F_true, F_false);
}
if (F_status_is_error_not(status_return)) {
status = f_rip_dynamic_partial_nulless(cache->buffer_item, cache->content_actions.array[i].array[1], &cache->action.generic);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->program.error, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true);
+ controller_print_error(global.thread, &global.main->program.error, F_status_set_fine(status), "f_rip_dynamic_partial_nulless", F_true);
break;
}
if (type == controller_rule_setting_type_capability_e || type == controller_rule_setting_type_nice_e || type == controller_rule_setting_type_user_e) {
if (cache->content_actions.array[i].used != 1 || type == controller_rule_setting_type_capability_e && rule->capability || type == controller_rule_setting_type_group_e && (rule->has & controller_rule_has_group_d) || type == controller_rule_setting_type_nice_e && (rule->has & controller_rule_has_nice_d) || type == controller_rule_setting_type_user_e && (rule->has & controller_rule_has_user_d)) {
- controller_rule_setting_read_print_error(global.main->program.error, "requires exactly one Content", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error(&global.main->program.error, "requires exactly one Content", i, line_item, global.thread, cache);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
controller_lock_print(global.main->program.error.to, global.thread);
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_false);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_false);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
controller_lock_print(global.main->program.error.to, global.thread);
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_capability_from_text", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_capability_from_text", F_true, F_false);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_false);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_false);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
break;
}
- controller_rule_setting_read_print_error(global.main->program.error, "failed to process the capabilities", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error(&global.main->program.error, "failed to process the capabilities", i, line_item, global.thread, cache);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
fl_print_format("%[19%]", global.main->program.error.to, global.main->program.error.notable, global.main->program.error.notable);
fl_print_format(" %[are allowed.%]%r", global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_false);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_false);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
}
}
else {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, status, "fl_conversion_dynamic_partial_to_signed_detect", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, status, "fl_conversion_dynamic_partial_to_signed_detect", F_true, F_false);
status = F_status_set_error(status);
if (F_status_is_error_not(status_return)) {
controller_lock_print(global.main->program.error.to, global.thread);
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_false);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_false);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
status = F_status_set_fine(status);
if (status == F_exist_not) {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an invalid user", cache->content_actions.array[i].array[0], ", because no user was found by that name", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an invalid user", cache->content_actions.array[i].array[0], ", because no user was found by that name", i, line_item, global.thread, cache);
}
else if (status == F_number_too_large) {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an invalid user", cache->content_actions.array[i].array[0], ", because the given ID is too large", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an invalid user", cache->content_actions.array[i].array[0], ", because the given ID is too large", i, line_item, global.thread, cache);
}
else if (status == F_number) {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an invalid user", cache->content_actions.array[i].array[0], ", because the given ID is not a valid supported number", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an invalid user", cache->content_actions.array[i].array[0], ", because the given ID is not a valid supported number", i, line_item, global.thread, cache);
}
else {
cache->action.line_action = ++cache->action.line_item;
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, status, "controller_get_id_user", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, status, "controller_get_id_user", F_true, F_false);
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
}
if (F_status_is_error_not(status_return)) {
if (type == controller_rule_setting_type_group_e) {
if (!cache->content_actions.array[i].used) {
- controller_rule_setting_read_print_error(global.main->program.error, "requires one or more Content", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error(&global.main->program.error, "requires one or more Content", i, line_item, global.thread, cache);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
for (j = 0; j < cache->content_actions.array[i].used; ++j) {
- macro_f_int32s_t_increase_by(status, rule->groups, controller_common_allocation_small_d);
+ status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_int32s_t), (void **) &rule->groups.array, &rule->groups.used, &rule->groups.size);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "macro_f_number_unsigneds_t_increase_by", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase", F_true, F_false);
if (F_status_set_fine(status) == F_memory_not) {
status_return = status;
cache->action.line_action = ++cache->action.line_item;
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
continue;
}
status = F_status_set_fine(status);
if (status == F_exist_not) {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an invalid group", cache->content_actions.array[i].array[j], ", because no group was found by that name", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an invalid group", cache->content_actions.array[i].array[j], ", because no group was found by that name", i, line_item, global.thread, cache);
}
else if (status == F_number_too_large) {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an invalid group", cache->content_actions.array[i].array[j], ", because the given ID is too large", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an invalid group", cache->content_actions.array[i].array[j], ", because the given ID is too large", i, line_item, global.thread, cache);
}
else if (status == F_number) {
- controller_rule_setting_read_print_error_with_range(global.main->program.error, " has an invalid group", cache->content_actions.array[i].array[j], ", because the given ID is not a valid supported number", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error_with_range(&global.main->program.error, " has an invalid group", cache->content_actions.array[i].array[j], ", because the given ID is not a valid supported number", i, line_item, global.thread, cache);
}
else {
cache->action.line_action = ++cache->action.line_item;
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, status, "f_account_group_id_by_name", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, status, "f_account_group_id_by_name", F_true, F_false);
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
}
if (F_status_is_error_not(status_return)) {
for (j = 0; j < cache->content_actions.array[i].used; ++j) {
- status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_string_dynamic_t), (void **) &setting_values.array, &setting_values.used, &setting_values.size);
+ status = f_memory_array_increase(controller_common_allocation_small_d, sizeof(f_string_dynamic_t), (void **) &setting_values->array, &setting_values->used, &setting_values->size);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase", F_true, F_false);
if (F_status_set_fine(status) == F_memory_not) {
status_return = status;
cache->action.line_action = ++cache->action.line_item;
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
continue;
}
status = f_string_dynamic_partial_append_nulless(cache->buffer_item, cache->content_actions.array[i].array[j], &setting_values->array[setting_values->used]);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_string_dynamic_partial_append_nulless", F_true, F_false);
setting_values->array[setting_values->used].used = 0;
cache->action.line_action = ++cache->action.line_item;
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
continue;
}
fl_print_format(f_string_format_Q_single_s.string, global.main->program.error.to, global.main->program.error.notable, setting_values->array[setting_values->used], global.main->program.error.notable);
fl_print_format(f_string_format_sentence_end_quote_s.string, global.main->program.error.to, global.main->program.error.context, global.main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_false);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_false);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
else {
// This function should only return F_complete_not_utf on error.
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_complete_not_utf, "controller_validate_environment_name", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_complete_not_utf, "controller_validate_environment_name", F_true, F_false);
if (F_status_is_error_not(status_return)) {
status_return = status;
setting_values->array[setting_values->used].used = 0;
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
continue;
}
// The "on" Rule Setting.
if (cache->content_actions.array[i].used != 4) {
- controller_rule_setting_read_print_error(global.main->program.error, "requires exactly four Content", i, line_item, global.thread, cache);
+ controller_rule_setting_read_print_error(&global.main->program.error, "requires exactly four Content", i, line_item, global.thread, cache);
if (F_status_is_error_not(status_return)) {
status_return = F_status_set_error(F_valid_not);
fl_print_format("%[' but only supports %r, %r, %r, %r, %r", global.main->program.error.to, global.main->program.error.context, controller_freeze_s, controller_kill_s, controller_pause_s, controller_reload_s, controller_restart_s);
fl_print_format("%r, %r, %r, and %r.%]%r", global.main->program.error.to, controller_resume_s, controller_start_s, controller_stop_s, controller_thaw_s, global.main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_false);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_false);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
}
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "controller_rule_ons_increase", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "controller_rule_ons_increase", F_true, F_false);
}
else {
if (f_compare_dynamic_partial_string(controller_need_s.string, cache->buffer_item, controller_need_s.used, cache->content_actions.array[i].array[1]) == F_equal_to) {
fl_print_format(f_string_format_Q_range_single_s.string, global.main->program.error.to, global.main->program.error.notable, cache->buffer_item, cache->content_actions.array[i].array[1], global.main->program.error.notable);
fl_print_format("%[' but only supports %r, %r, and %r.%]%r", global.main->program.error.to, global.main->program.error.context, controller_need_s, controller_want_s, controller_wish_s, global.main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(global.main->program.error, cache->action, F_false);
+ controller_rule_print_error_cache(&global.main->program.error, cache->action, F_false);
controller_unlock_print_flush(global.main->program.error.to, global.thread);
}
status = f_memory_array_increase_by(controller_common_allocation_small_d, sizeof(f_string_dynamic_t), (void **) &setting_values->array, &setting_values->used, &setting_values->size);
if (F_status_is_error(status)) {
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase_by", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_memory_array_increase_by", F_true, F_false);
}
}
cache->action.line_action = ++cache->action.line_item;
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
continue;
}
cache->action.line_action = ++cache->action.line_item;
- controller_rule_item_print_error(global.thread, global.main->program.error, cache->action, F_false, F_status_set_fine(status));
+ controller_rule_item_print_error(global.thread, &global.main->program.error, cache->action, F_false, F_status_set_fine(status));
continue;
}
if (F_status_is_error(status)) {
setting_values->array[setting_values->used].used = 0;
- controller_rule_print_error(global.thread, global.main->program.error, cache->action, F_status_set_fine(status), "f_file_name_base", F_true, F_false);
+ controller_rule_print_error(global.thread, &global.main->program.error, cache->action, F_status_set_fine(status), "f_file_name_base", F_true, F_false);
if (F_status_set_fine(status) == F_memory_not) {
status_return = status;
#ifndef _di_controller_rule_validate_
void controller_rule_validate(const controller_global_t global, const controller_rule_t rule, const uint8_t action, const uint8_t options, controller_cache_t * const cache) {
- const controller_main_t *main = global.main;
+ controller_main_t * const main = global.main;
switch (action) {
case controller_rule_action_type_freeze_e:
fl_print_format(f_string_format_r_single_s.string, main->program.error.to, main->program.error.notable, controller_rule_action_type_name(action), main->program.error.notable);
fl_print_format("%[' while attempting to validate rule execution.%]%r", main->program.error.to, main->program.error.context, main->program.error.context, f_string_eol_s);
- controller_rule_print_error_cache(main->program.error, cache->action, F_true);
+ controller_rule_print_error_cache(&main->program.error, cache->action, F_true);
controller_unlock_print_flush(main->program.error.to, global.thread);
}
f_status_t status_lock = controller_lock_read(is_normal, global.thread, &global.thread->lock.process);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
return status_lock;
}
status_lock = controller_lock_write(is_normal, global.thread, &process_list[i]->lock);
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_false, global.thread);
f_thread_unlock(&process_list[i]->active);
} // for
if (F_status_is_error(status_lock)) {
- controller_lock_print_error_critical(global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
+ controller_lock_print_error_critical(&global.main->program.error, F_status_set_fine(status_lock), F_true, global.thread);
return status_lock;
}
projects / fll / commitdiff