Update: The fl_directory_do() documentation comments and tweak flags.

The documentation comments on how `fl_directory_do()` operates is now correctly updated.

Add an additional helper flag.

Improve use of flags in the process.

Bugfix: The fl_directory_do() needs to always process at the top level.

The top level directory is not being processed when the depth is less than the max depth.

Make sure to add the directory flag as well.

Update: The experimental fll.c.tags.

Cleanup: Remove private headers from installation build path.

Update: Add directory functions, re-design fl_directory_do().

Add several directory functions.
I still may need to add more, such as a rewind to handle rewinddir().

Change the directory recurse do flags from an enumeration to defines.
Add a type fo handling `DIR *` called `f_directory_stream_t`.

Get rid of the directory listing structure to reduce memory usage.
This is only possible by replacing the `scandir()` with custom direct processing.
This change reduces the number of looping and removes the sorting behavior.
The directory recurse do flags are now redesigned.
The `top` is now entirely removed because a depth of 0 can be used to test for top without needing a flag.
The `opendir()` still has a notable cost, especially during recursion.
I need to do more research into how to more efficiently call `opendir()` without consuming too much memory.
The documentation comments still needs to be reviewed following these changes.

Make sure the directory functions only update the id values if there is no error.

Explicitly check for `-1` as return error rather than `< 0` to be more consistent with the standards.

Use typedefs to define callbacks.

Tweak the `fl_directory_list()` design.
Tweak the `fl_directory_path_pop()` design.

Regression: Parent directory in recursion does not get processed properly.

The commit 8df0301badf6f38fcb4ddf73318e02708ad344f7 fixed a problem with the parent directory not being processed at all.
It failed to handle the situation where the child directory alters the path to append itself.

Save the parent directory path and then restore it after processing the child directory.

Many POSIX libc functions work on NULL termination where possible.
Make sure a NULL termination exists after restoring the path.

Update: Add recurse flag masks.

This adds `f_directory_recurse_do_flag_action_mask_e` and `f_directory_recurse_do_flag_top_mask_e`.
These are helper flags for existing flag sets as a convenience.

Bugfix: The fl_directory_do() needs to operate on the parent directory during recursion.

The parent directory must be processed after recursion during the recursion steps.
These should not have the `f_directory_recurse_do_flag_top_after_e` flags because these are not top level.
These must have action because the action is expected to be performed on the directory just like other file types.

Cleanup: Add missing function documentation for fll_program_standard_signal_received_wait().

Feature: Add fll_program_signal_check_loop() and fll_program_signal_check_simple().

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.

Cleanup: Remove unnecessary status checks in fl_directory_do().

These checks are performed later on in the code at the end of the loop without additional status changes in between.

Bugfix: The fl_directory_do() needs to pass f_directory_recurse_do_flag_directory_e at the top.

At the top, before recursion, the path is known to be a directory.
The flag `f_directory_recurse_do_flag_directory_e` must be passed to the callbacks to let the callbacks know this is a directory.

Bugfix: Directory recursion has incorrect status check resulting in early loop breakage.

The loop is breaking out early due to the incorrect boolean logic when checking if an interrupt signal has been received via the state status.

This bug was exposed by the (incomplete) kevux-tools program `remove`:
```shell
clear ; md a/b/c ; touch a/b/file ; remove a/b/ -r +V ; t a
```

Update: Switch to the global array for print messages for fll_program.

This migrates the string messages to a single array.
At this time the array as a whole is enabled/disabled via the macros.
This may result in more strings included that needed.

This provides a single location to manage the string messages.
This may help with different languages.

Update: Rebuild the disable build configs.

I haven't done this in a while and this needs to happen before releases.
This helps catch things up.

Cleanup: The FLL FSS Status String strings.

Remove the granular define wrapping structure that I am not using anymore.
Make sure to use the proper `_s_` naming strategy.
Simplify some of the names.

Cleanup: Improve language for the version parameter help.

Update: Ensure the FLL print help option functions support NULL description.

Cleanup: Print less technical messages about verbosity help.

Feature: Add fll_program function for printing unsupported parameter message.

Cleanup: Fix comment in f_directory_empty().

Cleanup: Change verbosity variable assignments structure.

Update: Copyright year to 2025.

I hadn't realized that I had not done this in January.
Now the copyright is correctly updated.

Cleanup: Documentation comments, adding _s, _e, and _d.

Feature: Add 'input' as file type error string.

The error type string `input` is needed to for cases like standard input processing.

Also fix the ordering of the file type error parameter for directory.

Feature: The standard input should be available in fll_program_data_t.

I am surprised that I hadn't ever gotten to standard input processing.
The functionality should exist but the programs haven't needed this as of yet.
This is most certainly going to be needed so add the support.

Cleanup: Use project-specific type F_file_flag_read_only_d.

Bugfix: Trailing semi-colon added at the end of the macro for f_time_spec_t.

The semi-colons should not be auto-added like this.
When adding the define inside an array, the semi-colon will cause compile problems that are hard to debug.

Feature: Add missing file type unknown string.

The string for unknown file type should be supported for consistency reasons.

Bugfix: Incorrect example in time specification regarding EpochTime.

The EpochTime uses two colons '::'.
Make sure the EpochTime examples appropriately communicates this.

Update: Add more file type documentation comments and add macro_f_file_type_clear().

The file type documentation comments now have more details.

The `macro_f_file_type_clear()` provides a way to clear only the file type bits.

Feature: Add support for unknown file type.

Bugfix: The macro _f_memory_NO_zeroing_on_larger_ is being applied on smaller.

If the new memory size is smalle, then the _f_memory_NO_zeroing_on_larger_ should not be used.

Update: The top-level directory recursion actions should have more fine-tuned control.

Provide `f_directory_recurse_do_flag_top_after_e` and `f_directory_recurse_do_flag_top_before_e` flags.
This requires increasing the size of the flags from `uint16_t` to `uint32_t`.

Be sure to pass the `path` rather than `recurse->path` at the top-level.

Make sure the `action` flag is set for the top-level action.

Add additional documentation comment regarding the `top` flag and the `recurse.path`.

Even though it is a listing of the path, still pass the `recurse.path` to the error handler at the top of `private_fl_directory_do_recurse()`.

Try to make the flag usage be ordered alphabetically.

Always perform the directory listing loading.
If this is not desired, then the `fl_directory_do()` function is likely not needed and simpler functions may be better choices.

Do not include the top-level flag for the directory listing for consistency with the recursion.
The recursion doesn't know the top-level, so do not set the top flag in this case.
The directory exists check is no longer needed and might have been redundant anyway.

Update the documentation comments.
I appear to have missed updating this in some of the previous commits that introduced operational changes.
Add additional documentation about checking the recurse parameter for NULL.

The private_fl_directory_do_recurse() already checks the error status.
Remove extra error checking after the `private_fl_directory_do_recurse()` call.
This extra error checking is redundant.
The return on error and return on done must still be performed.

After every private_inline_fl_directory_do_handle() call, the F_done is not being processed.
The check for `F_done` must be done for every single error handler call.
The only exception would be the last one in the top-level function because the function will always return after the last call anyway.

Update Featureless Make to work with the latest changes.

Cleanup: Further clarify the directory recrusion action callback parameters.

Cleanup: Use uint8_t instead of bool and reduce calls to remove() in f_directory_remove().

I am now thinking that `uint8_t` is better than `bool`.
In particular, because this allows for more flags down the road without breaking API or ABI.

Simplify the logic in `f_directory_remove()` to have only a single declaration of `remove()`.

Bugfix: Ensure that fl_directory_do() depth 0 may still list directory contents.

The caller may want to check if there are any files within the directory when the max depth is 0.
Load the directory listing if the list flag is passed even when max depth is 0.

Cleanup: Remove redundant resetting of directory used length.

Security: Incorrect variable printed in private_fl_directory_do_recurse().

This bug is considered a security issue because it is printing potentially unused memory addresses.

Feature: Add F_test status codes.

These codes are notably useful during the unit and runtime testing.

Cleanup: Remove unused variables created via a copy and paste mistake.

Cleanup: Make the object parameter array a constant pointer.

Cleanup: Fix incorrect statement in documentation.

The statement of "This is different from code:"build_sources_object"" for the build_sources_object documentation makes no sense.
Remove that part of the statement.
There are no functional changes to the specification, so the version date is unchanged.

Bugfix: Incorrect counter resets and related clean ups.

I overlooked some cases where the counter is not reset at the start of the loop.

Do some variable clean ups for code following similar logic.

Bugfix: Static build is not working, 'rcs' is not being appended.

I overlooked a case where the counter is not reset at the start of the loop.

I did some additional reviews of similar cases in the code and applied similar fixes.

Cleanup: Remove ':' from documentation line with "license".

The documentation comments should be written in a way that would be complaint with the FSS Basic or FSS Extended if they were not commented out.

Feature: Add more fine tuned build_name options.

The build names should support shared, static, program, object, and library.
Some of these may not be directly used.
They should still be loaded.
This is done to make the project compliant with the standard while allowing extendability/hackability.

Update: Bootstrap script needs iki_read and iki_write for fake_programs.

Bugfix: The sources and under parameters can have invalid slashes.

The directory path cleanup function is not being called for these due to an incorrect boolean value.

Rename `cleanups` to `directory` to make this more clear that this is about being a directory more so than it is about cleanups.

Fix out of date parameter type documentation comment.

Remove old todo comment.

Update: Add help message for fakefiles and testfiles.

Add a fakefile option for printing help.
I used a generic and easy to copy and paste message.

Update: Implement the static string array for the fll_error program.

This provides some centralization to the static strings to a single global array.
This uses an enumeration similar to the way the function strings in the programs are handled.
This enumeration does come with a cost.
However, adding all the strings together in a single location should have some technical benefits.

Update: Add programs to bootstrap script.

Add several programs to the bootstrap program for the stand alone build.

Fix a comment.

Cleanup: Reduce duplicate code in the fll_error print functions.

Populate the `type_name` via a nested ternary instead of an if else if blocks.
The if else if blocks are cleaner but I want to have the `type_name` be a constant variable.
This should help the compiler optimize the variable.

Replace a lot of the repeated styles with new private functions.
This reduces quite a bit of repeated lines of code based on common patterns.

I do intend to follow this up at a later date with a commit that moves all of the static strings into a global array.

Cleanup: Use the f_string_static_t macros for the f_string_dynamic_t macros.

The `macro_f_string_dynamic_t_initialize_1` and `macro_f_string_dynamic_t_initialize_2` should be using the word `string` rather than `array` for the first argument.
call the `f_string_static_t` macros for the respective `f_string_dynamic_t` macros.

Feature: Add F_add and F_remove status codes.

Update: IKI Write from main/data.callback to main/data.call.

Rename `callback` to `call` to e consistent with recent naming changes.

Update: IKI Read documentation comments should use main.call.

The `main.callback` was recently replaced with `main.call`.
These documentation comments were overlooked or otherwise missed.

Update: Help printing functions and callbacks.

Have most of the help printing functions that might be used as `fl_print_call_t` be consistent with that prototype structure.

Fix some issues where `data.callback` is still used and should now instead be `data.call`.

Update: Use f_console_parameters_t as a pointer and document fll_program_parameter_process_context_standard().

Make the use of `f_console_parameters_t` as a pointer for consistency purposes.

Some programs did this whereas other programs repeatedly called `main->program.parameters`.
This should no longer be the case.

The documentation comments should be referencing `fll_program_parameter_process_context_standard()` and now do.

Update: Switch from memcpy() to memmove() just in case.

This is a library and cannot guarantee that the sources do not overlap.
Change to `memmove()` to play it safe.

Update: Use *_settings_load_call_t for callbacks.

Switch these callbacks to use the typedef design.

Feature: Allow for the group and user functions to not require a write value.

Several of these functions can be used to just check the validity of an ID or name.
Use the NULL pointer case to support this rather than writing a completely new functions for this logic.

For example, the `f_account_group_id_by_name()` function can have NULL for the `id` parameter.
In this case, nothing is written for the `id` and the function does not error out on invalid parameter (for when `id` is NULL).
The same logic is applied for the `f_account_group_name_by_id()` for the `name` parameter.

The same logic is applied for both user functions.

The account by functions are not updated as this is not needed.
Update the documentation for the account by functions, documenting that NULL is not allowed.

Update: Use a constant for the argv in fss_write.

Update: Callback changes and improvements.

The `void *(*)(void *)` function structure is being used so add that as a function callback type `f_void_pointer_call_t`.

Add `fl_print_call_t` function callback type.

Rename the console parameter callback from `callback` to `on_match`.
Add `f_console_parameters_call_t` function callback type.
Fix documentation comment where `length` should instead be `used`.

The `void_main` are now replaced with literal `main` type now that the typedef structure improvements are in place.

Shorten the `callback` name to `call`.
Use more typedefs for functions.
This better takes advantage of how functions are a "first class citizen" in C.

Bugfix: Individual build problems with incorrect settings and dependencies.

The `f_abstruse` is not being included in some cases.

The `individual_thread` is not being used in some cases and instead `individual-thread` is being used.
Make sure `individual_thread` is the only form used.

Remove `f_parse` inclusion where it is not needed.

Add missing `-lf_compare`.

Bugfix: Incorrect ifndef for f_capability_user_set().

Cleanup: Fix spelling of comment.

Full sentences should have the first letter upper case.

Bugfix: Incorrect clear macro on f_account_t().

The `macro_f_account_t_clear()` is calling its own macro for the dynamic string values.
This is entirely incorrect.

Use the proper `macro_f_string_dynamic_t_clear()` macro calls.

Update: Add f_id_t, f_uid_t, and f_gid_t type helpers for uid_t and gid_t.

The `uid_t` and `gid_t` don't readily map to each other.

I would love to simplify the code and have a single function call in several cases when using both `uid_t` and `gid_t`.

This provides interchangeable types `f_id_t`, `f_uid_t`, and `f_gid_t`.
The standard behavior is that `f_uid_t` and `f_gid_t` are both sub-types of `f_id_t`.
The `f_id_t` is by default an unsigned 32-bit integer.

Feature: Add f_void_call_t as a standard function callback.

This is likely to be very common.
Set this up to make the code cleaner when using this callback.

There are no plans to implement any other types of callbacks as a standard.

Update: Improve directory recursion and its documentation.

Fix some problems in the `fl_directory_do()` documentation.
Extend the documentation adding more details of the process.

Remove redundant "is not error" status checks.

The checks like `if (flag_actions[j])` and `if (!flag_actions[j])` are now changed to respect the recently added `f_directory_recurse_do_flag_action_e` flag.

Update: Switch to typedef struct approach for safer callbacks inside structure f_directory_recurse_do_t.

Update all of the files and callbacks.

Cleanup: Add new line after typedef.

Update: Add specific action flag for directory do recursion and fix integer type.

Add a specific action flag to make it easier to explicitly test if this is the action pass of say `fl_directory_do()`.

Use  `uint16_t` to directly map to the flag integer type.

Update: Improve signal handling code.

Add a new line before printing the standard "Received signal code" message to ensure that it is always reasonably separated from the output being interrupted.

Simplify the verbosity variable check to a less than because the verbosity list is an enumeration.

Move the `fll_program_print_signal_received()` calls to the main program to help ensure consistent printing at the end of the program.
- Note: I am not certain if I want this instead in the main() function or not and I opted not to do so for now.

Fix some cases where the manual signal checks are still being performed to use the function instead.

Update: Document that the NULL characters are removed by fl_path_clean().

Update: The threaded signal handler to avoid signal id races.

Apply the same anti-race improvements implemented on the non-threaded signal checker to the threaded signal checker.

Still check for a negative id to prevent the signal message from being printed more than once.

Feature: Implement fll_program_standard_signal_received_wait().

The `fll_program_standard_signal_received_wait()` is now added because a lot of this code is repeated forr every single FLL program.

The `fll_program_standard_signal_received()` is refactored to return a status code to match the newly added `ll_program_standard_signal_received_wait()`.

The `status_signal` can now be moved into the main program settings structure.
The `status_signal` is renamed to `signal_status` to keep the naming more consistent.

This also exposes and fixes a race condition in how the pre-existing threaded signal handling is being used.
The check for `program.signal.id` that then opens a signal via `f_signal_open()` in the thread is not necessary because the signal id from the parent thread is preserved.
The `f_signal_close()` in the thread ends up prematurely closing the signal because the parent thread signal id is passed to the child thread.
The `main->program.signal.id == -1` checks in the signal check functions end up preventing the interrupt cancel from being triggered because of the `f_signal_close()` being called in a separate thread that shares the same signal id.

Feature: Add F_maximum and F_minimum status codes.

Bugfix: f_signal_close() should be setting signal id to -1 and not 0.

The signal id is a file descriptor and a non-valid file descriptor is -1 instead of 0.

Feature: Add fl_path_clean() for stripping out NULLs and redundant slashes.

Update: The fl_path_canonical() should handle the NULL cases.

Allow for NULL within the strings.
Update the processing code and add some unit tests.

The documentation comment about canonical->used being reset to 0 before processing is incorrect and is now removed.

Update: Use the pre-defined typedef structure style for the main program type.

Make sure that the typedef is defined early for a later defined type.
This allows for circular use of the main, such as with callbacks.

This is being done across all of my programs.

Cleanup: Fix function alphabetic ordering in unit tests.

Several of the test files have the parameter_checking function out of order.
I also happened to notice that the work test in some cases are also out of order.

This out of order is likely a problem caused by early day mass test generation.

Update: use directory back and current strings.

These should be used rather than the inline strings.

Feature: Add several reverse string search functions.

These "_back" functions work based on the stop position of the range.

Update: Add missing constant qualifiers and update function comments.

Some functions are missing the standard constant qualifier on the pointer parameters.

Improve grammar in some of the documentation comments.

Feature: Add new function fl_directory_empty().

Simplify the process of determining if the directory is empty.
The entire list of directories do not need to be processed in this case.
Only check if the first child in the directory exists.

Cleanup: Typo in documentation comments and add missing status codes to fl_directory_list().

Bugfix: Add missing disable define for private_fll_execute_path_arguments_fixate().

Cleanup: private_fl_payload_header_map_multis() needs _di_fl_fss_payload_header_map_ instead of _di_fl_fss_payload_header_maps_.

Cleanup: Remove extra "_map" from private function name.

Bugfix: The IKI and EKI specifications do not require escaping inside of Content.

This is an oops on my part.
I thought I was correcting something that I missed and I ended up causing a problem.
I think this problem was introduced in this commit: e9621b09db34cfd9ac6264c77068c34afa5bfb17.

Bugfix: Specification files need proper escaping for example code.

The IKI/EKI need to be properly escaped inside the example so that when the specification file itself is processed, the examples do not get substituted.

The examples that have what would be valid FSS Basic Lists also need to be escaped for the same reason.

Cleanup: Comments in examples in specifications must be escaped.

These comments are intended to be printed so that they can be shown as an example.
Escape them.

Update: Next micro version (0.7.1).

The following are the commands that I ran to make this change:
  # find build/ level_? specifications/ documents/ licenses/ -type f -exec sed -i -e 's|0\.7\.0|0.7.1|g' '{}' ';'
  # find build/ level_? specifications/ documents/ licenses/ -type f -exec sed -i -e 's|^version_micro 0|version_micro 1|g' '{}' ';'
  # find level_3/ -name *.h -exec sed -i -e 's|_program_version_micro_s F_string_ascii_0_s|_program_version_micro_s F_string_ascii_1_s|g' '{}' ';'
  # find level_3/ -name *.h -exec sed -i -e 's|_program_version_micro_s_length F_string_ascii_0_s_length|_program_version_micro_s_length F_string_ascii_1_s_length|g' '{}' ';'

Bugfix: Runtime tests are missing the main programs.

Add the appropriate programs to the `testfile`.
I probably overlooked this because the programs likely already exist in my PATH.

Update: The eki_read runtime tests.

I review a number of the tests but not all of them.
They look correct as far as I can tell.

Update: Finish fixing iki_read for runtime tests.

The iki_read must still print the unmatched variables.

The `iki_read_process_line()` is indeed still valid to have.

The total should still be printed even when there is no data or the start range is out of range.
This ensures that a 0 is printed in these situations.

There may or may not be eki_read fixes needed but runtime tests do not exist for that yet.
A follow up commit shall address this.

Update: Clarify precedence of the --select for IKI Read.

The `--select` parameter is processed after the `--line` parameter.