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.

Update: Clarify precedence of the --name, --at, and --line for IKI Read.

Add description of the order of operations, or precedence, for the `--name`, `--at`, and the `--line` parameters.

Progress: Continue fixing iki_read (and eki_read) for runtime tests.

Minor changes that I started working on before vacation.
I forgot to write the notes and make a commit.

I appear to have changed some of the name parameter handling.
There is a clear bug where I mistakingly used the wrong array for a range check in a loop.

Use the state status rather than a custom status for managing the status.

Some of the print parameters are using the output.to directly rather than the print variable passed to the function.

Correct some of the function documentation.

there are still 165 test failures that I need to review.

Progress: Continue fixing iki_read (and eki_read) for runtime tests.

Some of the non-whole (as in the `--whole` parameter) runtime tests are actually invalid.
Update them with the correct results.
I manually reviewed most of these and found that the update is more correct.

I will back port these tests and fix the 0.6.x branch accordingly.

Progress: Continue fixing iki_read (and eki_read).

This addresses some of the `--total` processing.
It looks like I had not completed a lot of that code.
Much of that is added back.

I also noticed that I need to keep tabs on the `--select` parameter.
I will need tests for this and I may have missed some logic cases.
My first objective is to just get the 0.6.x runtime tests to work in 0.7.x.
(Or, I need to fix the 0.6.x tests to be correct.)

The expected next steps:
- Review and address what is left for IKI Read that is incorrect.
- For anything identified in the 0.6.x runtime tests that is invalid shall be fixed in 0.6.x.
- Update the EKI Read with all of the changes from IKI Read.
- Make a copy of the IKI Read runtime tests and see how EKI Read passes or fails.
- Address unexpected failures.
- Fix the tests for expected failures, which would be relating to having multiple Vocabularies/Objects.
- Write all of the new runtime tests for EKI Read.
- Make sure everything all passes.
- I probably need to update the help and describe the order of operations for some parameters.

Progress: Continue fixing iki_read (and eki_read).

I am using the 0.6.x iki_read runtime tests files to help identify problems.
This will also help identify problems with the 0.6.x iki_read.
(Of which I believe that there are some.)

This has a huge focus on addressing the `--line` and `--total`.
There are still known problems to solve, such as:
```
iki_read tests/runtime/iki/source/test-0000-basic.iki -L -a 1 -n hello
iki_read tests/runtime/iki/source/test-0000-basic.iki -L -a 1 -n hello -t
```

The EKI code is being partially updated while I am working on the IKI code.
However, big parts of it that are outdated are being left alone until I have IKI working correctly.
I will then update EKI accordingly and write the appropriate runtime tests.

Progress: Continue fixing iki_read (and eki_read).

There is overlap between how `--at` and `--line` work when not using `--whole`.
Do not treat using both as an error.
Instead, just have `--at` be the higher priority and then perform `--line`.
This results in a `--line` that can only potentially print something if it has a value of 0.

This is only the case for `--object`.
Both the `--content` and the `--literal` may potentially have multiple lines.

I removed the existing `--line` logic.
I will rewrite the logic for determining the number of lines when printing the `--literal` or the `--content`.
There will also need to be another file that haas multiple iki lines.

I was adding the line break behavior to break out of the loop when the line matches.
Much of that, but not all of that, has been removed until I come back to write the new logic.

The runtime tests are not yet updated.

Progress: Continue fixing iki_read (and eki_read).

This brings in the recently added 0.6.x runtime tests as-is.

Address some of the failures, such as the `--total` parameter.

I expected failures due to the incomplete state of the 0.7.x iki_read code (as a result of recent changes).

I will then need to add the eki_read runtime tests and add the `-s`/`--select` runtime tests once the existing problems are resolved.

Cleanup: Improve spacing style for fss_read generate.sh test script.

Add spacing to allow for lining up the lines to make it much easier to scan through with human eyes.

Update: IKI Read help message regarding --line parameter.

Make the `--line` parameter help message consistent with recent changes from the 0.6.x stable branch.

Update: Improve error reporting in runtime tests during generation.

The generation now prints the specific command that failed.

Progress: Begin fixing iki_read (and eki_read).

I noticed a lot of issues and fixed the problems on the 0.6 branch first.
This caused me to jump around back and forth a lot for the 0.7 branch.

This disoriented me.
I decided that I am going to commit this current state as a progress commit.
I will write the runtime tests for the 0.6 branch.
Then I will port those over to this.
Then I will use the runtime tests to help identify where I last was and what I need to change or finish changing.

The `--select` settings also need to be updated with regards to this.

Feature: Add support for eki_read program by extending iki_read, also adding --select and changing --substitute.

The eki_read is a variation of iki_read that instead supports the Extended IKI standard, known as EKI.

The iki_read and eki_read share common code.

This introduces a new parameter called `--select` or `-s`.
This allows for selecting the Vocabulary name (Object) at a given index.
I specifically chose `-s` to make the behavior more closely in line with the `-s` and `--select` from the fss_read programs.
The only difference being that the fss_read programs operate on the Content rather than the Object.

This decision forces the `--substitute` to now use `-S` instead of `-s`.
This is a breaking change that I will not back port.
The use of `--substitute` will still work with the 0.7 and 0.6 releases.

This completes the following progress commits:
- 21ae35744a1cfc7703fe3ac13b25ff7a71fa2d59
- dbc2fc03c4edd96611e07317a2c876f412017d2c
- 21ae35744a1cfc7703fe3ac13b25ff7a71fa2d59

Progress: Continue eki_read program by extending iki_read.

IKI/EKI Vocabularies (Objects) may not have spaces.
This means that I can safely print the list of Objects with a space between.
All Objects on a single line in `--object` mode will represent the objects assigned to that particular IKI/EKI variable.