Update: Finish implementing combining character detection.

I consider this done.
There will be a pass sometime in the future where I review all of the codepoints before making the stable release.
I suspect, given the size of these kinds of changes, that there will be mistakes and oversights.

Progress: More UTF-8 improvements, adding more combining characters.

Update: Make wide text display the default.

Move the width detection into a bitwise options property.
Detect the rightmost ordering of narrow and wide parameters.
Set the default value to wide.

Progress: Major UTF-8 changes and optimization.

Add more combining characters.
As usual, with the UTF-8 codes I am focusing on getting it supported rather than getting it optimal.

Add wide character detection.
Any mistakes aside, this appears complete.
There are a lot of blocks within some sequence ranges, so I used ".." in the comments to designate that this is a range of blocks.

Update the byte_dump program to utilize both of these.

Progress: Major UTF-8 changes and optimization, begin updating byte_dump and utf8, and miscellaneous changes.

A previous commit accidentally include the utf8 level 3 program while it was being heavily developed.
As it is already committed, commit the latest changes.
The utf8 program is still not done.

While working on the utf program, I noticed that there are some things in the UTF-8 code that is not yet done or correct and is needed.
I also noticed that the byte_dump program needs to handle the narrow and wide widths to assure consistent column line ups.
Such a change requires new functionality in the UTF-8 code for processing the widths.

These two significant needs resulted in me finally getting around to some of the UTF-8 cleanup that I have been needing to do.
- Get rid of the width parameter, and calculate the width as needed (bitwise is chip and allocated a variable and then passing it along parameters is not as cheap).
- Swap some of the conditions to avoid using "!", saving a single operation though structural changes.
- Break out the utf string functions into its own utf_string.c, utf_string.h, private-utf_string.c, and private-utf_string.h.
- Numerous documentation comment cleanups and update (I think there is still more to do).
- Provide F_utf_fragment and F_utf_fragment_not for improved communication of UTF-8 fragments in error responses (rather than re-using F_utf).
- Provide f_utf_unicode_string_from() (I have not yet written a f_utf_unicode_string_to() but I plan to).
- Update endianess detection to use macros (I am include <endian.h>, but I may also provide custom macros to disable and explicitly designate endianess).

The UTF-8 is wide functions are drafted out, but there are a lot of wide character codes that I need to add.
This will be grunt work that will take a notable amount of time.
For now, just add a comment and I will get back to this.

The byte_dump program is depending on the is wide functions and so currently incompletely implements the narrow and wide support.

Try to use present tense in error message.
There are likely many more places, but this is a start.

Add F_first, F_first_not, F_last, F_last_not, F_next, F_next_not, F_previous, and F_previous_not for providing position return codes.

Fix a bug where width is being define by a uint8_t but the calculates are f_array_length_t.
How did this ever work before, by accident?

Regression: Previous byte_dump cleanup resulted in an extra space for one character.

The character 0xd89d is being handled in a special case.
This is previous code that is now identifiable as removable.
Stop handling this as a special case, avoiding the need to print extra spaces.

Cleanup: Byte Dump UTF-8 handling.

Minor cleanups.
There are likely more to come in the future.

Update: Improve UTF-8 Control detecting, expanding to distinguish Control Code and Control Format.

There seem to be "Control Format".
Create functions for "Control Code" and "Control Format" (is_control_code and is_control_format functions).
The is_control functions now check for both.

Update: Implement double support in print functions and add missing functionality.

This implements the double support as a wrapper to the printf() functionality.
Future versions will ideally impliment this internally.

I observed that there is some incorrect logic with the "width" and the "precision".
The logic appears to be asserting that they are XOR to each other.
In actuality they are OR to each other and both can be provided.

Rename "output" to "stream".
This seems slightly more accurate to me.
I considered using "file" but that is heavily used by the f_file_t rather than the FILE *.

Bugfix: Base 10 was used in hexdigit for comparison, resulting in invalid number conversion.

Looks like I accidentally used based 10 numbers.
The 0x29 is supposed to be 0x2f (I was thinking 30-1 = 29, but in hex it is actually 2f).

Bugfix: The print safely functions are not fully UTF-8 aware.

The f_print_character_safely_get() can only handle a single byte.
This makes it impossible to be UTF-8 aware.

Provide a new function f_print_safely_get() that accepts a string and a max width.
This string is intended to represent a single character, but can be multi-byte based on max width.
This function checks to see if the character is invalid or a control character, in which case it is replaced.

Update: Remove old color print functions.

These functions are still present for migration and just in case.

Now that I am using fl_print_format() I feel there is no reason to keep and maintain this code.
Get rid of it.

Bugfix: Wrong characters being printed, switch to newer print functions.

When specifying a start offset using -f/--first, additional characters are printed.
This appears to be stale code that should no longer be present.

Switch the old color print functions to the fl_print_format() and similar.

Update: Signal related updates, consistency improvements, and miscellaneous code cleanups.

Add support for setting the timeout via f_signal_read().

I am using both F_signal and F_interrupt.
The F_signal is more general and in this since is more accurate.
However, F_interrupt is more accurate to the intent in the design.
When an interrupt is received exit.
All signals being treated as an interrupt will need to exit, so just pass F_interrupt.

Provide a consistent reporting of handling the signals.

Setup all programs to catch and handle signals, allowing for a clean exit.
There are so many changes in this regard, I went for a quick approach.
In every loop that at glance look like it would be a good point to check for signal, the code now checks for signal.
There is likely a need for performance consideration in this.
There is likely a need for invetigating this further to make sure it is still responsive (as in, investigate to see if I need to add additional signal checks).
Programs like fake and controller already handle the signal.
These programs are update to be consistent with this newer design.

The "main" structure used in the programs is sometimes a constant variable and other times a pointer.
While there are performance and security reasons, I am finding that consistency is better at this point in time.
Pass all of the "main" structures as either a constant pointe or a pointer.
At some point in the future, I can see myself reviewing these and making performance improvements that might result in reverting some of this.
Having be more consistent will make the code a bit more mangeable during this highly active development and design period.

Miscellaneous syntax cleanups of any code that I happened to notice needs cleaning and can be easily cleaned on the spot.

When interrupting, flush the output and print a new line.
This is effective in properly cleaning the console (to some reasonable extent), which can be messy when exiting due to an interrupt.

I did not get a change to utilize the signal handling function callbacks in the FSS processing functions.
I will need to follow up this commit with such a change.
I need to see if the IKI processing functions also can do this and need to do this as well.

I haven't had a chance to really look at each of the programs after this change.
I will need to spend time making suring there are no regressions.

Update: The color set context should also have the "reset".

Regression: NULL is being printed and fix inline function.

The NULL character should not be printed for "safely" print functions.

The private inline functions should be made static.

Cleanup: Improve standard verbosity help message.

I find the wording I used to be rather confusing.
Reword the documentation.

Update: Experimentall cast characters to uint8_t in UTF-8 processing code.

I've noticed with calls like printf("%d", string[0]) the printed number might be a negative huge number.
Explicitly casting it to uint8_t (rather than char) seems to be a way to avoid this and allow for the number to be better printed.
I am suspecting that this should be done in general rather than just to the print functions.
This is an experimental commit designed to make it so.

This also has an affect on bitwise operations because bitwise shifts respond differently between signed and unsigned integers.

Update: Fix print function bugs and add missing functions.

There are some cases where the logic is flawed and fails to print correctly.
Given a bash binary, passing it through the print functions and back to the disk in raw format resulted in a different binary.
The binary should be identical to the original and is not.

It seems that when I attempted to reduce the number of variables in the print function I failed to account for certain details.
This essentially reverts some of the previous logic and puts back the variables.

Many off these functions are almost identical but their differences result in requiring slightly different code.
This makes the code less manageable and easy to get lost in.
The code has been tweaked somewhat to be more consistent across the board, where possible.
This might come at a cost of some slight performance.

To make the code easier to read, separate the print functions into two groups:
1) The print functions that use file streams.
2) The print functions that use file descriptors.

This code is slightly different and while I could use macros to make this simpler, I opted to avoid macros at the cost of duplication.
Move these two groups into separate files, significantly improving code readability.

There is a mistake in the previous code where errno is being processed for file stream errors.
The libc file stream functions do not utilize errno.
Change the affected code to just return F_output with the error bit set.
I am unable to find a discrete list of error codes returned by ferror().
I will need to additional work to get these codes so I can properly map them to more verbose error codes.

The documentation is no longer out of sync.

There should be a file descriptor function equivalent for nearly every file stream function.
In this regard, several missing functions are now added.

This is an unplanned change that is rather large.
I am concerned with oversights and regressions.
Just keep an eye out for regressions and hope that there are none.

Bugfix: UTF-8 functions fail to properly handle ASCII.

This seems to be a problem where there are two ways of processing ASCII detection of UTF-8 code.

The macro_f_utf_byte_width() will return the width of 1 for ASCII.
The macro_f_utf_byte_width_is() will return a width of 0 for ASCII.

The affected code is assuming a width of 0, but some functions send a width of 1 for ASCII.
These are private functions, so it is relatively safe to just allow both.

Change the behavior to accept both 0 and 1 and treat them as ASCII.

Update comment about Unicode 12.1, setting it to 14.0.

Cleanup: Fix styling practice where a newline should be after a loop.

Any loop whose insides are greater than 1 line should have a newline separating the loop line start from the content.

Update: Add "success" color context and initialize color "set" in programs.

There is an "error" and a "warning" but no "success".
Make this complete by adding "success".

The programs aren't initializing the "set".
Attempting to use these always results in no color context.
Fix this by initializing these in each program.

The output context also needs to be initialized just like the error and warning.

Cleanup: Break apart controller sources.

The functions have gotten too large an are in a need of cleanup.
Create additional source files and move functions around as appropriate.

Do some function renaming as well.

Move the print functions into separate print source files.
This is done only for functions whose sole purpose is printing and is not nor should it be done for functions that happen to have printing within them.

The entry pre-process and process functions should be in the entry source files.
Fix the name of those functions to start with "controller_entry_" rather than starting with "controller_process_".

Move any structure construct and destruct functions into the common.h and common.c that are not already there.

Break out the build settings file settings into multiple lines.
I prefer not to have too many extra lines, but there is a point when the lines get absurdly too long.
The lines are broken up by some context or pattern.

Regression: Script and Utility are no longer working when using "Extended" rather than "Extended List" format.

At some point I changed how the actions array get incremented.
I failed to increment a valid script or utility (or accidentally removed the existing increment) when populating its actions.

I noticed a potential problem where the rerun is re-using "type".
Avoid any potential problems by refactoring this to "type_rerun".

I also noticed that the controller_rule_action_type_execute_* are starting at 0.
From off the top of my mind, I believe this starts at zero because it is being used as an index in a static array.
Otherwise this enum should start at 1.
Add a comment about this exceptional case.

Update: Add two example entries for testing delay so that terminate signals may be tested.

Bugfix: Use BLOCK after UNBLOCK rather than UNBLOCK again.

Cleanup: Remove stale comment regarding sleep interrupts.

I updated this in the previous commit and completely failed to notice that its message is no longer correct.
The commit ad4a95d1b8a26e271d491320b627dbdea443a13c actually makes it possible for the sleep functions to receive the interrupts.

Update: Improve sleeping logic, also replacing sleep() with nanosleep().

The previous time-related regression fix introduced unblocking the signals as an immediate solution to its problem.

The preferred and intended design is to have the signal handling done by controller rather than done automatically.

Redesign the sleep functions to only unblock the signals for the sleep call.
Then re-lock the signal so that the intended design may be continued.

This then allows all appropriate cleanup functionality to operate as expected.
This can be confirmed with valgrind before/after and sending an interrupt during a validation process that utilizes a sleep (such as the example htop rule).

Create several functions to standardize some of the processes involved.

This also resolves a "todo" designating to replace sleep() with nanosleep().

Cleanup: Fix spelling of "interruptible" and "uninterruptible".

Bugfix: Functions like nanosleep() are not receiving interrupt signals and similar.

When the thread is created, the signals are locked out so that they can be handled within the program.
The processes thread needs to be able to receive signals.
Allow the parent thread to receive all signals.

More work may be done in the future to fine tune this.
For now, the signals are just opened up entirely unless uninterruptible is designated,
This seems to allow for the thread to be cancelled even when nanosleep() is being called.
Also pass the specific signal received that is triggering a termination.

Cleanup: extra line.

Regression: controller_time_micro() is waiting too long.

Turns out that my calculation is in milliseconds but the value is not in milliseconds (it says microseconds!).

Change this to milliseconds and update the time as appropriate.

Update: Next micro version (0.5.7).

Bugfix: config.h shouldn't be installed.

The pre-generated config.h shouldn't be installed by default.
This fixes some mistakes in: "106c18c3 Feature: Enable config.h, config.c, and config.cpp support in package generation.".

The source files and any potential headers may still need changes to properly include the config.h as necessary.
Still, this is a step forward in making this project friendlier with some existing practices, even if it is only half a step.

Bugfix: Require is not properly triggering failure on error.

Get and handle the status code of controller_rule_wait_all().

Fix cases where "status" is being used where "status_lock" is better suited.

Remove unnecessary double assignment of status error.
In this case, only when F_lock is returned should the status be set.
This may need to be revisited and have the called function also set error on F_lock rather than handling here.

For asynchronous functions controller_rule_wait_all() is not properly handling the error.
This is happening because "required" is being incorrectly used.
For this function "required" is design to only wait for all required processes only and not limit the required validation.
Removing this fixing the problem so that when an asynchronous process that is required fails, the failure is propagated to the waiting process.

Add "require" in the htop example as a place for testing.

Add additional comments for clarifications and cleanup existing comments.

Remove unnecessary ready wait assignment.

Update: Implement "session new" and "session same", improve documentation, update simulate and validate display.

The controller and init programs now support customizing their session as new or session as same state.
A setting global to the entry and exit files is defined as "session new" and "session same".
A setting specific to every rule item is appended to the "with" as either "session_new" or "session_same".

Update the documentation with these changes.
I noticed the documentation could use a little cleanup.

When passing both simulate and validate parameters, the entries and exits (with all related parts) are displayed.
The ordering can be more alphabetic.
It will not be fully alphabetic because there still exists logic that supersedes this, such as:
- "id", "name", and "type" values generally go first regardless of alphabetic ordering (and in that order).
- The simple data is displayed first (ones not using '{' and '}' to display), which are within themselves alphabetic.
- The complex data is displayed last, which are within themselves alphabetic.
- Within the complex data, the "item"s are displayed last.

Cleanup whitespace in execute-common.h.

Update: Improve terminal support in execute functions.

The init program calling bash results in "not a tty" error:
- "bash: cannot set terminal process group (-1): Not a tty"
- "bash: no job control in this shell"

This exposed me to the Process Group.
I have learned that I may need to set the Controlling Terminal in this case.

To that end, I have introduced FL_execute_parameter_option_session_d for setting this up.
I have also added an initial setup for FL_execute_parameter_option_terminal_d, but more investigation and research needs to be done.

I've added some basic execute terminal codes that I may or may not need.
I would rather have them now and remove them now rather than not have them and have to add them later.

The controller program needs to utilize this, at least when running as "init".
However, I believe that I should pass control over this to the user as new settings, such as "session new" and "session same".

Provide example to utilize "setsid" program for doing this same thing when directly calling bash.

Update: Bootstrap build script should understand static and shared being built.

Instead of a single "built" file for tracking whether a package is built, have two "built" states, one for static and one for shared.

This allows for tracking whether shared or static is built exlusive of each other.

Feature: Add support for F_terminal status codes.

Cleanup: Remove resolved or no longer relevant notes in the todo.txt.

Regression: Example bzip fakefile fails.

Empty strings end up getting passed to the programs, such as gcc.
The program gcc will throw an error claiming it cannot find file (displaying an empty sting for the filename).
This empty string doesn't show up in verbose, so the whole reason for failure is confusing because nothing is being displayed.
Fix this by not appending empty strings to the arguments.

At some point I added additional checks when loading the build settings file.
Because the fake make process uses the same function, it ends up failing because unrequired settings are now required.
Add a new variable "checks" to designate to perform these requirement checks or not.
The fake make process will then be setup to not perform these requirement checks.

In a recent commit, I added support for indexer_arguments.
It turns out I did more than necessary because this will already get loaded via the build settings loading code.
Remove the extra unnecessary processing of the indexer_arguments setting as it is already being processed later on.
The "compiler" and "indexer" should also be looked into.

Cleanup a print function.
Add a missing newline print at the end of the "print" operation.

Update the example fakefiles.
Add missing settings to the example build settings.

Update: Add support for indexer_arguments, update documentation, and fix printing bugs.

This is a step towards removing hardcoded defaults that I had initially added just to save time.
The indexer now has an indexer_arguments that will expect the arguments, such as "rcs".
Update the documentation, documenting this behavior, fix problems in the documentation, and do some cleanup of the documentation.

There are some places where "linker" is still used.
Replace this usage with "indexer".

Fix some cases with printing mistakes.
These mistakes are likely regressions resulting from the mass refactor to the fl_print_format() and fll_print_format().

I've noticed that there are some problems with the settings in the fakefile.
The custom settings, such as "compiler", "indexer", etc.., are being overwritten by the build settings.

It may also be a good idea to provide another iki parameter to expose some of these settings.

Update: add additional fake settings, simplify defines_all and flags_all.

Add the following fake build settings:
- libraries_shared
- libraries_static
- build_sources_headers_shared
- build_sources_headers_static
- build_sources_library_shared
- build_sources_library_static
- build_sources_program_shared
- build_sources_program_static
- flags_library_shared
- flags_library_static
- flags_program_shared
- flags_program_static
- defines_library_shared
- defines_library_static
- defines_program_shared
- defines_program_static

"flags_all" is now "flags".
"defines_all" is now "defines".

These are needed for the adding settings specific to shared or static state.
The "headers" related ones are added in case custom headers include static or shared specific code that should only be installed when using static or shared.
Note that the "headers" is for installation and is not needed in any way for compilation.
Other non-compilation related settings are not to have the "_shared" or "_static" added.

Refactor: Use the newer _s and _d define strategy.

This new strategy allows for the "const char *"s to be more directly the same as the "#define"s.
For example, "F_console_standard_short_dark_s" is the "#define" and "f_console_standard_short_dark_s" is the "const char *".

The use of uppercase is tolerated here as an exceptional case because F, FL, and FLL are sufficiently short enough to not be an eyesore.

No changes are made to exist "macro_*".
I will contemplate changing the "macro_XXX" to instead be "XXX_m" to match the "XXX_s" and "XXX_d" notations.

As an additional exception case, the length "#defines" that are directly coupled to a string, are of the fom "XXX_s_length" rather than "XXX_d".
This directly identifies that these only exist within direct relationship to the string "#define".

The "#define" will now have uppercase in the level 0, 1, and 2 projects.
Level 3, being programs, only conditionally follow to avoid using too many uppercase characters (ie: fss_basic_list_read_xxx vs FSS_BASIC_LIST_READ_xxx).

Refactor: Convert old f_file_t output strategy to the newer fl_print_t output strategy.

The "f_file_t output" should now be "fl_print_t output".
The output verbosity can now be used rather than the error verbosity for output verbosity.
This makes the code more readable and consistent.

The default fl_print_t_initialize is for normal output so also convert the error output initialization to use macro_fl_print_t_initialize_error().

Refactor: fll_error_print_t is now fl_print_t.

After using fll_error_print_t for a while now, I find that it is in practice superior to the regular print approach (such as with "f_file_t output;").
This made coding far easier than I imagined.

This refactor changes renames this from an error purpose print to a generic all-purpose print.
The existing "f_file_t output;" designs are not changed with this factor and will be changed in a later commit.

This refactor allows this to be moved from a level 2 project to a level 1 project.

In following with my completeness principle, I have added a "suffix" to compliment the "prefix".

I also added the "set" as a pointer to make it optional and to also not take up as much resources the full object rather than a pointer.
Having used fll_error_print_t for some time, I have found that I occasionally needed more than just the "context" and "notable".

While working on this, I realized I could improve my practice of handling "static" strings (such as fll_error_print_debug_s).
The practice is now to have the defines more closely match the names, but begin with the F_, FL_, etc.. in the same way that status codes are used.
This then allows:
|           old           |       new        |
----------------------------------------------
| fll_error_print_debug_s | fl_print_debug_s | <--- variable.
| fll_error_print_debug   | FL_print_debug_s | <--- define/macro.

A future commit will convert all existing code that follows the old way.

Update: Controller devices rule should no longer attempt to mount /dev.

Update: Execute changes and controller program changes.

Tweak some of the execute status codes.
I confused the errno parameters for what I was using F_execute_off for.
Change F_execute_off to F_execute_bad to more accurately reflect what the error code represents.

Add additional execute status codes.
Provide a F_format and F_format_not status codes.

Pass through non-negative, non-zero, exec return codes.
For negative return codes that is not -1, set the execute error code to F_execute_failure.

Improve error printing in controller program on child process failure.

Start to cleanup print functions.
There already is data being passed via the f_process_t, use those to better reduce the number of parameters passed to relevant functions.
There is much more work in this regards to do, but that is to be done at another time.

The controller program threads should exit with child code only if the child code is non-zero.
When the child code is zero, then the normal (and preferred) thread exit is allowed to perform.

Bugfix: The rule for devices is "devices" and not "dev".

Update: Implement "rerun" and properly get failed execute status codes.

Provide "rerun" support feature.

I discovered some problems with the execute functions after testing the "rerun" feature.
Specifically, when a child exits, the exit code is not properly propogating to the caller.
This makes it impossible to detect a failed execution.

It turns out that I need to call exit() with the appropriate failed code (which is only 8-bits).
The pthread_exit() is documented as always exit() with a value of 0.
This makes it impossible to communicate the failed state to the parent via an exit return code.
I am forced to call exit() here.
To do this, several significant changes are required.

Implement F_execute_codes enum and related functions to handle the 8-bit large status codes.
The limited set of codes are focused on possible failure states from the execute functions.
Functions to convert to and from regular status codes and these special limited execute status codes are now provided.

A union called f_execute_result_t is now provided as a way for the execute functions to return a pid_t for the parent process and an int for the child process.
The int in this case is intended to hold the special execute status codes.
An int is used rather than a more appropriate uint8_t because the standard POSIX functions use int.

Additional normal status codes F_too_large and F_too_small are now provided as generic too large and too small statuses.

Exit calls now directly use the execute status codes when calling exit().

The controller program child process now returns the exit status code either at the end of the appropraite threads or at the end of the main().

A new micro time conversion function is provided so that the deprecated usleep() can be avoided.
I may end up rewriting this to perform the sleep as well rather than just return a timespec.

Yet another htop rule is provided for testing "rerun".

See the previous commit for additional details (5b09409e3c7b5eafc164405c5d487bdfd083be11).

Progress: Begin implementing re-run, fixing related problems.

To properly operate as an init (and improve the controller execution functionality), programs and services need to re-run after exiting.
A good example of this is the agetty program, which should re-run on both success and failure.

I attempted to take a simple approach with this design.
Example:
  rerun start success delay 1000 reset
  rerun start failure delay 5000 max 100

A "rerun" is applied to each Rule Action "start", "stop", "freeze", etc...
Each Rule Action has either a "success" or a "failure" state.
Each state may specify a delay, max, and a reset.
The delay provides how long to wait before re-running.
The max represents the maximum number of times to perform the re-run (setting to 0 results in no maximum).
The reset designates that the opposite return result (either success or failure) will have its counter reset.
That is, in the above example if failure is triggered 50 times and then success is triggered, the failure counter will be 0 again due to the reset on success.
Not specifying "rerun" will disable re-running.

This implements another array structure and the code is changed to perform the processing of the settings at an earlier point.
The previous design is a quick and simple but required additional looping before each execution.
The code now does the processing in the existing loops to avoid needing to loop later.
This requires adding new variables to the structure increasing memory footprint there but also decreases memory footprint in the actions array (and results in smaller actions array).

The "with" and "pid_file" are updated in this way as well.
The "user" and "group" have not yet been updated and need to be.

The configuration and validation of "rerun" is implemented, but the re-run functionality needs to be written.

The error checking, handling, and exiting will need to be reviewed after this work is complete.

Update: Implement timeout setting support, fix number handling, improve printing.

The timeout settings were never fully completed.
This implements the loading of the timeout settings but does not provide an usage of these settings.

Do some restructuring related to the timeout settings.

Fix detecting and processing of +/- as well as decimals.

Handle more errors returned by the number convert functions.

Cleanup the printing code.
Centralize some of the printing to functions, ideally reducing code size.
Add printing where it is not being done.
Fix debug vs verbose printing where debug isn't always including verbose printing messages.

Update the documentation.

Update: Add F_read_only and F_write_only errors to the file error print function.

Also cleanup the function structure a little.

Cleanup: The fl_conversion re-used functions should be within private files.

The practice is to maintain functional isolated even within a projects own sources.
The private sources are the method intended to re-use the functions within the same file.

Update some comments.

Bugfix: The decimal '.' (0x2e) should not be considered a number.

The decimal may be a number character, but the conversion functions are for whole numbers only.
Consider the presence of decimals an error.
Use the F_number_decimal character to communicate this case.

Bugfix: Formatted prints are pulling additional var_arg, resulting in a segfault.

The else condition should not be grabbing an additional argument.
Instead, initialize that argument to its default empty value.

Update: Support "pid" and "show" entry settings, and bug fixes.

The pid file may be created before the filesystem is ready and it may not be deleted when the system shuts down.
This then prevents the system from booting due to init failures.
Provide rule setting for fine tuning the control over how to handle the pid file.
Now, when running "as init", the pid entry setting by default designates to only utilize the pid file when "ready".
Previously, the pid file was always being checked for before the entry is even processed.
This prevented even waiting on the "ready" action because the entry is bailing out before even being processed.

There already is a "verbose" that prints the execution of programs.
This does not, however, start by default.
Provide a "show" setting for toggling this behavior to print some of the verbose messages when in "init" "show" mode.

Update the constant strings and related variables.

The ready behavior needs to be properly set.
As far as I can tell, the logic seemed odd, if not wrong.
Remove one of the ready checks and cleanup the ready check for the explicit ready action.

Update the prebuilt rules for terminals.
For now, there will be separate terminal files to execute.
There should be a variable substitution later on to not require multiple files.
For example, behavior is now:
  "rule terminal one", found in rules/terminal/one.rule
  "rule terminal two", found in rules/terminal/two.rule
This could better be something like:
  "rule terminal tty/1", found in rules/terminal/tty.rule
  "rule terminal tty/2", found in rules/terminal/tty.rule

Cleanup and update the documentation.

Update: Configuration settings changes.

There will likely be several of these kinds of changes as I continue to implement functionality in controller and test it against my system.

Update: Make fl_execute_into() slightly more consistent with fl_execute_program(), adding environment processing.

Allow for the environment to be conditionally cleared and re-defined in the same way fl_execute_program() does.

Bugfix: Infinite loop on invalid entry file and related printing problems.

The loop is not properly handling the failure state and infinitely attempts to execute a rule that will always fail.
Make sure to copy over the rule failure code to the entry status.
Make sure to exit when rule execution fails when not simulating.

The related error printing bad logic in the conditionals.
Separate the simulate and related verbosity from the non-simulate and related verbosity.

Cleanup: Remove quotes from number on printing.

The practice that I am starting to follow when printing is to quote text but not to quote numbers.

Update: Improve a few initial error printing messages.

Bugfix: Environment should only be reset when specified, even if empty.

The environment is accidentally always being reset.
This results in no environment in cases where this is unexpected.
This happens in simple things such as maintenance mode boot to bash, cannot find bash because there is no PATH environment variable.

Add example environment entry and rules for testing this.

Bugfix: Highlighting text should be using 'notable' and remove unneeded single quote.

Bugfix: Running as init is still not handling interruptable correctly.

I overlooked that the result was comparing against f_console_result_none rather than f_console_result_found.
This messed up my previous attempt to fix this.

Change the behavior and also explicitly assign the else case.

Bugfix: When already running as "init", ignore --init parameter.

This includes properly handling the default interrupt state.

Update: Improve pid file handling logic.

I had forgotten that this is already optional.
Change the design to detect when pid file is explicitly disabled (passing an empty string to "--pid").
This avoids the need for the process_pid variable.

Cleanup: Provide additional information on potential failure due to incomplete rule file.

Update: Controller "init" is not always operating as expected and improve error printing.

The execute as init state needs to be run with the as init settings set.
The settings.mode needs to be set to run as a service.
(I am considering adding a new standard practice for programs to accept default objects that are passed to the appropriate function from any main().)

Cleanup the printing:
- Using "print" rather than "output" (because it is shorter and "print" is already being used in some places for this).
- Get rid of one nesting level to further simplify the code using return (and avoid an extra operation from the "!").
- When exiting due to an interrupt, do not print an error message.

Bugfix: Incorrectly setting interrupt failure during exit.

While processing the exit rules, the fll_extended_read is failing due to an interrupt that is not being sent.
This is the result of an incorrect value being assigned to the controller_state_interrupt_t.

Bugfix: Controller program print locking issues and fix delimits cache issue.

The locking as it is implemented is incomplete.
In many places, it unlocks twice.
There are some places where locking is not correctly being locked or unlocked, resulting in deadlocks.

Rewrite controller_print_unlock_flush(), and also add controller_print_lock().

I belive the problem is simply a result of many design changes in the locking and I just missed a number of places.

There are some printing where the parameters should have been printed but are not correctly printed.
Make sure controller_entry_action_parameters_print() is called in these places.

Make sure the cache delimits is cleared before calling fll_fss_extended_read().

Bugfix: Fix problems exposed due to testing and improve "Init".

As expected, I have found several regressions as a result of the mass conversion to fl_print_format() and similar.
There are several places where the wrong parameters or string replacements are used.

Improve the Controller to allow for "Init" to not attempt to mount the pid file (which allows Init to also manage initial mounting and device creation without depending on the existence of the filesystem structure).
The Controllerr "Init" now treats an empty string for the --pid option as disabling the pid file creation.
Do not treat exiting as a result from interrupts as an exit error.

Update: Controller "as init" should use "init" over "controller" in more places.

The default settings should be changed to /etc/init/.
The default pid file path should be changed to /var/run/init/init-XXX.pid.

Bugfix: Should be using '%Q' and not '%S'.

This is a dynamic or static string rather than a string, so use '%Q'.

Feature: Enable config.h, config.c, and config.cpp support in package generation.

There is a common practice of having a config.h for local build time changes to be applied.
Provide a skeleton structure for this by default when building the FLL packages.
These files will be empty.

The user need only populate these files as needed.
This could be done manually, but doing this by default effectively documents the proof of concept with a working/functional example.

Perform some minor cleanup as well.

Cleanup: Spacing in fake help.

Feature: Controller Program should support uninterruptable and define default behavior.

After designing the Controller to support operating directly as "init", it later occurred to me that the default behavior of uninterruptable makes sense for "init" but not for "controller".
Change the behavior to default to interruptable for the "controller" program.

This change further implies that the program needs an opposite to the "--interuptable" parameter.
Implement the "--uninterruptable" parameter for this purpose.

I also noticed that there is already an "interrupted" variable but that code is dead.
Oops.
Resurrect this variable and use it for identifying for this updated interruptable behavior.

Feature: Allow controller program to operate directly as "init program" by default.

The controller program already supports operating as an "init" program.
The design is generic enough to do this and a parameter exists already to explicitly set paths.

When running as "init" under normally circumstances, parameters might not be passed to it.
This is a good argument to support operating natively as an "init" without requiring the init parameter.

The design of the FLL programs allows them to be used as a library.
Take advantage of this and rewrite some of the code to save the "init" related differences in the main.c file.
The main.c file is not shared in the library and is therefore a safe candidate for holding differences.

This results in two programs "controller" and "init" which use the same library.
A stripped binary size of these two programs is each ~23K.
The stripped library shared between them is ~235K.

Having both programs on the system therefore only costs and additional ~23k.

To make this easy, provide an "as_init" mode that can be added to compile in this mode.

A compilation as "controller" might look like:
- "fake clean build -m monolithic"

A compilation as "init" might look like:
- "fake clean build -m monolithic -m as_init"

In both cases the program is built as "controller" under "build/programs/shared/controller".
When compiling "as_init", just rename this program when installing, such as:
- "cp -v build/programs/shared/controller /sbin/init".

The libraries and headers need only be installed once between the two programs.

This situation is a great example of the design principles of this project in use and working well.

Cleanup: main program parameter documentation.

Bugfix: Add missing parameter in firewall help and tweak spaces.

Update: Next micro version (0.5.6).

Bugfix: Miscellaneous mistakes.

The fl_signal has the wrong project name, causing the fl_signal to be installed as fl_iki.

Fix comment in fll_print header file.

The byte_dump program needs to report file not found as an error.
Fix error message from missing bug in byte_dump.

Incorrect variable used in fss_basic_write (a copy and paste error).

Fix _libcap_legacy_only_ defines and apply the libcap and pthread defines more universally.

Bugfix: Embedded List slash processing problems.

The slash count must be recorded per-depth.

Fix a mistake in the specification documentation.

Cleanup: Fix tabbing.

Feature: Add support for -R/--raw parameters in FSS read programs.

The -R/--raw parameters designate that the quotes and the escapes should be preserved.
This allows for cleaning up a file and only pulling out valid FSS format and then provide that FSS in its originally escaped and quoted forms.
This further allows for maintaining quotes and escapes on Objects or Content individually.

Update: Allow empty Objects in FSS Basic and Extended Lists.

This actually includes FSS Embedded List as well, but the embedded list already appears to allow this.

Security: Static/Dynamic string compare functions aren't properly handling empty strings or empty ranges.

When the static/dynamic string has used = 0 or the range.start > range.stop, then the string (or range) is empty.
The private function isn't aware of this and simply attempts to access the invalid ranges.
This will result in an invalid read.

Add the missing used and range checks.

Bugfix: FSS Basic and Extended List Read -a -n -l parameter fails to work as expected.

When -a, -n, and -l are used at the same time, the line position ends up being the wrong position within the file.
The -l (--line) should be relative to the --at index relative to the --name given.

This turned out to be a simple mistake where the wrong variable was being passed.

Bugfix: iki_read never implemented --at.

The --at parameter appears to have never been implemented or the implementation was somehow lost.

It should be possible to have the --total with the --at, however odd it may be.
The --whole, however, doesn't seem like it would be a good idea to allow supporting the --at paramter.

Add the "--" characters when displaying the error via fll_error_parameter_integer_print().

Security: Finish implementing string and convert changes.

The observation that some filesystems may have control characters in their names revealed a security issue in the design of this project.
There is no provided way to easily handle control characters or invalid UTF-8 sequences.

I have long been thinking about writing my own printf()/fprintf() functions but have not been willing to go that far.
With the discovery of this security issue, I finally decided to do so.
This then allows me to get rid of the rather messy f_color_print() and similar functions.

The color support and special FLL types, such as f_static_string_t, are now supported.

Due to the size of this change as well as my available time, I have broken up this process over several "Progress" commits.

This implementation is not complete.
I want to implement floating and double support, but I am not about to spend the research needed to properly handle floating and double digit processing logic.

While being similar, there are several differences between the fl_print_format() and fll_print_format() functions with the fprintf() functions.
Most notable of these is the the fl_print_format(), does not lock the file stream and fll_print_format() is a wrapper to fl_print_format() that does lock the file stream.
The format characters are significantly different, see the function documentation.

There are also improvements that need to be made.
Most notable is the digit to string conversion in which the algorithm I chose is a simple algorithm.
While the performance is acceptable for the time being, the performance can be greatly improved upon.
I need to spend time researching in order to improve this.

All of the programs (level 3) have been converted to use this and all of the many of the old ways of printing have been entirely removed.
I used safe printing where the string needs to be safely printing where I was able to identify such cases.
However, given the size of the refactoring, not to mention the work being spread out between days and weeks, I have concerns that I did not get all of the places that should be using safe printing.

Progress: Continue string and convert changes.

Finish changing the fss_status_code and status_code, fixing mistakes identified.
Change fss_identify.
Change iki_write.

Security: Invalid allocation sizes due to incorrect types.

It looks like I added the wrong types on many of these.
I passed the array type in the allocation rather than the type used within the array.

For example, "f_statuss_t" is an array of "f_status_t".
The "f_status_t" is the type within the array but I had accidentally used "f_statuss_t".

This will lead to invalid wites, and therefore, a security issue.

Bugfix: Console parameter processing should handle unknown parameters with -/+ as regular parameters.

If the parameters are not found, then they should be added to the "remaining" set.
This allows unknown parameters to be used as regular parameters.

This is easily seen when using status_code or fss_status_code and attempting to pass a negative number, such as -200.
While -200 should be an out of range error for these programs, it is instead silently ignored.
Given that there is no reserved parameter with -200, then the -200 can be used normally.

There should also be a way to explicitly designate that all remaining parameters are processed as "remaining".
Add a comment by this.
There may also need to be a way to escape these parameters as an alternative.
Such changes are left to another time.

Progress: Continue string and convert changes.

Handle some loose ends in the FSS read programs.

Update fss_status_code and status_code.

Progress: Continue string and convert changes.

Convert several FSS write functions.

Add -O2 optimization by default.

Progress: Continue string and convert changes, fixing bugs.

Convert firewall and the fss read programs.

Update byte_dump, contoller, and fake.

Add -O2 optimization by default.

Progress: Continue string and convert changes, fixing bugs.

Convert the fake program.

Move the "%n" to "%in" to be consistent with how "%un" is used.

Change print string safely to ignore NULL rather than print the NULL character symbol.
This is done to be consistent with existing FLL design.
I realized printing the symbol is a problem when I test the fake build verbose setting.

Add warning output to fake and control programs.

Add -O2 optimization by default.

Provide standard conversion base data.

Progress: Continue string and convert changes, fixing bugs.

The f_conversion_character_* functions should accept uint8_t instead of f_number_unsigned_t.

Implement the "/" character to designate the a partial range.

The "*_except*" string processing functions must accept an offset.
I was really hoping to avoid adding additional parameters but then I realized that I have to have a start offset.
The "except" positions and ranges are relative to the actual start and not the offset start.
The previous behavior of applying an offset to the string before passing results in the entire except positions and ranges to be invalid for any offset greater than 0.

Have F_eos (with error bit set) returned for when end of string is reached while calling fl_print_string_convert().

Rewrite the static/dynamic string argument printing logic.

Update private_fl_print_convert_number() to use bitwise operations rather than comparisons.

Convert the controller program.
Add missing "controller_string_value" and related to controller program.

Progress: Continue string and convert changes, fixing bugs.

Update all relevant dependencies.

Convert the error projects.
Convert control program.
Begin converting controller program.

I really wanted to get rid of those pesky mutex locks.
With the addition of explicit calls to flockfile() and funlockfile() this felt like a possibility.
Unfortunately, I still need to protect both stdout and stderr from both writing to the same destination (which is common for normal consoles).

Security: NULL dereferences discovered by GCC's -fanalyzer.

The socket bind is both missing the parameter check and is passing '&' when the variable is already a pointer.

The f_utf_character_to_char() is a mess.
Not sure what I was trying to do, but it is clearly wrong.
Redesign it to be more correct but I should revisit this for a more thorough review.
There are endianess situations that also need resolved so I added an @todo.