Cleanup: FSS Read testfile and related.

Add some new lines to the testfile.
Remove a redundant directory create operation in the testfile.
Remove the '=' character as it does not provide anything useful when printing the test status.

Regression: Incorrect parameter location used, breaking parameter processing.

The regression is introduced in commit 4c0ca86048e431de2025c39a3f5078b7248192eb.

I completely forgot that "location" is for the parameter location and is not the last value location.
Some part of me wanted a last value location.
Revert back to using "values.used - 1" instead of "location".

Progress: Add simple runtime testing scripts and testfile for fss_read.

This is an incredibly basic implementation.
I didn't bother to make is as flexible and portable as it could otherwise be.

Provide a way to test the runtime results of the fss_read programs.
I only got so far as to add tests for FSS Basic (FSS-0000) and FSS Extended (FSS-0001).

The tests for the FSS Extended (FSS-0001) currently has some failures.
I've noticed that I have not even implemented the --select functionality.
This is the likely cause for several of the test failures.

For now, I just cheated and used the 0.6.x version of the project to generate the expected output.
Any bugs in that output will be matched (ideally there are no bugs).
I did do a quick glance at some of these and they do look fine.

The source test files are copies of files I have used in the past but never made publicly available until now.

Bugfix: The set no EOL is misplaced on "extended" and should be on "basic_list".

The fss_read program is incorrectly settings the no EOL set function for the FSS Extended (0001) standard.
This should actually be on the FSS Basic List (0002) standard.

Bugfix: Remove extra (and invalid) processing of --select parameter.

This --select parameter is already processed and validated earlier in the settings load function.

Bugfix: Handle f_directory_not status as an invalid directory.

The status f_directory_not is returned with the path exists but is not a directory.

The fake program can fail when doing something like this:
  fake clean make -w /arbitrary_non_directory_file +V

The error message returned is not very helpful:
  ERROR: (674) when calling function f_file_stat().

This is a known file-related error and so it is now handled appropraitely.
The new error message looks like:
  ERROR: Invalid directory while trying to access directory '/arbitrary_non_directory_file'.

Bugfix: The testfile needs to handle the --build parameter and improve --work parameter handling.

Provide a new operation "build_path" to load the "--build" parameter properly.
The existing checks for the "--work" parameter is better suited checking against "work:value" rather than "work".

There may be an existing bug where the condition for "build" parameter is always returning true when it should not.
This requires further investigation and is not addressed within the scope of this commit.

Cleanup: Fix comments in settings-tests files.

Progress: Continue work on refactoring fss_*_read into fss_read, focusing on fixing issues.

Get the programs into better working state.
I found several problems resulting from the way in which I migrated and refactored the code.
I think the next thing to do is to instead start writing some runtime tests that can better find problems.

Of particular note, I found problems with the comments being printed properly (which generally means not printed).
Some parameter handling problems are also fixed.

The payload and embedded list need special handling and are very much not implemented.

Update: Make fss_read and fss_write --as consistent and fix spacing in help.

The fss_read is using -a already and instead uses -A for the --as.
Change fss_write to also use -A for consistency reasons.

Fix spacing alignment in printed help for the --as parameter.

Progress: Continue work on refactoring fss_*_read into fss_read.

Get the programs into better working state.
Now I need to next focus on ensuring that they work as expected.

The payload and embedded list need special handling and are very much not implemented.

Security: F_data_not is not being handled leading to invalid read or write.

At some point I changed the behavior to return F_data_not when the main string (usually buffer) has used set to 0.
I failed to update the FSS processing functions to handle this.

The documentation comments are also not up to date in this regard and is now updated.

Progress: Continue work on refactoring fss_*_read into fss_read.

This gets the programs compiling.
I decided not to get everything correct and instead decided to get everything compiling.

The memory allocation needs to be fixed.
There are a lot of fixme and todo comments to address.
The payload and embedded list need special handling and are very much not implemented.
Individual standard differences need to be handled (and some are stubbed out or copied over, making them invalid).

Progress: Continue work on refactoring fss_*_read into fss_read.

The primary focus is on cleaning up the state of the code.

I will at some pointer later resume migrating the code.

Progress: Continue work on refactoring fss_*_read into fss_read.

Break out the callbacks into its own type as a sibling to the program and settings structures.
Do this in both fss_read and fss_write.

Remove unused "escaped" variable from fss_write.

Progress: Continue work on refactoring fss_*_read into fss_read.

Progress: Continue work on refactoring fss_*_read into fss_read.

Progress: Continue work on refactoring fss_*_read into fss_read.

Some small progress on refactoring the settings loader, focusing on the depth processing function.

Cleanup: Remove no longer used fl_utf project.

The source files are already empty.

Progress: Continue work on fss_read, making relevant changes in other projects.

Start using "static" where it is safe to do so and easy for me to identify such cases.
I would note that a static array of const f_string_static_t does not work.

Bugfix: Fix return codes and clean up package.sh.

Fix the return code handling just like the test.sh script in commit 5ccbc0f080ca5908f77e20879988b94a4cc0c6a9.

The package.sh script is rather out of date in regards to the use of wrapping braces.

Bugfix: Incorrect return code in tests causes false failures in CI.

Recent changes of the code change the "failure" variable from being an empty string for no error to being the explicit digit of "0".
The change is incomplete and this caused the false failure by incorrectly returning "1" when instead "0" should be returned.

The Gitlab CI detected this but the Github CI failed to.

Progress: Make some progress towards getting fss_read up and running.

This mostly focuses on the print help functions.

Fix the incorrectly spelled "aplied".
Fix the help messages in the read man pages.

Add *_format_code_name_* for an upper-case human friendly name.
Add this to the fss_write as well given that the programs follow the "programs as a library" design.

Progress: Initial setup of fss_read for merging all fss_*_read programs.

This is just a copy and paste of fss_write with some very basic initial changes and refactoring.
This is not expected to work anytime soon and will be slowly converted.
Expect major changes.

I suspect that I will be working outward in to slowly add the needed functionality and to match the behavior with the fss_*_read programs.
All of the fss_*_read programs will be removed and replaced with this once this project is complete just like was done with the fss_*_write programs and fss_write.

Also fix an incorrect comment in fss_write that references "payload" when it should not.

Update: Slightly reduce recursion cost for private_fl_directory_do_recurse().

Make some constant structures static with the goal of reducing the cost of recursion.
Using static should help avoid redeclaring these variables per execution.
This should reduce memory for each recurse into the function.

Bugfix: Incorrect wrapping define usage.

Much of this is discovered in the 0.6.x branch and I ported over some changes.
There may have been something missed.

Bugfix: Fix problems exposed by unit tests.

The f_pipe_debug and f_pipe_warning are no more and there is now an f_pipe_output.

The f_print_to* functions should not use parameter checking and should instead eturn F_file_descriptor_not when the descriptor is -1.

The F_help and F_help_not to string conversion is missing.

Update: Get remaining unit tests working.

Progress: Continue fixing the unit tests.

Properly handle mock return types.

Make sure to return F_file_descriptor_not instead of F_stream_not in cases where the file descriptor is checked instead of the file stream.

Cleanup: Suppress false positive regarding missing braces.

Update: The stand alone builds should also support fakefiles.

This is an oversight from previous changes where stand alone support is implemented and where the fakefile is make more advanced (adding help etc..).

Refactor: Mass change the macro initializer functions to always have an underscore and some identity.

The macro initializer functions can be a little confusing when there is macro_f_do_something() and macro_f_do_something2().
Change the behavior to something more like macro_f_do_something_1() and macro_f_do_something_2().

Progress: Unit tests and other minor changes.

Get more of the unit tests up to date.
I did not finish working on the f_file unit tests.
I specifically stopped on the stream functions, namely the f_stream_write().

Fix the file defaults, such as _di_f_type_file_defaults_ that should be _di_f_type_file_defaults_d_.

The file flags (wrapped by _di_f_file_flag_d_) must be located with the f_type type_file.h file.

Bugfix: Fix bugs in console parameter processing exposed by unit tests.

The f_console_identify() function is incorrectly assigning the bits for short alone values.
The mistake is a missing pipe character and as a result the flags are being assigned rather than being bitwise-or appended.

The short.used and long.used string checks should skip when the string is empty.
This is not happening due to an AND comparitor in the string.
This then causes a false positive and the unit tests identify invalid data.

The process found check outside of the loop that depends on the iterator "i" should also check that i is less than the total array length.

Update: Unit tests.

Get several of the unit tests working.
These tests were not updated when their respective code was changed.

Progress: Address incomplete updates to several programs.

A previous progress commit (or series of commits) left these programs incompletely updated when they should otherwise compile.

Add "machine" name type to the fss_write matching logic.

Add missing macro function string fo f_thread_create.

Fix out of date initializes that now need different arguments or sets of arguments.

The changes to fss_write accidentally mass replaced the special fss_write_setting_load() uses that have a callback parameter.
The embedded list write has the wrong format code string ("basic" should be "embedded list").

The iki_write has an out of place declaration of iki_write_main_delete().

Cleanup: Remove unused variables, remove double declared variable, and add missing return statements.

Cleanup: Fix warning regarding private_inline_f_print_write_unlocked() being unused.

This happens when the functions that call it are disabled via the macro.
Wrap this function in the appropriate macro checks.

Cleanup: Add -Wno-main flag to disable GCC's warning about "main".

This program is careful in its use of "main" and its use is correct given the complete isolation from main.c.

Progress: Wrap up most of the directory do related changes in Featureless Make.

I am hoping this is the last progress on Featureless Make to get it fully up to date with all of the changes.
While I won't be surprised if I missed something this feels like its ready.

Remove the directory recurse copy flags.

Use more caches in Featureless Make.
Move the directory do as a cache to better allow for reusing the path and path_custom strings.
Update the documentation comments regarding the caching.

The regression mentioned in commit 61a348ba714e41467da803f8220a31c126581a01 is resolved.
The regression is that I appended the path separator out of scope (outside of a relevant condition check).

I noticed another regression where when source.used is 0 the action is not performed.
This is incorrect because the source may be 0 and the paths being used are just relative paths.

Fix a mistake where the f_file_copy() and f_file_clone() are passed invalid flags.
Make sure to pass the appropriate flags to the f_file_clone() calls in the directory do handle callback.

Progress: Additional file copy, clone, and move changes.

Remove code relating to the recursive copy functions.
Remove the fll_file_move() function.

The fll_file_move() has some additional logic for handling a case where the return status is F_mount.
If this is still a problem then I will have to address this.
The fll_file_move() doesn't make as much sense now that thee is an fl_directory_do().
Most of the logic needed is now outside of the FLL project and inside of the projects utilizing the library.

The fl_directory_copy() function is now fully replaced by the fl_directory_do() function.
This has an upside of being more flexible but a downside of putting more of the design burden onto the caller.
This overall appears to be resulting in a cleaner and simpler design.

Move the fl_directory_do() related callbacks into a new source and header file in Featureless Make.

I have noticed a regression, of which I would wildly guess be related to the recent cache design changes, where testing Featureless Make against bzip is not working anymore.
There is a path separator at the start of the files when there should not be.
This regression is not fixed here.
I only wanted to record it.

Progress: Focus on directory recursion related changes and Featureless Make.

This should wrap up most of the initial work creating the copy recursion.
There are other areas to update but this is the start.

I forgot and accidentally added "custom" to the fl_directory_do_t.
I should be using the custom from the state variable.

Now that I have had a chance to experiment with the new fl_directory_do() design I have managed to come to some more decisions.
The parameter checking will not have the f_directory_recurse_do_flag_path_e bit set for the error handler.
The before and after should be called not on just the directory recursion but also before and after each non-recursion file action.
This better allows for setting things up in a sane way as is appropriate when performing a copy operation.

I decided to provide some convenience variables.
This is not a great idea for a recursive function but it is a start.
I should investigate moving this array into a static array that is global to the private file but not shared beyond that.
This would prevent the cost of allocating the array for each recursion.

It would be a good idea to bind some of the strings to the cache and update them to better avoid additional allocations.
I think I need a cache_3 to achieve this.
I added todo comments in areas where I think this is relevant.

Do some minor clean ups on the printing in certain areas.

Security: fl_directory_list() is not appending a NULL.

If any of these strings are passed to standard library functions that expect NULL terminated strings, then an invalid read access can occur.

Progress: Focus on directory recursion related changes and Featureless Make.

I decided to offload some of the design in fl_directory_do().
The caller provides a callback and handles the combining of the path and the base file name.
This should allow for more optimization in string allocation and reduce some of the overhead of recursion.
The recursion now only records the used string rather than allocate an array of the path each time.
This should ideally reduce the amount of memory in the recursion.

The caller can now provide a custom variable to pass local data to the callbacks.

Rename 'first' and 'last' into 'before' and 'after', respectively, to be more semantically accurate.

Initial implementation of callbacks for action and handle.
I may have more work to do in the error handling, but I decided now is a good place to stop and save the progress.

Progress: Continue program related work, addressing f_state_t, recursion, and Featureless Make.

Add missing f_directory_statuss_resize() implemetnation.

Add code property to f_state_t to provide custom flags for the caller to control.

Create fake_local_t to pass custom information to the recursion functions.

Begin setting up and populating the failures structure.

Take care more cases where the interrupt needs to be handled.
This now sets the interrupt function globally and so the interrupt should be checked more often (such as in FSS Basic List read functions).
Make sure the interrupt is not checked twice once a signal is received.
This can happen after a program returns due to an interrupt.

Update: Implement threaded signal handler in Featureless Make, handling missed code blocks.

I missed a few code blocks when I created commit 9e0529297bfdb1529be685eacd3ca5784ea8e946.

Bugfix: The stage files should not begin with "-".

I haven't looked at the stage files in a while because it just works.
I happened to notice that they are beginning with "-".
This is incorrect.

Turns out that at some point in time the separator got pulled outside the process.used condition.
This results in the "-" always being added when it should not be.
The problem is introduced in this completely erroneous commit 8cb1d765b75403e242e307590842628aad7ad91b.

Add the same logic check to the name because it also append a "-".

Also reset the used length at the start of population of the stage file strings.

Bugfix: Add missing new line.

Progress: Improve thread support across programs and update threaded usage.

Enable the threaded signal handled consistently across all programs that are currently migrated (see commit 9e0529297bfdb1529be685eacd3ca5784ea8e946).

Improve the thread configuration to make it easier to enable or disable thread support.

Add documentation regarding the build modes supported in each of the build settings files.

Update the build scripts to better handle the now additional build modes.
The build scripts now use braces everywhere.
Doing this should make it easier to be compatible with other scripting engines such as ZSH.

Update: Implement threaded signal handler in Featureless Make.

Bring in the threaded signal handler design that I experimented with in the Kevux Tools project.

This works by creating a thread that waits for the signal and nothing else.
The threaded design avoids the signal check and therefore avoids period calls to kernel space.

When thread support is diabled, this falls back to the traditional approach.

This will be done for other programs as well.

Progress: Continue program related work, focusing on Featureless Make.

The Featureless Make is not handling the return status correctly on error.
This is due to a regression from switching to having status on state.
There are a couple of separate reasons:
1) One function is not doing the pre-check for error and then overrides the status.
2) Other functions that handle the error printing are calling f_fss_count_lines() which overrides the state.

The first situation is easily solved with a condition check.
The second case requires saving the status and then restoring it for error handling functions calling f_fss_count_lines().

Change the code were reasonably possible to use const on the return code.
Don't bother with return_code != 0, as removing the != 0 should be effectively the same check.

Make sure path separator is only added if it is not already present.

The migration of status into main.setting.state.status incorrectly changed fake_make_operate_validate_define_name().
This function does not set the status on main.setting.state.status.

Make sure a single white space is after simple variable print messages (before the quoted variable).

Remove the extra arguments being created (just as is done in 0.6.x with commit e8998b2e7976cee50c8e0db55ed19e2137d7aa12).

Reduce the number of pointer accesses (such data->main->... into main->...) by using a variable.
This costs some memory but should reduce having to navigate two pointers constantly.
Doing it this way also avoids having to add a parameter to each function.

Progress: Centralize Featureless Make cache and update directory code.

The Featureless Make program now uses a more centralized cache.
This requires some delicate handling in certain areas and testing is needed to assure that there are no regressions.

Continue some work regarding the recursive directory functions.

Update: Relocate fll_status_string to fl_status_string, fix failing tests, and update relating projects.

Now the f_compare exists the fll_status_string only depends on level 0 projects.
This can now be moved from a level 2 project into a level 1 project.

The fll_fss_status_code can now call fl_status_code.

Bugfix: When specifying a specific section name, do not care if there is no "main" section.

When I implemented the feature represented by commit 6c05c66f50719c9edaa36dea75669e03cd558ee4, I apparently forgot to handle this case.

This program correctly errors when there is no "main" section.
When specifically asking to run a named section rather than the default "main", who cares if there is no "main"?
Based on that logic the lack of a "main" section should not be an error.

Cleanup: Remove extra line.

Update: Add define macros for newly created functions and update the stand alone fake build.

Update: Add unit tests for f_compare utf string functions.

I completely forgot about these and later noticed that they are not implemented.
This exposed problems where I neither had up to date utf stings nor did I have all of the expected functions implemented.

I took the lazy route to avoid spending time manually converting everything.
The files are direct copies from the non utf string compare functions.
I then provided functions that convert the regular strings into utf strings.
The comparisons are then against the generated utf strings.

Update: Add missing utf string functions and fix existing ones.

These utf string functions not up to date with the latest design and are missing several functions.

Update every single existing function.
Add the missing functions.

Cleanup: Syntax in f_utf.

Update: Add missing macro macro_f_utf_string_t_initialize().

Cleanup: Typo in testfile, Cmcka should be Cmocka.

Regression: Build test.sh script is not properly running.

Two mistakes are introduced by the commit 8f5854676725879488eaa1b378dc5d02e8169ae5.
1) The error handling return status checks are against empty string and not "0".
2) Accidental copy and paste mistake where print variable is being used as if it were a function.

Remove the failure=0 assignment.
The default of failure="" is what is needed.

The variable print_line_first is supposed to be test_print_first.

Update: Add the locale specific environment variables to everything by default.

Update: Finish adding the unit tests to f_compare.

This wraps up a good enough for now set of unit tests for f_compare.

Security: Invalid read in trim comparison functions.

Writing unit tests exposed this problem.

The last1 and last2 positions could be the exclusive stop points.
The comparison checks fail to handle this situation and expect the last1 and last2 variables to not be positioned at an exclusive stop point.
This results in an invalid read.

Update: Add more f_compare unit tests and minor tweaks to f_compare.

Bugfix: The f_parse parsing functions do not check buffer.used.

The range length is being performed but not the buffer used length.
Add the appropriate return codes to represent end of string (buffer used length is reached).
This is applicable for the dynamic strings but is not applicable for the regular strings.

Do some code clean up while I am at it.

Refactor: Redesign fl_string and fl_utf_string, relocating into f_compare, f_parse, and f_rip.

The fl_string and fl_utf_string projects only depend on the core projects.
They could easily be moved into the level_0 project directory.
The problem is that they cannot be part of the f_string project due to depending on f_utf.
The f_string project is before the f_utf.

The solution is to break the fl_string into three projects:
- f_compare
- f_parse
- f_rip

It just so happens that the fl_utf_string is in the same situation as fl_string.
Move fl_utf_string into these three projects as appropriate.

This adds some initial unit tests to f_compare.
I didn't have enough to to finish f_compare, let alone get to f_parse and f_rip.

Update: Add fl_directory_do(), add new status codes, update fl_directory_copy(), and other changes.

An alternative to the ftw() is desired.
The function, fl_directory_do() is provided to perform generic recursive tasks.
This is based off of the fl_directory_copy() function.
This is not yet tested and there may be changes in the future once this is tested.

I noticed some things that could be improved in fl_directory_copy().
The recursion structure is actually specific to fl_directory_copy(), so rename it with "copy" in the name.

Add additional status codes that might be useful:
- F_bottom
- F_bottom_not
- F_character
- F_character_not
- F_fifo
- F_fifo_not
- F_middle
- F_middle_not
- F_regular
- F_regular_not
- F_top
- F_top_not

Provide a standard macro initializer and use it to make project maintenance easier.
This reduces lines of code in the programs.

Update the program flags:
- Use "in" and "out" instead of "to" and "from".
- Separate the "file" from the now "in" and "out".

Update the build settings files, making sure the locale and language environment variables are exposed by default.

Relocate the utf-8 code that previously didn't properly get properly relocated.

Progress: Continue program related work, focusing on print and main structures for already migrated projects.

I did a lot of mass replacements with absolutely no consideration to the non-migrated projects.
The files were probably process and likely have a mess of some of the changes while not having any of the other migration changes.

I've updated and did minimal runtime tests to confirm that the following projects work:
- fake
- fss_write
- iki_read
- iki_write
- status_code
- utf8

Progress: Continue program related work, focusing on printing.

Lots of printing related changes and clean ups.
Begin preparing things for switching to the *_main_t structures.
The fake, status_code, and utf8 projects are already converted to this.

There is a lot of stubbing in this commit.
I am probably going to just start a clean slate when building fss_read.
The fss_read will be based off of fss_write's design.
For this reason, I am being lax and negligent on the fss_*_read projects as they are going to get replaced and merged into fss_read.

Update: Utf8 program structure, following newer standards.

Bugfix: Out of date repository build scripts.

The repository build scripts are very much out of date.

A recent bugfix, commit 831e5d8b0dce5279964987baa43201b63c12c203, attempted to partially address this.
It turns out that there is a lot more that needs to be done.

All of the repository build scripts are now updated.

Make sure the copyright parameter is available.

Make sure the "+Q/++quiet" and "+E/++error" parameters are correct and working.

Make sue the "+F/++line_first_no" and "+L/++line_last_no" parameters are working.
Utilize "+F" and "+L" where reasonably possible in the example bootstrap and test scripts.

Improve return status handling.
The goal here is to avoid calling "exit".
The use of "exit" is not safe as under certain conditions it can close terminals that the script is running in.

Progress: Continue program relating work, focusing on Featureless Make and printing.

I am finally getting close to wrapping up the printing changes in Featureless Make.
There are some improvements in the design that need to be reflected in the other already migrated programs (such as fss_write).

Having the extra flags and object on fl_print_t is already showing its worth.
I am able to drastically simplify the print functions.

I am also now using fake_main_t structure.
I like that pattern that is forming from this and will need to also update the already migrated programs.

Featureless Make is nearly fully migrated.
There are still some fixme and todo situations to resolve.

Bugfix: Out of date install.sh and Featureless Make helper scripts.

It seems that I never looked at these in a while and they are rather out of date.
Fix the parameters.
There are other scripts that need to be looked at as well and are not solved by this commit.

Security: Fix memory leak in private_fl_directory_copy_recurse().

The cause is not as clear to me.
The memory address is being copied and so it should be being freed.
There could be some compiler optimization making a bad decision here.

Simplify the logic and remove extra checks.
Operate on the variable before replacing the pointer.
Memory leak seems to be gone now.

Progress: Continue program related work, focusing on Featureless Make and printing.

Make the fl_print structure more extensible by adding a flag and a custom object.

The first/last printing is to complex.
Simplify the design to a simpler one.

Fix other problems as observed.

I have observed a memory leak in the recent f_directory_listing_t processing code.
Specifically, the f_directory_recurse_t as called in fake_build_copy().
The appropriate memory deletes appear to be being called.
More investigation is needed.
This is a recursive function, so there is probably a bad pointer assignment somewhere.

Progress: Get stand alone Featureless Make compiling and fix discovered problems.

Fix any discovered bugs while getting the stand alone Featureless Make compiling.
This should allow for the unit tests to be run again.
Unit tests will be needing numerous updates for that matter.

Bugfix: Add missing includes, add missing fanalyzer mode, and fix problems with stand alone fake.

The stand alone Featureless Make is not building properly.
Investigation reveals that there are missing sources and missing header includes.

For some reason the missing includes do not cause a problem in 0.6 or in non-stand_alone 0.7 builds.
However, it does cause a problem in the stand alone build.
Add the missing header includes.

Update: Relocate fll_path to fl_path.

I recently noticed that the fll_path has no level 1 dependencies.
I try to keep all projects as low as possible (level_0 being the lowest).
Move fll_paath to fl_path and update everything affected by this.

Progress: Continue program related work, focusing on Featureless Make.

THis mostly addresses comments.
This is a rather annoying and time-consuming process but it is worth it for long term maintenance.
I may have missed something but this should be acceptable.

Update: Add "HOME" environment variable support to f_path.

Update: Add unit tests for fll_path.

I noticed that the '~' path is not expanded.
I checked to see if this is intentional or not.
It is intentionally not supported yet.
I need another function.

This check encouraged me to write some unit tests for the current behavior.
It seems that I had forgotten just how few unit tests I have.
Now there are at least more.

Update: Change man page year and month from January 2023 to March 2023.

Update: Man page for controller specification changes regarding "helper" mode.

Bugfix: Bad define macros.

Fix problems with some of the define macros.

Bugfix: Incorrect dependencies for individual build modes.

Progress: Continue program related work, focusing on Featureless Make.

This gets Featureless Make compiling again.
The program also appears to work.

I need to now start reviewing the code, fixing non-compile time catching mistakes, resolving any todd or fixme cases, and optimization.
There may also be some directory and file structure manipulation.

Progress: Continue program related work, focusing on Featureless Make.

I'm seeing a lot of places where I can perform optimizations.
I am ignoring these cases for now.

Bugfix: The control readonly option is not being loaded.

I implemented the numeration and processing logic but I somehow forgot to actually load the setting from the entry file.

Set and unset the flag as requested.
Make sure the path_control is reset before appending the string.

Add control_has in validation test mode to better display the file.

Bugfix: Remove out of place single quote in print.

Bugfix: The Entry is not printing on simulate and validate combined mode.

I must have not gotten around to doing this.
Now there entry and settings information is printed.

Update: Add example contrroller script for running under systemd using cgroups.

This provides an example cgroups setup.
I found that on systems with cgroups2, this is harder to figure out.
This turned out to be because of the existing setup used by many systemd systems.

This provides an example that I managed to get to work under some systems in some circumstances.
The biggest problems is that the subtree needs to be passed along and that tends to not be done by default.
The current user, if not root, usually lacks the privileges to do so.

The best case would be to use the cgroups generation when running as root to setup the appropriate user.
Then, use the program startup examples as the normal user.
This should show the cgroup situation.

I would not be surprised if the cgroup setup scripts has to be altered (not just the user and group name).

Progress: Continue program related work.

Feature: Add support for 'helper' mode to compliment the 'program' mode.

This is a bug fix disguised as a new feature.

When controller runs in program mode and is cancelled, all background (asynchronous) processes are cancelled.
My original thoughts were that background processes should stay open in program mode.
This is the bug being fixed.

I believe that there are use cases to operate in "program" mode and to always terminate the background processes in this manner.
Rather than fixing one case and breaking the other, this is a new feature that helps solve both cases.

The "program" mode operates in the same manner unchanged.

The new "helper" mode operates by detaching background (asynchronous) processes on exit.
The foreground process still runs and blocks normally.
A terminate signal might still terminate background processes.
More work is likely needed in this regard.

This stretches the original design to its limits.
The 0.7.x versions and later will need re-design to better handle these cases.
The original design I used was a learn as I go for thread design.
This resulted in rather messy code.
Now that I made it to this point, the controller program (0.6.x and earlier) can be used as a stepping stone for a better design.

Some of the problems are worked-around.
The program starts and exits too fast in controller mode.
The child processes end up getting terminated before a complete process is started and then backgrounded.
The work-around is to add a short sleep.
This is not reliable but for most cases it should be fine.
Additional work-arounds may be needed by the user such as executig their own sleep foreground process.

Cleanup: Remove dead code in controller program.

The process variable is not used.
Remove all of the dead code.

Cleanup: Properly initialize the time variable in controller_thread_process_cancel().

Bugfix: Multiple cancellations may occur, use mutex lock to prevent.

There is an existing check that prevents the cancellation from being called more than once.
What is not being considered is that if the main thread calls cancellation while another cancellation is active then the controller_thread_process_exit() gets called.
The controller_thread_process_exit() function will begin more forcibly shutting things down.

Avoid this by providing a mutex lock to lock the cancellation.
Only once the first cancellation is complete will the second (or more) then return without doing anything.

Cleanup: Improve semaphore documentation comments.

Cleanup: Documentation comments in regards to f_state_t.

Several of the documentation comments regarding f_state_t are now no longer out of date.