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.

Progress: Continue eki_read program by extending iki_read.

This refactors iki_read in regards to the wraps and replaces.
I have not done any testing of the wraps and the replaces yet.
I also need to consider exactly how I want the multiple parameters to be handled.

I need to think about how I want to handle printing Objects (`--object`) with EKI when there is more than one Object for a single Variable.

Progress: Begin adding eki_read program by extending iki_read.

Setup the most basic functionality.

Currently they are both performing iki_read functionality.

The two programs require a different data structure.
I need to plan on how to handle this.
I may end up using callbacks and possibly a void pointer for data.

Update: Simplify code slightly aad remove redundant `fll_program_print_help_header()` call.

Use the variable for `parameters` to simplify code.
This simplifies the code at the cost of using a variable.

Remove include that is not needed from the c files.

Update the documentation comments to have `Properties: `.

Remove redundant `fll_program_print_help_header()` call.

Cleanup: Use parameters pointer and relocate output.to assignment.

Relocate the `main->program.output.to` assignment to the top of the load settings functions.
This should better allow for printing to be properly used, sooner.

Setup the `parameters` as a pointer to `&main->program.parameters`.
This should help made the code easier to read by reducing the size of the code needed.

Cleanup: Add missing documentation comment and fix structure ordering.

Use alphabetic ordering when the dependencies are not forcing the order.

Cleanup: Build settings structure for iki_write.

Cleanup: Add new line in build settings files.

Update: Add clarifying documentation to some memory allocation functions.

Feature: Add eki_write program.

The eki_write program is now added and complete.

This resolves the progress commits for this, such as 740d5fc88d6e05edf2a7267c422642bd14cc473c.

There are no iki_write runtime tests yet, so this does not add any yet.

Update: The fss_read has missing our out of date information.

Add the android settings like is done for other settings files.

Use the hex digits rather than `f_true` and `f_false`.

The `fss_read_main_setting_load_as` callback appears to be missing.
I need to review the code to confirm/deny this particular behavior.

Progress: Begin adding the eki_write program by extending iki_write.

This is a bit rushed, so I will have additional passes to make.

Update: Improved documentation comments in f_memory functions.

I sometimes forget whether or not which type the "width" should be.
This adds additional documentation to hopefully make it more clear.

Update: Switch iki_write to using f_iki_write().

The old iki_write is using the simple processing functions.
Switch to using the dedicated `f_iki_write()` function.

Switch to using the main cache design.

Cleanup: Fix incorrect documentation comment for fss_read function.

Feature: Add fl_iki_eki_read(), add unit tests, and update existing stand alone builds.

Cleanup: Remove unused header include fo f_abstruse unit tests.

Update: The time specification, making it more flexible.

Improve the time specification to grant better control and flexibility on what it means to those implementing and using it.
Provide suggestions regarding IKI and EKI.
Remember, these are suggestions and are not requirements.

Bugfix: FSS Read unit tests, fix file names, and fix FSS-0008 test files.

I noticed that I had several of the test files misnamed.
Many of the test files should have a prefix of `name_` in from of parts of the file name relating to the name parameter.

I had originally created the test data for FSS-0008, FSS Embedded List Read, tests just using the output data as generated.
I knew that there was a good chance that any mistakes would be treated as valid.
This saved time and allowed me to work towards improvements.
I have identified and fixed several bugs.
This has then revealed that several of the tests have invalid data.
I manually reviewed several of these and confirmed that the newly generated code looks more correct.
There is still an opportunity for an oversight or mistake but I believe this is more progress forward.
My goal is not to spend too much time directly on this with the expectation that I will test and resolve these problems over time before a stable release.
This is more of a matter of time allocation and priorities rather than a technical correctness and accuracy issue.

Bugfix: Incorrect handling of "at" positions in FSS Embedded List Read.

The "at" position needs to be counted during all iterations.

Bugfix: The FSS Read process at should only process if index_at is non-zero.

The FSS Embedded Read recursive logic exposes this problem.

The at flag bit is set when the at parameter is passed.
The at parameter being passed when there are multiple depths does not mean that the specific depth in question should be using the at position.
Add a check that ensures that the current depth needs the at position processed.

Bugfix: Do not treat out of range depth as an error.

The FSS Embedded List Read should not treat out of range depth as an error.
This simply should return no results.

Update: Refresh the stand alone builds.

I ran the commands as written in the commented out parts of the config.h files.
The order of the defines somehow changed.

I must either have done something weird, wrong, or different last time to result in the differences.
To save time, I short circuited some of the process.
This means that there is a chance that I commented out defines that don't need to be commented out.

I've tested and confirmed that these compiles.
I have not checked the before and after sizes or symbols.

Bugfix: Add missing _di_f_print_except_in_dynamic_safely_ to private_f_print_except_in_safely().

Update: Fix IKI write and add EKI write functions for f_iki.

Fix the backslash handling now that I have figured that whole situation out and updated the specifications.

Adding support for the EKI write.

Add more extensive unit tests for both IKI write and EKI write.

I am trying to keep both the IKI write and the IKI write works functions as similar as possible.
The "works" write tests are already big enough anyway.
Implement a separate test for EKI, called `test__f_iki_eki_write__works_for_multiple`, to handle the multiple vocabularies case.
This will be structurally identical to the regular works tests but instead has multiple vocabularies.