These functions are already implemented in each of the level 3 programs.
The functions are pretty much identical.
Move the signal check logic into the `fll_program` project as `fll_program_signal_check_loop()` and `fll_program_signal_check_simple()`.
Update all of the programs, removing their variation and instead using one of these two.
Utilize a macro to call one or the other based on thread enabled state.
The fss_write payload is not calling the fss_write function and is instead using its own variation.
Replace that code with the macro as well.
Remove all stale and no longer needed signal check defines.
#define _di_fll_program_print_version_
#define _di_fll_program_s_a_
#define _di_fll_program_s_e_
+#define _di_fll_program_signal_check_loop_
+#define _di_fll_program_signal_check_simple_
+#define _di_fll_program_signal_d_
#define _di_fll_program_standard_set_down_
#define _di_fll_program_standard_set_up_
#define _di_fll_program_standard_signal_handle_
//#define _di_fll_program_print_version_
//#define _di_fll_program_s_a_
//#define _di_fll_program_s_e_
+//#define _di_fll_program_signal_check_loop_
+//#define _di_fll_program_signal_check_simple_
+//#define _di_fll_program_signal_d_
//#define _di_fll_program_standard_set_down_
//#define _di_fll_program_standard_set_up_
//#define _di_fll_program_standard_signal_handle_
//#define _di_fll_program_print_version_
//#define _di_fll_program_s_a_
//#define _di_fll_program_s_e_
+//#define _di_fll_program_signal_check_loop_
+//#define _di_fll_program_signal_check_simple_
+//#define _di_fll_program_signal_d_
//#define _di_fll_program_standard_set_down_
//#define _di_fll_program_standard_set_up_
//#define _di_fll_program_standard_signal_handle_
//#define _di_fll_program_print_version_
//#define _di_fll_program_s_a_
//#define _di_fll_program_s_e_
+//#define _di_fll_program_signal_check_loop_
+//#define _di_fll_program_signal_check_simple_
+//#define _di_fll_program_signal_d_
//#define _di_fll_program_standard_set_down_
//#define _di_fll_program_standard_set_up_
//#define _di_fll_program_standard_signal_handle_
//#define _di_fll_program_print_version_
//#define _di_fll_program_s_a_
//#define _di_fll_program_s_e_
+//#define _di_fll_program_signal_check_loop_
+//#define _di_fll_program_signal_check_simple_
+//#define _di_fll_program_signal_d_
//#define _di_fll_program_standard_set_down_
//#define _di_fll_program_standard_set_up_
//#define _di_fll_program_standard_signal_handle_
//#define _di_fll_program_print_version_
//#define _di_fll_program_s_a_
//#define _di_fll_program_s_e_
+//#define _di_fll_program_signal_check_loop_
+//#define _di_fll_program_signal_check_simple_
+//#define _di_fll_program_signal_d_
//#define _di_fll_program_standard_set_down_
//#define _di_fll_program_standard_set_up_
//#define _di_fll_program_standard_signal_handle_
}
#endif // !defined(_di_fll_program_print_help_option_) || !defined(_di_fll_program_print_help_option_standard_)
-#if !defined(_di_fll_program_standard_signal_received_) || !defined(_di_fll_program_standard_signal_handle_)
+#if !defined(_di_fll_program_signal_check_loop_) || !defined(_di_fll_program_standard_signal_received_) || !defined(_di_fll_program_standard_signal_handle_)
f_status_t private_fll_program_standard_signal_received(fll_program_data_t * const program) {
if (!program || program->signal.id == -1) return F_status_set_error(F_parameter);
return F_interrupt_not;
}
-#endif // !defined(_di_fll_program_standard_signal_received_) || !defined(_di_fll_program_standard_signal_handle_)
+#endif // !defined(_di_fll_program_signal_check_loop_) || !defined(_di_fll_program_standard_signal_received_) || !defined(_di_fll_program_standard_signal_handle_)
#if !defined(_di_fll_program_parameter_process_context_) || !defined(_di_fll_program_parameter_process_context_standard_) || !defined(_di_fll_program_parameter_process_empty_)
void private_fll_program_parameter_process_empty(f_color_context_t * const context, f_color_set_t * const sets[]) {
*
* @see f_signal_read()
*
+ * @see fll_program_signal_check_loop()
* @see fll_program_standard_signal_received()
* @see fll_program_standard_signal_handle()
*/
-#if !defined(_di_fll_program_standard_signal_received_) || !defined(_di_fll_program_standard_signal_handle_)
+#if !defined(_di_fll_program_signal_check_loop_) || !defined(_di_fll_program_standard_signal_received_) || !defined(_di_fll_program_standard_signal_handle_)
f_status_t private_fll_program_standard_signal_received(fll_program_data_t * const program) F_attribute_visibility_internal_d;
-#endif // !defined(_di_fll_program_standard_signal_received_) || !defined(_di_fll_program_standard_signal_handle_)
+#endif // !defined(_di_fll_program_signal_check_loop_) || !defined(_di_fll_program_standard_signal_received_) || !defined(_di_fll_program_standard_signal_handle_)
/**
* Private implementation of fll_program_parameter_process_empty().
}
#endif // _di_fll_program_parameter_additional_rip_mash_
+#ifndef _di_fll_program_signal_check_loop_
+ f_status_t fll_program_signal_check_loop(fll_program_data_t * const program, f_state_t * const state) {
+
+ if (!program) return F_false;
+
+ if (program->signal_received) {
+ if (state) {
+ state->status = F_status_set_error(F_interrupt);
+ }
+
+ return F_true;
+ }
+
+ if (!((++program->signal_check) % fll_program_signal_check_d)) {
+ if (F_status_set_fine(private_fll_program_standard_signal_received(program)) == F_interrupt) {
+ if (state) {
+ state->status = F_status_set_error(F_interrupt);
+ }
+
+ return F_true;
+ }
+
+ program->signal_check = 0;
+ }
+
+ return F_false;
+ }
+#endif // _di_fll_program_signal_check_loop_
+
+#ifndef _di_fll_program_signal_check_simple_
+ f_status_t fll_program_signal_check_simple(fll_program_data_t * const program, f_state_t * const state) {
+
+ if (program && program->signal_received) {
+ if (state) {
+ state->status = F_status_set_error(F_interrupt);
+ }
+
+ return F_true;
+ }
+
+ return F_false;
+ }
+#endif // _di_fll_program_signal_check_simple_
+
#ifndef _di_fll_program_standard_set_down_
f_status_t fll_program_standard_set_down(fll_program_data_t * const program) {
#ifndef _di_level_2_parameter_checking_
#endif // _di_fll_program_parameter_additional_rip_mash_
/**
+ * Check to see if a signal is received, using a loop..
+ *
+ * This checks if program.signal_received is non-zero and if so then it returns TRUE.
+ *
+ * There is ideal for use in a non-threaded build.
+ * This checks periodically using fll_program_standard_signal_received() and updates program.signal_check as needed.
+ *
+ * @param program
+ * The program data.
+ *
+ * This alters program.signal_check as needed.
+ * This does not alter program.signal_received.
+ *
+ * @param state
+ * The state data.
+ *
+ * If specified, then this alters state.status, setting it to F_status_set_error(F_interrupt) on interrupt.
+ *
+ * @return
+ * F_true on signal received.
+ * F_false otherwise (even when program is NULL).
+ *
+ * @see fll_program_standard_signal_received()
+ */
+#ifndef _di_fll_program_signal_check_loop_
+ extern f_status_t fll_program_signal_check_loop(fll_program_data_t * const program, f_state_t * const state);
+#endif // _di_fll_program_signal_check_loop_
+
+/**
+ * Check to see if a signal is received, using a simple check.
+ *
+ * There is ideal for use in a threaded build.
+ * The caller should have a thread that assigns the program.signal_received to some non-zero value for this to work.
+ *
+ * @param program
+ * The program data.
+ *
+ * This does not alter program.signal_check.
+ * This does not alter program.signal_received.
+ *
+ * @param state
+ * The state data.
+ *
+ * If specified, then this alters state.status, setting it to F_status_set_error(F_interrupt) on interrupt.
+ *
+ * @return
+ * F_true on signal received (when program.signal_received is non-zero).
+ * F_false otherwise (even when program is NULL).
+ */
+#ifndef _di_fll_program_signal_check_simple_
+ extern f_status_t fll_program_signal_check_simple(fll_program_data_t * const program, f_state_t * const state);
+#endif // _di_fll_program_signal_check_simple_
+
+/**
* This provides a standard program set down operations used by FLL programs.
*
* This does the following:
#endif // _di_fll_program_copyright_s_
/**
+ * A standard signal flags.
+ *
+ * fll_program_signal_*_d:
+ * - check: A for fll_program_signal_loop() for determining when to make the check.
+ */
+#ifndef _di_fll_program_signal_d_
+ #define fll_program_signal_check_d 500000
+#endif // _di_fll_program_signal_d_
+
+/**
* Program data pipe codes.
*
* These are bit-wise codes used to designate that a particular pipe exists and is to be used.
for (f_number_unsigned_t i = 0; i < main->setting.files.used; ++i) {
- if (byte_dump_signal_check(main)) break;
+ if (macro_byte_dump_signal_check(&main->program, &main->setting.state)) break;
if (!main->setting.files.array[i].used) continue;
main->setting.state.status = f_file_stream_open(main->setting.files.array[i], f_string_empty_s, &file);
for (index = 0; index < parameters->remaining.used; ++index) {
- if (byte_dump_signal_check(main)) return;
+ if (macro_byte_dump_signal_check(&main->program, &main->setting.state)) return;
number = parameters->remaining.array[index];
* The program signal defines.
*
* byte_dump_signal_*_d:
- * - check: Number of iterations before performing signal check in non-threaded signal handling.
* - check_failsafe: When using threads, how many consecutive failures to check signal before aborting (as a recursion failsafe).
- * - check_tiny: The tiny check.
- * - check_short: The short signal check.
*/
#ifndef _di_byte_dump_signal_d_
- #define byte_dump_signal_check_d 500000
#define byte_dump_signal_check_failsafe_d 20000
- #define byte_dump_signal_check_tiny_d 4
- #define byte_dump_signal_check_short_d 16
#endif // _di_byte_dump_signal_d_
+/**
+ * A macro wrapping the appropriate signal check function based on threaded/non-threaded support.
+ */
+#ifndef _di_byte_dump_signal_check_d_
+ #ifdef _di_thread_support_
+ #define macro_byte_dump_signal_check(program, state) fll_program_signal_check_loop(program, state)
+ #else
+ #define macro_byte_dump_signal_check(program, state) fll_program_signal_check_simple(program, state)
+ #endif // _di_thread_support_
+#endif // _di_byte_dump_signal_check_d_
+
#ifdef __cplusplus
} // extern "C"
#endif
byte_dump_setting_load(arguments, &data);
}
- if (!byte_dump_signal_check(&data)) {
+ if (!macro_byte_dump_signal_check(&data.program, &data.setting.state)) {
byte_dump_main(&data);
}
if (byte_get >= 0) {
for (;;) {
- if (byte_dump_signal_check(main)) return;
+ if (macro_byte_dump_signal_check(&main->program, &main->setting.state)) return;
byte_get = getc(file.stream);
extern "C" {
#endif
-#if !defined(_di_byte_dump_signal_check_) && defined(_di_thread_support_)
- f_status_t byte_dump_signal_check(byte_dump_main_t * const main) {
-
- if (!main) return F_false;
- if (main->program.signal_received) return F_true;
-
- if (!((++main->program.signal_check) % byte_dump_signal_check_d)) {
- if (F_status_set_fine(fll_program_standard_signal_received(&main->program)) == F_interrupt) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- main->program.signal_check = 0;
- }
-
- return F_false;
- }
-#endif // !defined(_di_byte_dump_signal_check_) && defined(_di_thread_support_)
-
-#if !defined(_di_byte_dump_signal_check_) && !defined(_di_thread_support_)
- f_status_t byte_dump_signal_check(byte_dump_main_t * const main) {
-
- if (!main) return F_false;
-
- if (main->program.signal_received) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- return F_false;
- }
-#endif // !defined(_di_byte_dump_signal_check_) && !defined(_di_thread_support_)
-
#if !defined(_di_byte_dump_signal_handler_) && !defined(_di_thread_support_)
void byte_dump_signal_handler(byte_dump_main_t * const main) {
#endif
/**
- * Check to see if a signal is received.
- *
- * If main.signal is non-zero, then this handles the following signals:
- * - F_signal_abort
- * - F_signal_broken_pipe
- * - F_signal_hangup
- * - F_signal_interrupt
- * - F_signal_quit
- * - F_signal_termination
- *
- * There is a threaded and a non-threaded version of this.
- * The non-threaded version checks periodically using byte_dump_signal_check_d and updates main->signal_check as needed.
- * The threaded version checks the flag state which is set by a separate thread that is blocking until signal is received.
- *
- * @param main
- * The main program and settings data.
- *
- * This does not alter main.setting.state.status.
- *
- * @return
- * F_true on signal received.
- * F_false otherwise.
- *
- * @see byte_dump_signal_handler()
- *
- * @see fll_program_standard_signal_received()
- */
-#ifndef _di_byte_dump_signal_check_
- extern f_status_t byte_dump_signal_check(byte_dump_main_t * const main);
-#endif // _di_byte_dump_signal_check_
-
-/**
* Signal handler for signals/interrupts.
*
* This blocks until an expected signal is recieved.
* The program signal defines.
*
* example_signal_*_d:
- * - check: Number of iterations before performing signal check in non-threaded signal handling.
* - check_failsafe: When using threads, how many consecutive failures to check signal before aborting (as a recursion failsafe).
- * - check_tiny: The tiny check.
- * - check_short: The short signal check.
*/
#ifndef _di_example_signal_d_
- #define example_signal_check_d 500000
#define example_signal_check_failsafe_d 20000
- #define example_signal_check_tiny_d 4
- #define example_signal_check_short_d 16
#endif // _di_example_signal_d_
+/**
+ * A macro wrapping the appropriate signal check function based on threaded/non-threaded support.
+ */
+#ifndef _di_example_signal_check_d_
+ #ifdef _di_thread_support_
+ #define macro_example_signal_check(program, state) fll_program_signal_check_loop(program, state)
+ #else
+ #define macro_example_signal_check(program, state) fll_program_signal_check_simple(program, state)
+ #endif // _di_thread_support_
+#endif // _di_example_signal_check_d_
+
#ifdef __cplusplus
} // extern "C"
#endif
example_setting_load(arguments, &data);
}
- if (!example_signal_check(&data)) {
+ if (!macro_example_signal_check(&data.program, &data.setting.state)) {
example_main(&data);
}
extern "C" {
#endif
-#if !defined(_di_example_signal_check_) && defined(_di_thread_support_)
- f_status_t example_signal_check(example_main_t * const main) {
-
- if (!main) return F_false;
- if (main->program.signal_received) return F_true;
-
- if (!((++main->program.signal_check) % example_signal_check_d)) {
- if (F_status_set_fine(fll_program_standard_signal_received(&main->program)) == F_interrupt) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- main->program.signal_check = 0;
- }
-
- return F_false;
- }
-#endif // !defined(_di_example_signal_check_) && defined(_di_thread_support_)
-
-#if !defined(_di_example_signal_check_) && !defined(_di_thread_support_)
- f_status_t example_signal_check(example_main_t * const main) {
-
- if (!main) return F_false;
-
- if (main->program.signal_received) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- return F_false;
- }
-#endif // !defined(_di_example_signal_check_) && !defined(_di_thread_support_)
-
#if !defined(_di_example_signal_handler_) && !defined(_di_thread_support_)
void example_signal_handler(example_main_t * const main) {
#endif
/**
- * Check to see if a signal is received.
- *
- * If main.signal is non-zero, then this handles the following signals:
- * - F_signal_abort
- * - F_signal_broken_pipe
- * - F_signal_hangup
- * - F_signal_interrupt
- * - F_signal_quit
- * - F_signal_termination
- *
- * There is a threaded and a non-threaded version of this.
- * The non-threaded version checks periodically using example_signal_check_d and updates main->signal_check as needed.
- * The threaded version checks the flag state which is set by a separate thread that is blocking until signal is received.
- *
- * @param main
- * The main program and settings data.
- *
- * This does not alter main.setting.state.status.
- *
- * @return
- * F_true on signal received.
- * F_false otherwise.
- *
- * @see example_signal_handler()
- *
- * @see fll_program_standard_signal_received()
- */
-#ifndef _di_example_signal_check_
- extern f_status_t example_signal_check(example_main_t * const main);
-#endif // _di_example_signal_check_
-
-/**
* Signal handler for signals/interrupts.
*
* This blocks until an expected signal is recieved.
if (!data || !data->main) return;
if (data->main->setting.state.status == F_child) return;
if (F_status_is_error(data->main->setting.state.status) || f_file_exists(file_stage, F_true) == F_true) return;
- if (fake_signal_check(data->main)) return;
+ if (macro_fake_signal_check(&data->main->program, &data->main->setting.state)) return;
fake_main_t * const main = data->main;
for (f_number_unsigned_t i = 0; i < files.used; ++i) {
- if (fake_signal_check(main)) break;
+ if (macro_fake_signal_check(&main->program, &main->setting.state)) break;
if (!files.array[i].used) continue;
fake_string_dynamic_reset(&main->cache_map.value);
main->setting.state.status = fll_execute_program(main->cache_argument, main->cache_arguments, ¶meter, 0, (void *) &return_code);
- if (fake_signal_check(main)) return return_code;
+ if (macro_fake_signal_check(&main->program, &main->setting.state)) return return_code;
if (main->setting.state.status != F_child) {
if (F_status_is_error(main->setting.state.status)) {
if (!data || !data->main) return;
if (F_status_is_error(data->main->setting.state.status)) return;
- if (fake_signal_check(data->main)) return;
+ if (macro_fake_signal_check(&data->main->program, &data->main->setting.state)) return;
fake_main_t * const main = data->main;
if (!data || !data->main) return;
if (F_status_is_error(data->main->setting.state.status)) return;
- if (fake_signal_check(data->main)) return;
+ if (macro_fake_signal_check(&data->main->program, &data->main->setting.state)) return;
fake_main_t * const main = data->main;
if (!data || !data->main || !setting) return;
if (F_status_is_error(data->main->setting.state.status)) return;
- if (fake_signal_check(data->main)) return;
+ if (macro_fake_signal_check(&data->main->program, &data->main->setting.state)) return;
fake_main_t * const main = data->main;
if (!data || !data->main || !setting) return;
if (F_status_is_error(data->main->setting.state.status) && buffer.used) return;
- if (fake_signal_check(data->main)) return;
+ if (macro_fake_signal_check(&data->main->program, &data->main->setting.state)) return;
fake_main_t * const main = data->main;
if (!data || !data->main || !data_build || !stage) return;
if (F_status_is_error(data->main->setting.state.status)) return;
- if (fake_signal_check(data->main)) return;
+ if (macro_fake_signal_check(&data->main->program, &data->main->setting.state)) return;
fake_main_t * const main = data->main;
for (j = 0; j < directorys[i].used; ++j) {
if (f_path_separator_s.used && directorys[i].string[j] != f_path_separator_s.string[0]) continue;
- if (fake_signal_check(data->main)) return;
+ if (macro_fake_signal_check(&data->main->program, &data->main->setting.state)) return;
directorys[i].string[j] = 0;
* The program signal defines.
*
* fake_signal_*_d:
- * - check: Number of iterations before performing signal check in non-threaded signal handling.
* - check_failsafe: When using threads, how many consecutive failures to check signal before aborting (as a recursion failsafe).
- * - check_tiny: The tiny check.
- * - check_short: The short signal check.
*/
#ifndef _di_fake_signal_d_
- #define fake_signal_check_d 500000
#define fake_signal_check_failsafe_d 20000
- #define fake_signal_check_tiny_d 4
- #define fake_signal_check_short_d 16
#endif // _di_fake_signal_d_
/**
+ * A macro wrapping the appropriate signal check function based on threaded/non-threaded support.
+ */
+#ifndef _di_fake_signal_check_d_
+ #ifdef _di_thread_support_
+ #define macro_fake_signal_check(program, state) fll_program_signal_check_loop(program, state)
+ #else
+ #define macro_fake_signal_check(program, state) fll_program_signal_check_simple(program, state)
+ #endif // _di_thread_support_
+#endif // _di_fake_signal_check_d_
+
+/**
* Flags for the code property in the f_state_t structure.
*
* fake_state_code_*_d:
break;
}
- if (fake_signal_check(main)) break;
+ if (macro_fake_signal_check(&main->program, &main->setting.state)) break;
} // for
}
}
if (main->setting.state.status == F_child) break;
- if (F_status_set_fine(main->setting.state.status) == F_interrupt || fake_signal_check(main)) break;
+ if (F_status_set_fine(main->setting.state.status) == F_interrupt || macro_fake_signal_check(&main->program, &main->setting.state)) break;
if (F_status_is_error(main->setting.state.status)) break;
} // for
}
fl_execute_parameter_t parameter = macro_fl_execute_parameter_t_initialize_1(0, 0, &environment, &signals, 0);
main->setting.state.status = fll_execute_program(program, main->cache_arguments, ¶meter, 0, (void *) &return_code);
- if (fake_signal_check(data->main)) return return_code;
+ if (macro_fake_signal_check(&data->main->program, &data->main->setting.state)) return return_code;
if (main->setting.state.status == F_child) return return_code;
}
else {
void fake_file_buffer(fake_data_t * const data, const f_string_static_t path_file, const bool required, f_string_dynamic_t * const buffer) {
if (!data || !data->main || !buffer) return;
- if (fake_signal_check(data->main)) return;
+ if (macro_fake_signal_check(&data->main->program, &data->main->setting.state)) return;
fake_main_t * const main = data->main;
clearerr(F_type_input_d);
do {
- if (fake_signal_check(main)) return;
+ if (macro_fake_signal_check(&main->program, &main->setting.state)) return;
main->setting.state.status = f_file_stream_read_block(file, buffer);
void fake_validate_parameter_paths(fake_data_t * const data) {
if (!data || !data->main) return;
- if (fake_signal_check(data->main)) return;
+ if (macro_fake_signal_check(&data->main->program, &data->main->setting.state)) return;
fake_main_t * const main = data->main;
if (!local->main) return;
- if (fake_signal_check(local->main)) {
+ if (macro_fake_signal_check(&local->main->program, &local->main->setting.state)) {
recurse->state.status = F_status_set_error(F_interrupt);
return;
fake_setting_load(arguments, &data);
}
- if (!fake_signal_check(&data)) {
+ if (!macro_fake_signal_check(&data.program, &data.setting.state)) {
fake_main(&data);
}
if (!data_make || !data_make->data || !data_make->main) return;
if (F_status_is_error(data_make->main->setting.state.status)) return;
- if (fake_signal_check(data_make->main)) return;
+ if (macro_fake_signal_check(&data_make->main->program, &data_make->main->setting.state)) return;
data_make->fakefile.used = 0;
for (f_number_unsigned_t i = 0; i < list_objects.used; ++i) {
- if (fake_signal_check(data_make->main)) break;
+ if (macro_fake_signal_check(&data_make->main->program, &data_make->main->setting.state)) break;
if (f_compare_dynamic_partial_string(fake_make_item_settings_s.string, data_make->main->buffer, fake_make_item_settings_s.used, list_objects.array[i]) == F_equal_to) {
if (!missing_settings) {
void fake_make_operate(fake_data_t * const data) {
if (!data || !data->main) return;
- if (fake_signal_check(data->main)) return;
+ if (macro_fake_signal_check(&data->main->program, &data->main->setting.state)) return;
fake_main_t * const main = data->main;
for (j = 0; j < fake_max_operation_d; ++j) {
- if (fake_signal_check(main)) break;
+ if (macro_fake_signal_check(&main->program, &main->setting.state)) break;
if (f_compare_dynamic_partial_string(operations_name[j].string, main->buffer, operations_name[j].used, section->objects.array[i]) == F_equal_to) {
state_process.operation = operations_type[j];
fake_main_t * const main = data_make->main;
- if (fake_signal_check(main)) return;
+ if (macro_fake_signal_check(&main->program, &main->setting.state)) return;
// Reset the environment.
for (f_number_unsigned_t i = 0; i < data_make->environment.used; ++i) {
main->setting.state.status = fll_execute_program(program, arguments, ¶meter, 0, (void *) &return_code);
- if (fake_signal_check(main)) return;
+ if (macro_fake_signal_check(&main->program, &main->setting.state)) return;
if (F_status_is_error(main->setting.state.status)) {
if (F_status_set_fine(main->setting.state.status) == F_interrupt) return;
extern "C" {
#endif
-#if !defined(_di_fake_signal_check_) && defined(_di_thread_support_)
- f_status_t fake_signal_check(fake_main_t * const main) {
-
- if (!main) return F_false;
- if (main->program.signal_received) return F_true;
-
- if (!((++main->program.signal_check) % fake_signal_check_d)) {
- if (F_status_set_fine(fll_program_standard_signal_received(&main->program)) == F_interrupt) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- main->program.signal_check = 0;
- }
-
- return F_false;
- }
-#endif // !defined(_di_fake_signal_check_) && defined(_di_thread_support_)
-
-#if !defined(_di_fake_signal_check_) && !defined(_di_thread_support_)
- f_status_t fake_signal_check(fake_main_t * const main) {
-
- if (!main) return F_false;
-
- if (main->program.signal_received) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- return F_false;
- }
-#endif // !defined(_di_fake_signal_check_) && !defined(_di_thread_support_)
-
#if !defined(_di_fake_signal_handler_) && !defined(_di_thread_support_)
void fake_signal_handler(fake_main_t * const main) {
? ((fake_local_t *) state->custom)->main
: (fake_main_t *) state->custom;
- state->status = (fake_signal_check(main) == F_true) ? F_status_set_error(F_interrupt) : F_interrupt_not;
+ state->status = (macro_fake_signal_check(&main->program, &main->setting.state) == F_true) ? F_status_set_error(F_interrupt) : F_interrupt_not;
}
#endif // _di_fake_signal_handler_callback_
#endif
/**
- * Check to see if a signal is received.
- *
- * If main.signal is non-zero, then this handles the following signals:
- * - F_signal_abort
- * - F_signal_broken_pipe
- * - F_signal_hangup
- * - F_signal_interrupt
- * - F_signal_quit
- * - F_signal_termination
- *
- * There is a threaded and a non-threaded version of this.
- * The non-threaded version checks periodically using fake_signal_check_d and updates main->signal_check as needed.
- * The threaded version checks the flag state which is set by a separate thread that is blocking until signal is received.
- *
- * @param main
- * The main program and settings data.
- *
- * This does not alter main.setting.state.status.
- *
- * @return
- * F_true on signal received.
- * F_false otherwise.
- *
- * @see fake_signal_handler()
- *
- * @see fll_program_standard_signal_received()
- */
-#ifndef _di_fake_signal_check_
- extern f_status_t fake_signal_check(fake_main_t * const main);
-#endif // _di_fake_signal_check_
-
-/**
* Signal handler for signals/interrupts.
*
* This blocks until an expected signal is recieved.
for (f_number_unsigned_t i = 0; i < parameters->remaining.used; ++i) {
- if (firewall_signal_check(main)) return;
+ if (macro_firewall_signal_check(&main->program, &main->setting.state)) return;
index = parameters->remaining.array[i];
* The program signal defines.
*
* firewall_signal_*_d:
- * - check: Number of iterations before performing signal check in non-threaded signal handling.
* - check_failsafe: When using threads, how many consecutive failures to check signal before aborting (as a recursion failsafe).
- * - check_tiny: The tiny check.
- * - check_short: The short signal check.
*/
#ifndef _di_firewall_signal_d_
- #define firewall_signal_check_d 500000
#define firewall_signal_check_failsafe_d 20000
- #define firewall_signal_check_tiny_d 4
- #define firewall_signal_check_short_d 16
#endif // _di_firewall_signal_d_
+/**
+ * A macro wrapping the appropriate signal check function based on threaded/non-threaded support.
+ */
+#ifndef _di_firewall_signal_check_d_
+ #ifdef _di_thread_support_
+ #define macro_firewall_signal_check(program, state) fll_program_signal_check_loop(program, state)
+ #else
+ #define macro_firewall_signal_check(program, state) fll_program_signal_check_simple(program, state)
+ #endif // _di_thread_support_
+#endif // _di_firewall_signal_check_d_
+
#ifdef __cplusplus
} // extern "C"
#endif
firewall_setting_load(arguments, &data);
}
- if (!firewall_signal_check(&data)) {
+ if (!macro_firewall_signal_check(&data.program, &data.setting.state)) {
firewall_main(&data);
}
// Remove "lo" (loopback) from the device listing.
for (; i < main->setting.devices.used; ++i) {
- if (firewall_signal_check(main)) return;
+ if (macro_firewall_signal_check(&main->program, &main->setting.state)) return;
if (f_compare_dynamic(firewall_device_loop_s, main->setting.devices.array[i]) == F_equal_to) {
main->data.file = main->setting.devices.array[i];
for (i = 0; i < main->data.chain_objects.used; ++i) {
- if (firewall_signal_check(main)) return;
+ if (macro_firewall_signal_check(&main->program, &main->setting.state)) return;
if (!(main->data.has & firewall_data_has_stop_e) && f_compare_dynamic_partial_string(firewall_group_stop_s.string, main->data.buffer, firewall_group_stop_s.used, main->data.chain_objects.array[i]) == F_equal_to) {
main->data.stop = i;
for (f_number_unsigned_t j = 0; j < main->setting.devices.used; ++j) {
- if (firewall_signal_check(main)) return;
+ if (macro_firewall_signal_check(&main->program, &main->setting.state)) return;
main->cache.path_file.used = 0;
main->data.device = j;
for (; i < main->data.chain_objects.used; ++i) {
- if (firewall_signal_check(main)) return;
+ if (macro_firewall_signal_check(&main->program, &main->setting.state)) return;
new_chain = F_true;
j = 0;
return;
}
- if (firewall_signal_check(main)) return;
+ if (macro_firewall_signal_check(&main->program, &main->setting.state)) return;
if (return_code && F_status_is_error_not(main->setting.state.status)) {
firewall_print_error_operation_return_code(&main->program.error, tools[t], main->cache.arguments, return_code);
for (t = 0; t < 2; ++t) {
- if (firewall_signal_check(main)) return;
+ if (macro_firewall_signal_check(&main->program, &main->setting.state)) return;
if (!tools[t].used) continue;
return;
}
- if (firewall_signal_check(main)) return;
+ if (macro_firewall_signal_check(&main->program, &main->setting.state)) return;
if (F_status_is_error(main->setting.state.status)) {
if (F_status_set_fine(main->setting.state.status) == F_failure) {
for (t = 0; t < 2; ++t) {
- if (firewall_signal_check(main)) return;
+ if (macro_firewall_signal_check(&main->program, &main->setting.state)) return;
if (!tools[t].used) continue;
for (; i < rule_objects->used; ++i) {
- if (firewall_signal_check(main)) return;
+ if (macro_firewall_signal_check(&main->program, &main->setting.state)) return;
valid = F_true;
is_ip_list = F_false;
for (t = 0; t < 2; ++t) {
- if (firewall_signal_check(main)) return;
+ if (macro_firewall_signal_check(&main->program, &main->setting.state)) return;
if (!tools[t].used) continue;
for (; at < rule_contents->array[i].used; ++at) {
- if (firewall_signal_check(main)) return;
+ if (macro_firewall_signal_check(&main->program, &main->setting.state)) return;
if (rule_contents->array[i].array[at].start <= rule_contents->array[i].array[at].stop) {
main->cache.arguments.array[main->cache.arguments.used].used = 0;
// The ip_list file contains objects and no content, all objects are what matter an nothing else.
for (at = 0; at < main->cache.basic_objects.used; ++at) {
- if (firewall_signal_check(main)) return;
+ if (macro_firewall_signal_check(&main->program, &main->setting.state)) return;
main->cache.arguments.array[main->cache.arguments.used].used = 0;
extern "C" {
#endif
-#if !defined(_di_firewall_signal_check_) && defined(_di_thread_support_)
- f_status_t firewall_signal_check(firewall_main_t * const main) {
-
- if (!main) return F_false;
- if (main->program.signal_received) return F_true;
-
- if (!((++main->program.signal_check) % firewall_signal_check_d)) {
- if (F_status_set_fine(fll_program_standard_signal_received(&main->program)) == F_interrupt) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- main->program.signal_check = 0;
- }
-
- return F_false;
- }
-#endif // !defined(_di_firewall_signal_check_) && defined(_di_thread_support_)
-
-#if !defined(_di_firewall_signal_check_) && !defined(_di_thread_support_)
- f_status_t firewall_signal_check(firewall_main_t * const main) {
-
- if (!main) return F_false;
-
- if (main->program.signal_received) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- return F_false;
- }
-#endif // !defined(_di_firewall_signal_check_) && !defined(_di_thread_support_)
-
#if !defined(_di_firewall_signal_handler_) && !defined(_di_thread_support_)
void firewall_signal_handler(firewall_main_t * const main) {
#endif
/**
- * Check to see if a signal is received.
- *
- * If main.signal is non-zero, then this handles the following signals:
- * - F_signal_abort
- * - F_signal_broken_pipe
- * - F_signal_hangup
- * - F_signal_interrupt
- * - F_signal_quit
- * - F_signal_termination
- *
- * There is a threaded and a non-threaded version of this.
- * The non-threaded version checks periodically using firewall_signal_check_d and updates main->signal_check as needed.
- * The threaded version checks the flag state which is set by a separate thread that is blocking until signal is received.
- *
- * @param main
- * The main program and settings data.
- *
- * This does not alter main.setting.state.status.
- *
- * @return
- * F_true on signal received.
- * F_false otherwise.
- *
- * @see firewall_signal_handler()
- *
- * @see fll_program_standard_signal_received()
- */
-#ifndef _di_firewall_signal_check_
- extern f_status_t firewall_signal_check(firewall_main_t * const main);
-#endif // _di_firewall_signal_check_
-
-/**
* Signal handler for signals/interrupts.
*
* This blocks until an expected signal is recieved.
for (; i < main->setting.names.used; ++i) {
- if (fss_identify_signal_check(main)) return;
+ if (macro_fss_identify_signal_check(&main->program, &main->setting.state)) return;
index = parameters->array[fss_identify_parameter_name_e].values.array[i];
main->setting.names.array[i].used = 0;
if (main->setting.names.array[i].used) {
for (j = 0; j < main->setting.names.array[i].used; ++j) {
- if (fss_identify_signal_check(main)) return;
+ if (macro_fss_identify_signal_check(&main->program, &main->setting.state)) return;
main->setting.state.status = f_utf_is_word_dash(main->setting.names.array[i].string + j, main->setting.names.array[i].used, F_true);
// Construct the array without allocating any more memory by setting this as a static string (used > 0, size = 0).
for (index = 0; main->setting.files.used < parameters->remaining.used; ) {
- if (fss_identify_signal_check(main)) return;
+ if (macro_fss_identify_signal_check(&main->program, &main->setting.state)) return;
index = parameters->remaining.array[main->setting.files.used];
* The program signal defines.
*
* fss_identify_signal_*_d:
- * - check: Number of iterations before performing signal check in non-threaded signal handling.
* - check_failsafe: When using threads, how many consecutive failures to check signal before aborting (as a recursion failsafe).
- * - check_tiny: The tiny check.
- * - check_short: The short signal check.
*/
#ifndef _di_fss_identify_signal_d_
- #define fss_identify_signal_check_d 500000
#define fss_identify_signal_check_failsafe_d 20000
- #define fss_identify_signal_check_tiny_d 4
- #define fss_identify_signal_check_short_d 16
#endif // _di_fss_identify_signal_d_
+/**
+ * A macro wrapping the appropriate signal check function based on threaded/non-threaded support.
+ */
+#ifndef _di_fss_identify_signal_check_d_
+ #ifdef _di_thread_support_
+ #define macro_fss_identify_signal_check(program, state) fll_program_signal_check_loop(program, state)
+ #else
+ #define macro_fss_identify_signal_check(program, state) fll_program_signal_check_simple(program, state)
+ #endif // _di_thread_support_
+#endif // _di_fss_identify_signal_check_d_
+
#ifdef __cplusplus
} // extern "C"
#endif
for (f_number_unsigned_t i = 0; F_status_is_error_not(main->setting.state.status) && i < main->setting.files.used; ++i) {
- if (fss_identify_signal_check(main)) break;
+ if (macro_fss_identify_signal_check(&main->program, &main->setting.state)) break;
if ((main->setting.flag & fss_identify_main_flag_line_d) && main->setting.current > main->setting.line) break;
macro_f_file_t_reset(main->setting.file);
main->setting.range.stop = 0;
do {
- if (fss_identify_signal_check(main)) return;
+ if (macro_fss_identify_signal_check(&main->program, &main->setting.state)) return;
main->setting.state.status = f_memory_array_increase_by(main->setting.file.size_read, sizeof(f_char_t), (void **) &main->setting.buffer.string, &main->setting.buffer.used, &main->setting.buffer.size);
fss_identify_setting_load(arguments, &data);
}
- if (!fss_identify_signal_check(&data)) {
+ if (!macro_fss_identify_signal_check(&data.program, &data.setting.state)) {
fss_identify_main(&data);
}
extern "C" {
#endif
-#if !defined(_di_fss_identify_signal_check_) && defined(_di_thread_support_)
- f_status_t fss_identify_signal_check(fss_identify_main_t * const main) {
-
- if (!main) return F_false;
- if (main->program.signal_received) return F_true;
-
- if (!((++main->program.signal_check) % fss_identify_signal_check_d)) {
- if (F_status_set_fine(fll_program_standard_signal_received(&main->program)) == F_interrupt) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- main->program.signal_check = 0;
- }
-
- return F_false;
- }
-#endif // !defined(_di_fss_identify_signal_check_) && defined(_di_thread_support_)
-
-#if !defined(_di_fss_identify_signal_check_) && !defined(_di_thread_support_)
- f_status_t fss_identify_signal_check(fss_identify_main_t * const main) {
-
- if (!main) return F_false;
-
- if (main->program.signal_received) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- return F_false;
- }
-#endif // !defined(_di_fss_identify_signal_check_) && !defined(_di_thread_support_)
-
#if !defined(_di_fss_identify_signal_handler_) && !defined(_di_thread_support_)
void fss_identify_signal_handler(fss_identify_main_t * const main) {
#endif
/**
- * Check to see if a signal is received.
- *
- * If main.signal is non-zero, then this handles the following signals:
- * - F_signal_abort
- * - F_signal_broken_pipe
- * - F_signal_hangup
- * - F_signal_interrupt
- * - F_signal_quit
- * - F_signal_termination
- *
- * There is a threaded and a non-threaded version of this.
- * The non-threaded version checks periodically using fss_identify_signal_check_d and updates main->signal_check as needed.
- * The threaded version checks the flag state which is set by a separate thread that is blocking until signal is received.
- *
- * @param main
- * The main program and settings data.
- *
- * This does not alter main.setting.state.status.
- *
- * @return
- * F_true on signal received.
- * F_false otherwise.
- *
- * @see fss_identify_signal_handler()
- *
- * @see fll_program_standard_signal_received()
- */
-#ifndef _di_fss_identify_signal_check_
- extern f_status_t fss_identify_signal_check(fss_identify_main_t * const main);
-#endif // _di_fss_identify_signal_check_
-
-/**
* Signal handler for signals/interrupts.
*
* This blocks until an expected signal is recieved.
fss_read_setting_load(arguments, &data, 0);
}
- if (!fss_read_signal_check(&data)) {
+ if (!macro_fss_read_signal_check(&data.program, &data.setting.state)) {
fss_read_main(&data);
}
fss_read_setting_load(arguments, &data, 0);
}
- if (!fss_read_signal_check(&data)) {
+ if (!macro_fss_read_signal_check(&data.program, &data.setting.state)) {
fss_read_main(&data);
}
fss_read_setting_load(arguments, &data, 0);
}
- if (!fss_read_signal_check(&data)) {
+ if (!macro_fss_read_signal_check(&data.program, &data.setting.state)) {
fss_read_main(&data);
}
for (; i < main->setting.contents.used && main->setting.state.status != F_success; ++i) {
if (!names[i]) continue;
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
main->call.process_at_line(main, i, *delimits_object, *delimits_content, &line);
if (F_status_is_error(main->setting.state.status)) return;
for (; i < main->setting.contents.used; ++i) {
if (!names[i]) continue;
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
main->call.print_at(&main->program.output, i, *delimits_object, *delimits_content);
} // for
* This alters main.setting.state.status:
* F_okay on success.
*
- * Errors (with error bit) from: fss_read_signal_check().
+ * Errors (with error bit) from: macro_fss_read_signal_check().
*
- * @see fss_read_signal_check()
+ * @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_embedded_list_process_
extern void fss_read_embedded_list_process(fss_read_main_t * const main);
* This alters main.setting.state.status:
* F_okay on success.
*
- * Errors (with error bit) from: fss_read_signal_check().
+ * Errors (with error bit) from: macro_fss_read_signal_check().
*
- * @see fss_read_signal_check()
+ * @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_embedded_list_process_determine_depth_
extern void fss_read_embedded_list_process_determine_depth(fss_read_main_t * const main);
* This alters main.setting.state.status:
* F_okay on success.
*
- * Errors (with error bit) from: fss_read_signal_check().
+ * Errors (with error bit) from: macro_fss_read_signal_check().
* @param parent
* The index position of the parent element.
* This is needed because the items array for some depth is tied to the parent via a property.
*
* Must be greater than 0.
*
- * @see fss_read_signal_check()
+ * @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_embedded_list_process_determine_depth_nest_recurse_
extern void fss_read_embedded_list_process_determine_depth_nest_recurse(fss_read_main_t * const main, const f_number_unsigned_t parent, const f_number_unsigned_t next);
fss_read_setting_load(arguments, &data, 0);
}
- if (!fss_read_signal_check(&data)) {
+ if (!macro_fss_read_signal_check(&data.program, &data.setting.state)) {
fss_read_main(&data);
}
fss_read_setting_load(arguments, &data, 0);
}
- if (!fss_read_signal_check(&data)) {
+ if (!macro_fss_read_signal_check(&data.program, &data.setting.state)) {
fss_read_main(&data);
}
for (i = 0; i < parameters->array[fss_read_parameter_delimit_e].values.used; ++i) {
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
index = parameters->array[fss_read_parameter_delimit_e].values.array[i];
length = parameters->arguments.array[index].used;
while (main->setting.state.status != F_okay_eof) {
- if (fss_read_signal_check(main)) break;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) break;
main->setting.state.status = f_file_stream_read_block(file, &main->setting.buffer);
if (F_status_is_error(main->setting.state.status)) break;
for (i = 0; i < parameters->remaining.used; ++i) {
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
index = parameters->remaining.array[i];
file_data = &main->setting.files.array[main->setting.files.used];
for (size_read = 0; size_read < size_file; size_read += size_block) {
- if (size_file > fss_read_allocation_block_max_d && fss_read_signal_check(main)) break;
+ if (size_file > fss_read_allocation_block_max_d && macro_fss_read_signal_check(&main->program, &main->setting.state)) break;
main->setting.state.status = f_file_stream_read_until(file, size_block, &main->setting.buffer);
if (F_status_is_error(main->setting.state.status)) break;
for (i = 0; i < main->setting.depths.used; ++i) {
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
current = &main->setting.depths.array[i];
current->depth = 0;
for (j = i + 1; j < main->setting.depths.used; ++j) {
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
current = &main->setting.depths.array[i];
* Errors (with error bit) from: fll_program_parameter_process_verbosity_standard().
*
* Errors (with error bit) from: fss_read_setting_load_depth().
- * Errors (with error bit) from: fss_read_signal_check()
+ * Errors (with error bit) from: macro_fss_read_signal_check()
* @param do_settings_load
* (optional) Designate a function to call after performing the initial processing, but before printing help.
* If the function returns F_done, then this function immediately returns, resetting status to F_okay.
* @see fll_program_parameter_process_verbosity_standard()
*
* @see fss_read_setting_load_depth()
- * @see fss_read_signal_check()
+ * @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_setting_load_
extern void fss_read_setting_load(const f_console_arguments_t arguments, fss_read_main_t * const main, const fss_read_settings_load_call_t do_settings_load);
* The program signal defines.
*
* fss_read_signal_*_d:
- * - check: Number of iterations before performing signal check in non-threaded signal handling.
* - check_failsafe: When using threads, how many consecutive failures to check signal before aborting (as a recursion failsafe).
- * - check_tiny: The tiny check.
- * - check_short: The short signal check.
*/
#ifndef _di_fss_read_signal_d_
- #define fss_read_signal_check_d 500000
#define fss_read_signal_check_failsafe_d 20000
- #define fss_read_signal_check_tiny_d 4
- #define fss_read_signal_check_short_d 16
#endif // _di_fss_read_signal_d_
+/**
+ * A macro wrapping the appropriate signal check function based on threaded/non-threaded support.
+ */
+#ifndef _di_fss_read_signal_check_d_
+ #ifdef _di_thread_support_
+ #define macro_fss_read_signal_check(program, state) fll_program_signal_check_loop(program, state)
+ #else
+ #define macro_fss_read_signal_check(program, state) fll_program_signal_check_simple(program, state)
+ #endif // _di_thread_support_
+#endif // _di_fss_read_signal_check_d_
+
#ifdef __cplusplus
} // extern "C"
#endif
*
* Errors (with error bit) from: f_string_dynamic_append_assure().
*
- * Errors (with error bit) from: fss_read_signal_check().
+ * Errors (with error bit) from: macro_fss_read_signal_check().
*
* @see f_string_dynamic_append_assure()
*
- * @see fss_read_signal_check()
+ * @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_process_last_line_
extern void fss_read_process_last_line(fss_read_main_t * const main);
fss_read_setting_load(arguments, &data, &fss_read_main_setting_load_as);
}
- if (!fss_read_signal_check(&data)) {
+ if (!macro_fss_read_signal_check(&data.program, &data.setting.state)) {
fss_read_main(&data);
}
// Loop through with conditionals only when necessary for performance reasons.
for (print_state |= 0x8; i < main->setting.contents.array[at].used; ++i) {
- if (fss_read_signal_check(main)) return F_status_set_error(F_interrupt);
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return F_status_set_error(F_interrupt);
if (main->setting.contents.array[at].array[i].start <= main->setting.contents.array[at].array[i].stop) {
print_state &= ~0x8;
for (; i < main->setting.contents.array[at].used; ++i) {
- if (fss_read_signal_check(main)) return F_status_set_error(F_interrupt);
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return F_status_set_error(F_interrupt);
if (main->setting.contents.array[at].array[i].start > main->setting.contents.array[at].array[i].stop) continue;
if (main->call.print_content_next) {
for (; i < main->setting.contents.used && main->setting.state.status != F_success; ++i) {
if (!names[i]) continue;
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
main->call.process_at_line(main, i, *delimits_object, *delimits_content, &line);
if (F_status_is_error(main->setting.state.status)) return;
for (; i < main->setting.contents.used; ++i) {
if (!names[i]) continue;
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
main->call.print_at(&main->program.output, i, *delimits_object, *delimits_content);
} // for
for (; i < main->setting.objects.used; ++i) {
if (!names[i]) continue;
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
if (at == main->setting.depth.value_at) {
if (main->setting.flag & fss_read_main_flag_line_d) {
for (; i < main->setting.contents.array[at].used; ++i) {
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
main->setting.range = main->setting.contents.array[at].array[i];
k = 0;
for (j = main->setting.range.start; j <= main->setting.range.stop; ++j) {
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
if (k < main->setting.comments.used) {
while (k < main->setting.comments.used && main->setting.comments.array[k].stop < j) ++k;
for (f_number_unsigned_t at = 0; at < main->setting.contents.used; ++at) {
if (!names[at]) continue;
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
if (main->setting.flag & fss_read_main_flag_empty_d) {
if (main->setting.contents.array[at].used > max) {
for (i = 0; i < main->setting.contents.array[at].used; ++i) {
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
if (main->setting.contents.array[at].array[i].start <= main->setting.contents.array[at].array[i].stop) ++current;
} // for
}
}
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
} // for
}
if ((main->setting.flag & fss_read_main_flag_trim_d) || (main->setting.feature & fss_read_feature_flag_object_trim_d)) {
for (i = 0; i < main->setting.objects.used; ++i) {
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
if (f_compare_dynamic_partial_except_trim_dynamic(main->setting.depth.value_name, main->setting.buffer, main->setting.objects.array[i], fss_read_except_none_c, main->setting.delimits_object) == F_equal_to) {
names[i] = F_true;
else {
for (i = 0; i < main->setting.objects.used; ++i) {
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
if (f_compare_dynamic_partial_except_dynamic(main->setting.depth.value_name, main->setting.buffer, main->setting.objects.array[i], fss_read_except_none_c, main->setting.delimits_object) == F_equal_to) {
names[i] = F_true;
for (; i < main->setting.contents.used; ++i) {
if (!names[i]) continue;
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
if ((main->setting.flag & fss_read_main_flag_at_d) && main->setting.depth.index_at) {
if (main->setting.depth.value_at != i) continue;
for (f_number_unsigned_t at = 0; i < main->setting.objects.used; ++i) {
if (!names[i]) continue;
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
if (at < main->setting.depth.value_at) {
++at;
for (; i < main->setting.objects.used; ++i) {
if (!names[i]) continue;
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
if (!(main->setting.flag & fss_read_main_flag_object_d) && (main->setting.flag & fss_read_main_flag_content_d)) {
if (!(main->setting.contents.array[i].used || (main->setting.flag & fss_read_main_flag_empty_d))) continue;
for (; at < main->setting.contents.used; ++at) {
if (!names[at]) continue;
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
if ((main->setting.flag & fss_read_main_flag_at_d) && main->setting.depth.index_at) {
if (main->setting.depth.value_at != at) continue;
for (i = 0; i < main->setting.contents.array[at].used; ++i) {
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
range.start = main->setting.contents.array[at].array[i].start;
range.stop = main->setting.contents.array[at].array[i].stop;
for (; at < main->setting.objects.used; ++at) {
if (!names[at]) continue;
- if (fss_read_signal_check(main)) return;
+ if (macro_fss_read_signal_check(&main->program, &main->setting.state)) return;
if ((main->setting.flag & fss_read_main_flag_at_d) && main->setting.depth.index_at) {
if (main->setting.depth.value_at != at) continue;
* Errors (with error bit) from: main.call.process_read().
* Errors (with error bit) from: main.call.process_total().
*
- * Errors (with error bit) from: fss_read_signal_check().
+ * Errors (with error bit) from: macro_fss_read_signal_check().
*
- * @see fss_read_signal_check()
+ * @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_process_
extern void fss_read_process(fss_read_main_t * const main);
* This alters main.setting.state.status:
* F_okay on success.
*
- * Errors (with error bit) from: fss_read_signal_check().
+ * Errors (with error bit) from: macro_fss_read_signal_check().
* @param names
* An array of booleans representing if the name at a given index is enabled.
* (If TRUE, then the name is to be used and if FALSE, then the name is not to be used.)
* The delimits array representing a delimited Content.
* This represents the positions within the current Content at the "at" position.
*
- * @see fss_read_signal_check()
+ * @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_process_at_
extern void fss_read_process_at(fss_read_main_t * const main, const bool names[], const f_number_unsigneds_t delimits_object, const f_number_unsigneds_t delimits_content);
*
* Errors (with error bit) from: f_string_dynamic_append_assure().
*
- * Errors (with error bit) from: fss_read_signal_check().
+ * Errors (with error bit) from: macro_fss_read_signal_check().
* @param at
* The Object index position to be processed.
* @param delimits_object
* This alters main.setting.state.status:
* F_okay on success.
*
- * Errors (with error bit) from: fss_read_signal_check().
+ * Errors (with error bit) from: macro_fss_read_signal_check().
* @param names
* An array of booleans representing if the name at a given index is enabled.
* (If TRUE, then the name is to be used and if FALSE, then the name is not to be used.)
*
- * @see fss_read_signal_check()
+ * @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_process_columns_
extern void fss_read_process_columns(fss_read_main_t * const main, const bool names[]);
* This alters main.setting.state.status:
* F_okay on success.
*
- * Errors (with error bit) from: fss_read_signal_check().
+ * Errors (with error bit) from: macro_fss_read_signal_check().
* @param names
* An array of booleans representing if the name at a given index is enabled.
* (If TRUE, then the name is to be used and if FALSE, then the name is not to be used.)
*
- * @see fss_read_signal_check()
+ * @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_process_name_
extern void fss_read_process_name(fss_read_main_t * const main, bool names[]);
* This alters main.setting.state.status:
* F_okay on success.
*
- * Errors (with error bit) from: fss_read_signal_check().
+ * Errors (with error bit) from: macro_fss_read_signal_check().
* @param names
* An array of booleans representing if the name at a given index is enabled.
* (If TRUE, then the name is to be used and if FALSE, then the name is not to be used.)
*
- * @see fss_read_signal_check()
+ * @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_process_total_
extern void fss_read_process_total(fss_read_main_t * const main, const bool names[]);
* This alters main.setting.state.status:
* F_okay on success.
*
- * Errors (with error bit) from: fss_read_signal_check().
+ * Errors (with error bit) from: macro_fss_read_signal_check().
* @param names
* An array of booleans representing if the name at a given index is enabled.
* (If TRUE, then the name is to be used and if FALSE, then the name is not to be used.)
*
- * @see fss_read_signal_check()
+ * @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_process_total_multiple_
extern void fss_read_process_total_multiple(fss_read_main_t * const main, const bool names[]);
extern "C" {
#endif
-#if !defined(_di_fss_read_signal_check_) && defined(_di_thread_support_)
- f_status_t fss_read_signal_check(fss_read_main_t * const main) {
-
- if (!main) return F_false;
- if (main->program.signal_received) return F_true;
-
- if (!((++main->program.signal_check) % fss_read_signal_check_d)) {
- if (F_status_set_fine(fll_program_standard_signal_received(&main->program)) == F_interrupt) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- main->program.signal_check = 0;
- }
-
- return F_false;
- }
-#endif // !defined(_di_fss_read_signal_check_) && defined(_di_thread_support_)
-
-#if !defined(_di_fss_read_signal_check_) && !defined(_di_thread_support_)
- f_status_t fss_read_signal_check(fss_read_main_t * const main) {
-
- if (!main) return F_false;
-
- if (main->program.signal_received) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- return F_false;
- }
-#endif // !defined(_di_fss_read_signal_check_) && !defined(_di_thread_support_)
-
#if !defined(_di_fss_read_signal_handler_) && !defined(_di_thread_support_)
void fss_read_signal_handler(fss_read_main_t * const main) {
#endif
/**
- * Check to see if a signal is received.
- *
- * If main.signal is non-zero, then this handles the following signals:
- * - F_signal_abort
- * - F_signal_broken_pipe
- * - F_signal_hangup
- * - F_signal_interrupt
- * - F_signal_quit
- * - F_signal_termination
- *
- * There is a threaded and a non-threaded version of this.
- * The non-threaded version checks periodically using fss_read_signal_check_d and updates main->signal_check as needed.
- * The threaded version checks the flag state which is set by a separate thread that is blocking until signal is received.
- *
- * @param main
- * The main program and settings data.
- *
- * This does not alter main.setting.state.status.
- *
- * @return
- * F_true on signal received.
- * F_false otherwise.
- *
- * @see fss_read_signal_handler()
- *
- * @see fll_program_standard_signal_received()
- */
-#ifndef _di_fss_read_signal_check_
- extern f_status_t fss_read_signal_check(fss_read_main_t * const main);
-#endif // _di_fss_read_signal_check_
-
-/**
* Signal handler for signals/interrupts.
*
* This blocks until an expected signal is recieved.
* F_data_not on success but nothing was provided to operate with.
*
* @see fss_read_setting_load()
- * @see fss_read_signal_check()
+ * @see macro_fss_read_signal_check()
*/
#ifndef _di_fss_read_payload_setting_load_
extern void fss_read_payload_setting_load(const f_console_arguments_t arguments, fss_read_main_t * const main);
fss_read_setting_load(arguments, &data, &fss_read_payload_setting_load);
}
- if (!fss_read_signal_check(&data)) {
+ if (!macro_fss_read_signal_check(&data.program, &data.setting.state)) {
fss_read_main(&data);
}
fss_write_setting_load(arguments, &data, 0);
}
- if (!fss_write_signal_check(&data)) {
+ if (!macro_fss_write_signal_check(&data.program, &data.setting.state)) {
fss_write_main(&data);
}
fss_write_setting_load(arguments, &data, 0);
}
- if (!fss_write_signal_check(&data)) {
+ if (!macro_fss_write_signal_check(&data.program, &data.setting.state)) {
fss_write_main(&data);
}
fss_write_setting_load(arguments, &data, 0);
}
- if (!fss_write_signal_check(&data)) {
+ if (!macro_fss_write_signal_check(&data.program, &data.setting.state)) {
fss_write_main(&data);
}
fss_write_setting_load(arguments, &data, 0);
}
- if (!fss_write_signal_check(&data)) {
+ if (!macro_fss_write_signal_check(&data.program, &data.setting.state)) {
fss_write_main(&data);
}
fss_write_setting_load(arguments, &data, 0);
}
- if (!fss_write_signal_check(&data)) {
+ if (!macro_fss_write_signal_check(&data.program, &data.setting.state)) {
fss_write_main(&data);
}
* The program signal defines.
*
* fss_write_signal_*_d:
- * - check: Number of iterations before performing signal check in non-threaded signal handling.
* - check_failsafe: When using threads, how many consecutive failures to check signal before aborting (as a recursion failsafe).
- * - check_tiny: The tiny check.
- * - check_short: The short signal check.
*/
#ifndef _di_fss_write_signal_d_
- #define fss_write_signal_check_d 500000
#define fss_write_signal_check_failsafe_d 20000
- #define fss_write_signal_check_tiny_d 4
- #define fss_write_signal_check_short_d 16
#endif // _di_fss_write_signal_d_
+/**
+ * A macro wrapping the appropriate signal check function based on threaded/non-threaded support.
+ */
+#ifndef _di_fss_write_signal_check_d_
+ #ifdef _di_thread_support_
+ #define macro_fss_write_signal_check(program, state) fll_program_signal_check_loop(program, state)
+ #else
+ #define macro_fss_write_signal_check(program, state) fll_program_signal_check_simple(program, state)
+ #endif // _di_thread_support_
+#endif // _di_fss_write_signal_check_d_
+
#ifdef __cplusplus
} // extern "C"
#endif
if (length) {
for (f_number_unsigned_t i = 0; i < length; ++i) {
- if (fss_write_signal_check(main)) return;
+ if (macro_fss_write_signal_check(&main->program, &main->setting.state)) return;
if (main->setting.objects.used) {
main->setting.object = &main->setting.objects.array[i];
for (;;) {
- if (fss_write_signal_check(main)) break;
+ if (macro_fss_write_signal_check(&main->program, &main->setting.state)) break;
if (range.start > range.stop) {
if (status_pipe == F_okay_eof) break;
fss_write_setting_load(arguments, &data, &fss_write_main_setting_load_as);
}
- if (!fss_write_signal_check(&data)) {
+ if (!macro_fss_write_signal_check(&data.program, &data.setting.state)) {
fss_write_main(&data);
}
extern "C" {
#endif
-#if !defined(_di_fss_write_signal_check_) && defined(_di_thread_support_)
- f_status_t fss_write_signal_check(fss_write_main_t * const main) {
-
- if (!main) return F_false;
- if (main->program.signal_received) return F_true;
-
- if (!((++main->program.signal_check) % fss_write_signal_check_d)) {
- if (F_status_set_fine(fll_program_standard_signal_received(&main->program)) == F_interrupt) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- main->program.signal_check = 0;
- }
-
- return F_false;
- }
-#endif // !defined(_di_fss_write_signal_check_) && defined(_di_thread_support_)
-
-#if !defined(_di_fss_write_signal_check_) && !defined(_di_thread_support_)
- f_status_t fss_write_signal_check(fss_write_main_t * const main) {
-
- if (!main) return F_false;
-
- if (main->program.signal_received) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- return F_false;
- }
-#endif // !defined(_di_fss_write_signal_check_) && !defined(_di_thread_support_)
-
#if !defined(_di_fss_write_signal_handler_) && !defined(_di_thread_support_)
void fss_write_signal_handler(fss_write_main_t * const main) {
#endif
/**
- * Check to see if a signal is received.
- *
- * If main.signal is non-zero, then this handles the following signals:
- * - F_signal_abort
- * - F_signal_broken_pipe
- * - F_signal_hangup
- * - F_signal_interrupt
- * - F_signal_quit
- * - F_signal_termination
- *
- * There is a threaded and a non-threaded version of this.
- * The non-threaded version checks periodically using fss_write_signal_check_d and updates main->signal_check as needed.
- * The threaded version checks the flag state which is set by a separate thread that is blocking until signal is received.
- *
- * @param main
- * The main program and settings data.
- *
- * This does not alter main.setting.state.status.
- *
- * @return
- * F_true on signal received.
- * F_false otherwise.
- *
- * @see fss_write_signal_handler()
- *
- * @see fll_program_standard_signal_received()
- */
-#ifndef _di_fss_write_signal_check_
- extern f_status_t fss_write_signal_check(fss_write_main_t * const main);
-#endif // _di_fss_write_signal_check_
-
-/**
* Signal handler for signals/interrupts.
*
* This blocks until an expected signal is recieved.
for (;;) {
- if (!((++main->program.signal_check) % fss_write_signal_check_d)) {
- if (fll_program_standard_signal_received(&main->program)) {
- fll_program_print_signal_received(&main->program.warning, main->program.signal_received);
-
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- break;
- }
-
- main->program.signal_check = 0;
- }
+ if (macro_fss_write_signal_check(&main->program, &main->setting.state)) break;
if (range.start > range.stop) {
if (status_pipe == F_okay_eof) break;
fss_write_setting_load(arguments, &data, &fss_write_payload_setting_load);
}
- if (!fss_write_signal_check(&data)) {
+ if (!macro_fss_write_signal_check(&data.program, &data.setting.state)) {
fss_write_main(&data);
}
for (j = 0; j < data->vocabularys.array[i].used; ++j) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
if (main->setting.replace.used) {
k = main->setting.replace.used - 1;
iki_read_setting_load(arguments, &data, &iki_read_eki_setting_load);
}
- if (!iki_read_signal_check(&data)) {
+ if (!macro_iki_read_signal_check(&data.program, &data.setting.state)) {
iki_read_main(&data);
}
for (i = 0; i < data->vocabularys.used; ++i) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
for (j = 0; j < data->vocabularys.array[i].used; ++j) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
for (k = 0; k < main->setting.names.used; ++k) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
if (f_compare_dynamic_partial_string(main->setting.names.array[k].string, main->cache.buffer, main->setting.names.array[k].used, data->vocabularys.array[i].array[j]) == F_equal_to) {
matched |= 0x1;
else if (main->setting.flag & iki_read_main_flag_line_d) {
for (i = 0; F_status_is_error_not(main->setting.state.status) && i < data->variable.used; ++i) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
iki_read_eki_process_buffer_at(main, i);
iki_read_process_buffer_at_newline(main);
else {
for (i = 0; F_status_is_error_not(main->setting.state.status) && i < data->variable.used; ++i) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
iki_read_eki_process_buffer_at(main, i);
iki_read_process_buffer_at_newline(main);
for (i = 0; i < data->variable.used; ++i) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
if (main->call.print_data) {
main->call.print_data(&main->program.output, i);
while (i <= range_buffer->stop && j < stop) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
if (i < data->variable.array[j].start) {
range_buffer->start = i;
for (i = 0; i < main->program.parameters.array[iki_read_parameter_name_e].values.used; ++i) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
index = main->program.parameters.array[iki_read_parameter_name_e].values.array[i];
name.used = 0;
for (j = 0; j < data->vocabularys.used; ++j) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
for (k = 0; k < data->vocabularys.array[j].used; ++k) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
main->setting.state.status = f_compare_dynamic_partial(name, main->cache.buffer, range, data->vocabularys.array[j].array[k]);
for (i = 0; i < data->vocabulary.used; ++i) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
if (main->setting.replace.used) {
main->setting.map_replacess.array[i].used = 0;
iki_read_setting_load(arguments, &data, &iki_read_iki_setting_load);
}
- if (!iki_read_signal_check(&data)) {
+ if (!macro_iki_read_signal_check(&data.program, &data.setting.state)) {
iki_read_main(&data);
}
for (i = 0; i < data->vocabulary.used; ++i) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
if (f_compare_dynamic_partial_string(main->setting.names.array[j].string, main->cache.buffer, main->setting.names.array[j].used, data->vocabulary.array[i]) == F_equal_to) {
matched |= 0x1;
else if (main->setting.flag & iki_read_main_flag_line_d) {
for (i = 0; F_status_is_error_not(main->setting.state.status) && i < data->variable.used; ++i) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
iki_read_iki_process_buffer_at(main, i);
iki_read_process_buffer_at_newline(main);
else {
for (i = 0; F_status_is_error_not(main->setting.state.status) && i < data->variable.used; ++i) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
iki_read_iki_process_buffer_at(main, i);
iki_read_process_buffer_at_newline(main);
for (i = 0; i < data->variable.used; ++i) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
if (main->call.print_data) {
main->call.print_data(&main->program.output, i);
while (i <= range_buffer->stop && j < stop) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
if (i < data->variable.array[j].start) {
range_buffer->start = i;
for (i = 0; i < main->program.parameters.array[iki_read_parameter_name_e].values.used; ++i) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
index = main->program.parameters.array[iki_read_parameter_name_e].values.array[i];
name.used = 0;
for (j = 0; j < data->vocabulary.used; ++j) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
main->setting.state.status = f_compare_dynamic_partial(name, main->cache.buffer, range, data->vocabulary.array[j]);
* The program signal defines.
*
* iki_read_signal_*_d:
- * - check: Number of iterations before performing signal check in non-threaded signal handling.
* - check_failsafe: When using threads, how many consecutive failures to check signal before aborting (as a recursion failsafe).
- * - check_tiny: The tiny check.
- * - check_short: The short signal check.
*/
#ifndef _di_iki_read_signal_d_
- #define iki_read_signal_check_d 500000
#define iki_read_signal_check_failsafe_d 20000
- #define iki_read_signal_check_tiny_d 4
- #define iki_read_signal_check_short_d 16
#endif // _di_iki_read_signal_d_
+/**
+ * A macro wrapping the appropriate signal check function based on threaded/non-threaded support.
+ */
+#ifndef _di_iki_read_signal_check_d_
+ #ifdef _di_thread_support_
+ #define macro_iki_read_signal_check(program, state) fll_program_signal_check_loop(program, state)
+ #else
+ #define macro_iki_read_signal_check(program, state) fll_program_signal_check_simple(program, state)
+ #endif // _di_thread_support_
+#endif // _di_iki_read_signal_check_d_
+
#ifdef __cplusplus
} // extern "C"
#endif
for (f_number_unsigned_t i = 0; i < main->setting.files.used; ++i) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
file.stream = 0;
file.id = -1;
for (size_read = 0; size_read < size_file; size_read += size_block) {
- if (size_file > iki_read_block_max_d && iki_read_signal_check(main)) break;
+ if (size_file > iki_read_block_max_d && macro_iki_read_signal_check(&main->program, &main->setting.state)) break;
main->setting.state.status = f_file_stream_read_until(file, size_block, &main->cache.buffer);
if (F_status_is_error(main->setting.state.status)) break;
for (f_number_unsigned_t first = 0; range.start <= range.stop && range.start < main->cache.expand.used; ) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
main->setting.state.status = f_string_dynamic_seek_line(main->cache.expand, &range);
if (F_status_is_error(main->setting.state.status)) return;
for (; range.start <= range.stop && range.start < main->cache.expand.used; ++total, ++range.start) {
- if (iki_read_signal_check(main)) return;
+ if (macro_iki_read_signal_check(&main->program, &main->setting.state)) return;
main->setting.state.status = f_string_dynamic_seek_line(main->cache.expand, &range);
if (F_status_is_error(main->setting.state.status)) return;
* F_data_not on success, but total is 0 or line is out of range.
*
* Error (with error bit set) from f_string_dynamic_seek_line().
- * Error (with error bit set) from iki_read_signal_check().
+ * Error (with error bit set) from macro_iki_read_signal_check().
*
* Error (with error bit) if status already has an error before start of function.
*/
* F_okay on success and data was processed.
* F_data_not on success, but there was no data to process (0 is printed).
*
- * Signal from iki_read_signal_check().
+ * Signal from macro_iki_read_signal_check().
*
* Error (with error bit set) from f_string_dynamic_seek_line()
*
* @see f_string_dynamic_seek_line()
*
- * @see iki_read_signal_check()
+ * @see macro_iki_read_signal_check()
*/
#ifndef _di_iki_read_print_data_total_
extern void iki_read_print_data_total(fl_print_t * const print, const f_number_unsigned_t);
* F_data_not on success, but total is 0 or line is out of range.
*
* Error (with error bit set) from f_string_dynamic_seek_line().
- * Error (with error bit set) from iki_read_signal_check().
+ * Error (with error bit set) from macro_iki_read_signal_check().
*
* Error (with error bit) if status already has an error before start of function.
*
* @see f_string_dynamic_seek_line()
- * @see iki_read_signal_check()
+ * @see macro_iki_read_signal_check()
*/
#ifndef _di_iki_read_print_data_line_total_expand_
extern void iki_read_print_data_total_expand(fl_print_t * const print);
extern "C" {
#endif
-#if !defined(_di_iki_read_signal_check_) && defined(_di_thread_support_)
- f_status_t iki_read_signal_check(iki_read_main_t * const main) {
-
- if (!main) return F_false;
- if (main->program.signal_received) return F_true;
-
- if (!((++main->program.signal_check) % iki_read_signal_check_d)) {
- if (F_status_set_fine(fll_program_standard_signal_received(&main->program)) == F_interrupt) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- main->program.signal_check = 0;
- }
-
- return F_false;
- }
-#endif // !defined(_di_iki_read_signal_check_) && defined(_di_thread_support_)
-
-#if !defined(_di_iki_read_signal_check_) && !defined(_di_thread_support_)
- f_status_t iki_read_signal_check(iki_read_main_t * const main) {
-
- if (!main) return F_false;
-
- if (main->program.signal_received) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- return F_false;
- }
-#endif // !defined(_di_iki_read_signal_check_) && !defined(_di_thread_support_)
-
#if !defined(_di_iki_read_signal_handler_) && !defined(_di_thread_support_)
void iki_read_signal_handler(iki_read_main_t * const main) {
#endif
/**
- * Check to see if a signal is received.
- *
- * If main.signal is non-zero, then this handles the following signals:
- * - F_signal_abort
- * - F_signal_broken_pipe
- * - F_signal_hangup
- * - F_signal_interrupt
- * - F_signal_quit
- * - F_signal_termination
- *
- * There is a threaded and a non-threaded version of this.
- * The non-threaded version checks periodically using iki_read_signal_check_d and updates main->signal_check as needed.
- * The threaded version checks the flag state which is set by a separate thread that is blocking until signal is received.
- *
- * @param main
- * The main program and settings data.
- *
- * This does not alter main.setting.state.status.
- *
- * @return
- * F_true on signal received.
- * F_false otherwise.
- *
- * @see iki_read_signal_handler()
- *
- * @see fll_program_standard_signal_received()
- */
-#ifndef _di_iki_read_signal_check_
- extern f_status_t iki_read_signal_check(iki_read_main_t * const main);
-#endif // _di_iki_read_signal_check_
-
-/**
* Signal handler for signals/interrupts.
*
* This blocks until an expected signal is recieved.
// Construct the array without allocating any more memory by setting this as a static string (used > 0, size = 0).
for (index = 0; at_object < object->values.used; ) {
- if (iki_write_signal_check(main)) return;
+ if (macro_iki_write_signal_check(&main->program, &main->setting.state)) return;
main->setting.state.status = f_memory_array_increase(main->setting.state.step_small, sizeof(f_string_dynamic_t), (void **) &objectss->array[objectss->used].array, &objectss->array[objectss->used].used, &objectss->array[objectss->used].size);
// Construct the array without allocating any more memory by setting this as a static string (used > 0, size = 0).
for (index = 0; main->setting.contents.used < content->values.used; ) {
- if (iki_write_signal_check(main)) return;
+ if (macro_iki_write_signal_check(&main->program, &main->setting.state)) return;
index = content->values.array[main->setting.contents.used];
iki_write_setting_load(arguments, &data, &iki_write_eki_setting_load);
}
- if (!iki_write_signal_check(&data)) {
+ if (!macro_iki_write_signal_check(&data.program, &data.setting.state)) {
iki_write_main(&data);
}
for (; range_object.start <= range_object.stop; ++total) {
- if (iki_write_signal_check(main)) return;
+ if (macro_iki_write_signal_check(&main->program, &main->setting.state)) return;
main->setting.state.status = f_string_dynamic_seek_to(main->cache.buffer, f_string_ascii_space_back_s.string[0], &range_object);
for (; i < total; ++i) {
- if (iki_write_signal_check(main)) return;
+ if (macro_iki_write_signal_check(&main->program, &main->setting.state)) return;
main->cache.objects.array[main->cache.objects.used].used = 0;
// Construct the array without allocating any more memory by setting this as a static string (used > 0, size = 0).
for (index = 0; main->setting.objectss.used < values->used; ) {
- if (iki_write_signal_check(main)) return;
+ if (macro_iki_write_signal_check(&main->program, &main->setting.state)) return;
main->setting.state.status = f_memory_arrays_resize(1, sizeof(f_string_dynamic_t), (void **) &main->setting.objectss.array[main->setting.objectss.used].array, &main->setting.objectss.array[main->setting.objectss.used].used, &main->setting.objectss.array[main->setting.objectss.used].size, &f_string_dynamics_delete_callback);
// Construct the array without allocating any more memory by setting this as a static string (used > 0, size = 0).
for (index = 0; main->setting.contents.used < values->used; ) {
- if (iki_write_signal_check(main)) return;
+ if (macro_iki_write_signal_check(&main->program, &main->setting.state)) return;
index = values->array[main->setting.contents.used];
iki_write_setting_load(arguments, &data, &iki_write_iki_setting_load);
}
- if (!iki_write_signal_check(&data)) {
+ if (!macro_iki_write_signal_check(&data.program, &data.setting.state)) {
iki_write_main(&data);
}
* The program signal defines.
*
* iki_write_signal_*_d:
- * - check: Number of iterations before performing signal check in non-threaded signal handling.
* - check_failsafe: When using threads, how many consecutive failures to check signal before aborting (as a recursion failsafe).
- * - check_tiny: The tiny check.
- * - check_short: The short signal check.
*/
#ifndef _di_iki_write_signal_d_
- #define iki_write_signal_check_d 500000
#define iki_write_signal_check_failsafe_d 20000
- #define iki_write_signal_check_tiny_d 4
- #define iki_write_signal_check_short_d 16
#endif // _di_iki_write_signal_d_
+/**
+ * A macro wrapping the appropriate signal check function based on threaded/non-threaded support.
+ */
+#ifndef _di_iki_write_signal_check_d_
+ #ifdef _di_thread_support_
+ #define macro_iki_write_signal_check(program, state) fll_program_signal_check_loop(program, state)
+ #else
+ #define macro_iki_write_signal_check(program, state) fll_program_signal_check_simple(program, state)
+ #endif // _di_thread_support_
+#endif // _di_byte_dump_signal_check_d_
+
#ifdef __cplusplus
} // extern "C"
#endif
range.start = 0;
do {
- if (iki_write_signal_check(main)) return;
+ if (macro_iki_write_signal_check(&main->program, &main->setting.state)) return;
if (status != F_okay_eof) {
status = f_file_read(pipe, &main->cache.buffer);
if (F_status_is_error_not(main->setting.state.status) && F_status_set_fine(main->setting.state.status) != F_interrupt) {
for (f_number_unsigned_t i = 0; i < main->setting.objectss.used; ++i) {
- if (iki_write_signal_check(main)) return;
+ if (macro_iki_write_signal_check(&main->program, &main->setting.state)) return;
main->call.process_objects_content((void *) main, main->setting.objectss.array[i], main->setting.contents.array[i]);
if (F_status_is_error(main->setting.state.status)) break;
extern "C" {
#endif
-#if !defined(_di_iki_write_signal_check_) && defined(_di_thread_support_)
- f_status_t iki_write_signal_check(iki_write_main_t * const main) {
-
- if (!main) return F_false;
- if (main->program.signal_received) return F_true;
-
- if (!((++main->program.signal_check) % iki_write_signal_check_d)) {
- if (F_status_set_fine(fll_program_standard_signal_received(&main->program)) == F_interrupt) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- main->program.signal_check = 0;
- }
-
- return F_false;
- }
-#endif // !defined(_di_iki_write_signal_check_) && defined(_di_thread_support_)
-
-#if !defined(_di_iki_write_signal_check_) && !defined(_di_thread_support_)
- f_status_t iki_write_signal_check(iki_write_main_t * const main) {
-
- if (!main) return F_false;
-
- if (main->program.signal_received) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- return F_false;
- }
-#endif // !defined(_di_iki_write_signal_check_) && !defined(_di_thread_support_)
-
#if !defined(_di_iki_write_signal_handler_) && !defined(_di_thread_support_)
void iki_write_signal_handler(iki_write_main_t * const main) {
#endif
/**
- * Check to see if a signal is received.
- *
- * If main.signal is non-zero, then this handles the following signals:
- * - F_signal_abort
- * - F_signal_broken_pipe
- * - F_signal_hangup
- * - F_signal_interrupt
- * - F_signal_quit
- * - F_signal_termination
- *
- * There is a threaded and a non-threaded version of this.
- * The non-threaded version checks periodically using iki_write_signal_check_d and updates main->signal_check as needed.
- * The threaded version checks the flag state which is set by a separate thread that is blocking until signal is received.
- *
- * @param main
- * The main program and settings data.
- *
- * This does not alter main.setting.state.status.
- *
- * @return
- * F_true on signal received.
- * F_false otherwise.
- *
- * @see iki_write_signal_handler()
- *
- * @see fll_program_standard_signal_received()
- */
-#ifndef _di_iki_write_signal_check_
- extern f_status_t iki_write_signal_check(iki_write_main_t * const main);
-#endif // _di_iki_write_signal_check_
-
-/**
* Signal handler for signals/interrupts.
*
* This blocks until an expected signal is recieved.
status_code_setting_load(arguments, &data);
}
- if (!status_code_signal_check(&data)) {
+ if (!macro_status_code_signal_check(&data.program, &data.setting.state)) {
status_code_main(&data);
}
* The program signal defines.
*
* status_code_signal_*_d:
- * - check: Number of iterations before performing signal check in non-threaded signal handling.
* - check_failsafe: When using threads, how many consecutive failures to check signal before aborting (as a recursion failsafe).
- * - check_tiny: The tiny check.
- * - check_short: The short signal check.
*/
#ifndef _di_status_code_signal_d_
- #define status_code_signal_check_d 500000
#define status_code_signal_check_failsafe_d 20000
- #define status_code_signal_check_tiny_d 4
- #define status_code_signal_check_short_d 16
#endif // _di_status_code_signal_d_
+/**
+ * A macro wrapping the appropriate signal check function based on threaded/non-threaded support.
+ */
+#ifndef _di_status_code_signal_check_d_
+ #ifdef _di_thread_support_
+ #define macro_status_code_signal_check(program, state) fll_program_signal_check_loop(program, state)
+ #else
+ #define macro_status_code_signal_check(program, state) fll_program_signal_check_simple(program, state)
+ #endif // _di_thread_support_
+#endif // _di_status_code_signal_check_d_
+
#ifdef __cplusplus
} // extern "C"
#endif
status_code_setting_load(arguments, &data);
}
- if (!status_code_signal_check(&data)) {
+ if (!macro_status_code_signal_check(&data.program, &data.setting.state)) {
status_code_main(&data);
}
extern "C" {
#endif
-#if !defined(_di_status_code_signal_check_) && defined(_di_thread_support_)
- f_status_t status_code_signal_check(status_code_main_t * const main) {
-
- if (!main) return F_false;
- if (main->program.signal_received) return F_true;
-
- if (!((++main->program.signal_check) % status_code_signal_check_d)) {
- if (F_status_set_fine(fll_program_standard_signal_received(&main->program)) == F_interrupt) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- main->program.signal_check = 0;
- }
-
- return F_false;
- }
-#endif // !defined(_di_status_code_signal_check_) && defined(_di_thread_support_)
-
-#if !defined(_di_status_code_signal_check_) && !defined(_di_thread_support_)
- f_status_t status_code_signal_check(status_code_main_t * const main) {
-
- if (!main) return F_false;
-
- if (main->program.signal_received) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- return F_false;
- }
-#endif // !defined(_di_status_code_signal_check_) && !defined(_di_thread_support_)
-
#if !defined(_di_status_code_signal_handler_) && !defined(_di_thread_support_)
void status_code_signal_handler(status_code_main_t * const main) {
#endif
/**
- * Check to see if a signal is received.
- *
- * If main.signal is non-zero, then this handles the following signals:
- * - F_signal_abort
- * - F_signal_broken_pipe
- * - F_signal_hangup
- * - F_signal_interrupt
- * - F_signal_quit
- * - F_signal_termination
- *
- * There is a threaded and a non-threaded version of this.
- * The non-threaded version checks periodically using status_code_signal_check_d and updates main->signal_check as needed.
- * The threaded version checks the flag state which is set by a separate thread that is blocking until signal is received.
- *
- * @param main
- * The main program and settings data.
- *
- * This does not alter main.setting.state.status.
- *
- * @return
- * F_true on signal received.
- * F_false otherwise.
- *
- * @see status_code_signal_handler()
- *
- * @see fll_program_standard_signal_received()
- */
-#ifndef _di_status_code_signal_check_
- extern f_status_t status_code_signal_check(status_code_main_t * const main);
-#endif // _di_status_code_signal_check_
-
-/**
* Signal handler for signals/interrupts.
*
* This blocks until an expected signal is recieved.
for (f_number_unsigned_t i = 0; i < main->program.parameters.remaining.used; ++i) {
- if (status_code_signal_check(main)) break;
+ if (macro_status_code_signal_check(&main->program, &main->setting.state)) break;
status = main->setting.state.status;
for (f_number_unsigned_t i = 0; i < main->program.parameters.remaining.used; ++i) {
- if (status_code_signal_check(main)) break;
+ if (macro_status_code_signal_check(&main->program, &main->setting.state)) break;
status = main->setting.state.status;
for (f_number_unsigned_t i = 0; i < main->program.parameters.remaining.used; ++i) {
- if (status_code_signal_check(main)) break;
+ if (macro_status_code_signal_check(&main->program, &main->setting.state)) break;
status = main->setting.state.status;
for (i = 0; F_status_is_error_not(main->setting.state.status) && i < main->setting.buffer.used; ) {
- if (utf8_signal_check(main)) return;
+ if (macro_utf8_signal_check(&main->program, &main->setting.state)) return;
main->setting.state.status = F_okay;
for (i = 0; F_status_is_error_not(main->setting.state.status) && i < main->setting.buffer.used; ) {
- if (utf8_signal_check(main)) return;
+ if (macro_utf8_signal_check(&main->program, &main->setting.state)) return;
main->setting.state.status = F_okay;
* The program signal defines.
*
* utf8_signal_*_d:
- * - check: Number of iterations before performing signal check in non-threaded signal handling.
* - check_failsafe: When using threads, how many consecutive failures to check signal before aborting (as a recursion failsafe).
- * - check_tiny: The tiny check.
- * - check_short: The short signal check.
*/
#ifndef _di_utf8_signal_d_
- #define utf8_signal_check_d 500000
#define utf8_signal_check_failsafe_d 20000
- #define utf8_signal_check_tiny_d 4
- #define utf8_signal_check_short_d 16
#endif // _di_utf8_signal_d_
+/**
+ * A macro wrapping the appropriate signal check function based on threaded/non-threaded support.
+ */
+#ifndef _di_utf8_signal_check_d_
+ #ifdef _di_thread_support_
+ #define macro_utf8_signal_check(program, state) fll_program_signal_check_loop(program, state)
+ #else
+ #define macro_utf8_signal_check(program, state) fll_program_signal_check_simple(program, state)
+ #endif // _di_thread_support_
+#endif // _di_utf8_signal_check_d_
+
#ifdef __cplusplus
} // extern "C"
#endif
utf8_setting_load(arguments, &data);
}
- if (!utf8_signal_check(&data)) {
+ if (!macro_utf8_signal_check(&data.program, &data.setting.state)) {
utf8_main(&data);
}
for (; text.string[0] && F_status_is_error_not(main->setting.state.status); ) {
- if (utf8_signal_check(main)) return;
+ if (macro_utf8_signal_check(&main->program, &main->setting.state)) return;
main->setting.state.status = F_okay;
extern "C" {
#endif
-#if !defined(_di_utf8_signal_check_) && defined(_di_thread_support_)
- f_status_t utf8_signal_check(utf8_main_t * const main) {
-
- if (!main) return F_false;
- if (main->program.signal_received) return F_true;
-
- if (!((++main->program.signal_check) % utf8_signal_check_d)) {
- if (F_status_set_fine(fll_program_standard_signal_received(&main->program)) == F_interrupt) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- main->program.signal_check = 0;
- }
-
- return F_false;
- }
-#endif // !defined(_di_utf8_signal_check_) && defined(_di_thread_support_)
-
-#if !defined(_di_utf8_signal_check_) && !defined(_di_thread_support_)
- f_status_t utf8_signal_check(utf8_main_t * const main) {
-
- if (!main) return F_false;
-
- if (main->program.signal_received) {
- main->setting.state.status = F_status_set_error(F_interrupt);
-
- return F_true;
- }
-
- return F_false;
- }
-#endif // !defined(_di_utf8_signal_check_) && !defined(_di_thread_support_)
-
#if !defined(_di_utf8_signal_handler_) && !defined(_di_thread_support_)
void utf8_signal_handler(utf8_main_t * const main) {
#endif
/**
- * Check to see if a signal is received.
- *
- * If main.signal is non-zero, then this handles the following signals:
- * - F_signal_abort
- * - F_signal_broken_pipe
- * - F_signal_hangup
- * - F_signal_interrupt
- * - F_signal_quit
- * - F_signal_termination
- *
- * There is a threaded and a non-threaded version of this.
- * The non-threaded version checks periodically using utf8_signal_check_d and updates main->signal_check as needed.
- * The threaded version checks the flag state which is set by a separate thread that is blocking until signal is received.
- *
- * @param main
- * The main program and settings data.
- *
- * This does not alter main.setting.state.status.
- *
- * @return
- * F_true on signal received.
- * F_false otherwise.
- *
- * @see utf8_signal_handler()
- *
- * @see fll_program_standard_signal_received()
- */
-#ifndef _di_utf8_signal_check_
- extern f_status_t utf8_signal_check(utf8_main_t * const main);
-#endif // _di_utf8_signal_check_
-
-/**
* Signal handler for signals/interrupts.
*
* This blocks until an expected signal is recieved.
for (f_number_unsigned_t i = 0; i < main->setting.path_files_from.used && F_status_is_error_not(main->setting.state.status); ++i) {
- if (utf8_signal_check(main)) return;
+ if (macro_utf8_signal_check(&main->program, &main->setting.state)) return;
utf8_print_data_section_header_file(&main->program.output, main->setting.path_files_from.array[i], i);
if (F_status_is_error_not(main->setting.state.status) && main->setting.remaining.used) {
for (f_number_unsigned_t i = 0; F_status_is_error_not(main->setting.state.status) && i < main->setting.remaining.used; ++i) {
- if (utf8_signal_check(main)) return;
+ if (macro_utf8_signal_check(&main->program, &main->setting.state)) return;
utf8_print_data_section_header_parameter(&main->program.output, i);
projects / fll / commitdiff