Cleanup: Remove remaining fss_*_write programs.

These are now part of fss_write.

Update: Finish updating fss_write.

Remove the unused files.
Simplify the processing callbacks using ternary operators.
Resolve the void_setting to the specific setting for easier to read code at the cost of allocation more memory (1 memory address variable per function).
Implement the ignore functionality.
Make sure the multiple Content is supported where appropriate.
The flags must not be reset at the start of the setting load so that main.c programs can pre-fill the flags.
Add all of the supported write program setting files.
Other miscellaneous changes and fixes.

The pipe data is lacking and will need future reviews and probably will need fixes.
The original fss_*_write pipe data is also lacking so I feel that it is fine to leave it alone for now to be addressed later on.

Security: Invalid write in FSS functions and ensure a reset used length on error.

The command that triggers this is "fss_basic_write -oc hi there".

An invalid write is happening due to not always performing the array size increase operations.
Update all FSS write functions with more thorough checks.
This problem is being obfuscated by the lossy allocation.

When errors happen the destination->used needs to be consistently reset to the original value on return.

Use the lossy allocation as well for allocation shwere the increase by is a raw digit.
In these specific cases use state.step_small rather than state.step_large.

Rename used_start to destination_used for improved consistency.

Update: Add more notes to 'disable' about.txt documentation.

Cleanup: Update the build disable process.

Cleanup: Make changes to the build disable process documentation.

Bugfix: _di_string_ascii_s_ is missing the _f.

Update: Add mising _d in wrapping defines.

Update: The define _di_f_array_t_ should be _di_f_array_length_t_.

Update: The status code wrapping global constant string wrapping defines should end in _s.

Update: The _di_compiler_attributes_ should e _di_compiler_attributes_d_.

Bugfix: Some of the level checking defines have an "s" that should not be there.

Fix incorrect _di_level_0_parameters_checking_, replacing it with _di_level_0_parameter_checking_.
Fix incorrect _di_level_2_parameters_checking_, replacing it with _di_level_2_parameter_checking_.

Update: The status code wrapping defines should end in _e.

Update: Improve define structure, wrapping global static data in individual ifndef blocks.

Make the example "build/disable" defines scripts more precise to avoid getting defines used from other projects from being loaded in the wrong file.

Use per variable wrapping ifndef defines to have better fine-tuned control over the compiled code.

Fix any problems observed with syntax and naming.

Update: More consistently follow the recent clarifications of the style guide for defines.

I discovered that the "_s" type of notation to be incredibly helpful while working on the stand alone projects.
I also noticed some inconsistency in the naming structure to some extent.

I updated and clarified the style guide and then updated the defines where needed.

This turned out to be more work than expect and has been rushed a little.
Look out for mistakes.

Update: Style guide documentation.

I discovered the style guide is a bit out of date.
As I started cleaning it up I noticed that there is a lot more work needed.

This is a quick pass and more reviewing and fixes should follow.

Update: Add stand alone firewall build.

Bugfix: Add missing dependencies and remove incorrect library from firewall program.

Update: Remove unused "test" mode and add "clang" mode to stand alone builds.

Update: The disable defines files need to be updated when defines change.

Update: The fake stand alone build defines.

Redesign to match the more recent stand alone config.h structure.

This is cherry-picked from 0.6 branch for consistency but another update is going to be necessary.

Cleanup: Add updated type and add commented out status codes.

The status codes should always be present for consistency between programs despite these being stand alone.

Update: The ifndef wrappers should end in _t_ to represent it wrapping a type.

Cleanup: Remove random '_f' in ifndef define.

Cleanup: Update the stand alone utf8 to match how the byte_dump stand alone is designed.

Bugfix: The private is_zero_width function is also needed by the is_graph functions.

Cleanup: Remove random '_f' added to ifndef define.

Update: Wrap the conversion digits defines in _di_f_conversion_digits_d_.

Also remove the extra _di_f_type_number_64_t_ from the build disable defines.

Bugfix: Add missing ifdefs for f_file_stat() and f_file_stat_at().

Update: Add pre-built define files for stand alone use.

Use these per-project files for adding a complete list of functions, structures, and macros with each ifdef define block disabled.

Cleanup: The static inline functions are being included when the function they call is not.

Wrap the static inline functions with the appropriate wrapping defines.

Cleanup: Update stand alone config.h files and add an additional comment.

Bugfix: The type_array is probably a dependency for most of these.

Almost everything is using an array from f_type_array.
Add this dependency to all programs rather than investigating every case.

Cleanup: The utf8 stand alone program does not need the libcap.so.

Bugfix: Incorrect ifndef defines for some functions and structures.

The _di_string_ascii_s_ is incorrect and should instead be _di_f_string_ascii_s_.

These have been exposed while building the stand alone which is very sensitive to the defines.

Update: Add support for backtick quoting for IKI.

Comply with the recent addition to the IKI specification that designates backticks as a quote alternative to single and double quotes.

Fix several inconsistencies observed, such as "quoted" vs "quote".

The code is inconsistently using a type code and a literal character for passing the desired quote.
This is probably a long lost incomplete refactor.
Change all of the FSS code to accept the character as a uint8_t.
Get rid of the f_fss_quote_t and related, replacing them with uint8_t.

Get rid of the f_fss_delimit_* macros.
These are redundant and it is simpler just to use the f_fss_* variants.

Rename F_fss_delimit_placeholder_s to F_string_placeholder_s (and similar).

The flags for single and double quotes are not needed when the charaacter is being explicitly set.

Bugfix: Incorrect parameter passed to iki_read_print_help().

Update: Add support for backtick quoting for IKI.

Comply with the recent addition to the IKI specification that designates backticks as a quote alternative to single and double quotes.

Update: FSS and IKI specification now supports backticks for quoting similar to single and double quotes.

The 0.6 version is not having this support added to prevent API breakage.
This should be supported in 0.7 and greater.

Bugfix: Invalid print of character when a placeholder should be printed in byte_dump.

The following is happening:
  # clear ; echo -n "xa" | byte_dump -wt 2 && echo -n "∩" | byte_dump -wt 2 && echo -n "∩xa" | byte_dump -wt 2

  Piped Byte Dump: (in Hexidecimal)
  0000000000000000  78 61  | x a  |

  Piped Byte Dump: (in Hexidecimal)
  0000000000000000  e2 88  | ∩    |
  0000000000000001  a9     | ∩    |

  Piped Byte Dump: (in Hexidecimal)
  0000000000000000  e2 88  | ∩    |
  0000000000000001  a9 78  |   x  |
  0000000000000002  61     | a    |

In the second case the line 0000000000000001 should not print the string '| ∩    |'.
This is happening because the character is not being properly reset in the situation where the overflow happens at the end of input.

With this change the results should now be:
  # clear ; echo -n "xa" | byte_dump -wt 2 && echo -n "∩" | byte_dump -wt 2 && echo -n "∩xa" | byte_dump -wt 2

  Piped Byte Dump: (in Hexidecimal)
  0000000000000000  78 61  | x a  |

  Piped Byte Dump: (in Hexidecimal)
  0000000000000000  e2 88  | ∩    |
  0000000000000001  a9     |      |

  Piped Byte Dump: (in Hexidecimal)
  0000000000000000  e2 88  | ∩    |
  0000000000000001  a9 78  |   x  |
  0000000000000002  61     | a    |

Perform a trivial cleanup/optimization where inverse of bytes is being checked for.
This is pointless when there is an else block.
Reverse the order and remove the "not" operator.

Progress: Continue program related work, updating fss_write.

Rename F_supported to F_supported and F_supported_not to F_support_not to avoid past tense.

Add a static empty range to make initialization assignment even easier.

For fss_write:
- Add most of the ignore range handling.
- Add support for the multiple Content per Object and handle errors for standards that do not support this.
- Lost of clean up and simplifications.
- Add a lot of fixme and todo comments for things not yet completed.

There is still a lot to do with fss_write.
The common write functionality is mostly done.
The standard specific functionality is not written for anything except FSS Payload.

Progress: Continue program related work, updating fss_write.

Minor improvement to comments and specifications.

I've identified the structure I wanted and this is progress towards implementing the fss_write code across all currently supported formats.

Cleanup: Remove fss_payload_write.

This is now part of fss_write.

Progress: Continue program related work, updating fss_write.

Fix minor spacing problem where the color context should be closed near non-whitespace whenever possible.

Add missing word "error" in some comments.

Continue working in fss_write.
This gets the fss_payload_write program compiling.
The installer by default doesn't handle all of the programs.
Where before './install.sh -w /tmp/fll/' used to work now the following are all needed:
- ./install.sh -w /tmp/fll/
- ./install.sh -w /tmp/fll/ -s data/build/settings.main
- ./install.sh -w /tmp/fll/ -s data/build/settings.payload

Progress: Continue program related work, updating fss_write.

Relocate help and version flag assignment checks across programs.

Setup individual help printing for each supported "--as" parameter in fss_write.

Progress: Continue program related work, updating fss_write.

The work continues, focusing on preparing fss_write for handling all currently written fss_*_write programs.
This should also pave the way for supporting other fss-???? standards than are currently directly represented.

The individual write programs will be linked to the same library fss_write is.
These individual write programs will act as if they were passed the "--as XXXX".
For example, fss_basic_list would operate the same as "fss_write -a fss-0002".

Some of the programs may have vastly different functionality than others.
In any case that code can be shared that code will be shared.

Update: Fix and improve FSS unit test regarding zero-width.

Recent changes to the Unicode functions regarding zero-width improved or changed how what is designated as a zero-width character.
The test is failing due to this change.

Update the test to treat the tested character as zero-width.
Add an additional test condition to test the stop range.

Progress: Stub out the fss_write program.

The fss_write program is going to replace all of the other fss_X_write programs.
This is the initial setup and may not be the final structure.
I still have some fiddlign to do to figure out how I want them to share code.

The final result is intended to have the fss_write being capable of compiling all of the fss_X_write programs as well as the fss_write program.

Regression: Improper execution when no arguments and no pipe are passed to fake.

At some point in time the default for executing without a "clean", "make", or "build" stopped working.
This probably happened when I fixed the empty pipe bug.

The default should run the "make" operation.

Security: Invalid access when calling fake without 'make' or 'build'.

This is caused by the F_data_not return result not being processed in some of the fl_fss functions.

Additional changes:
- Make the return status constant.
- The status is being returned regardless in some cases so remove the effectively redundant lines of code.
- Combined the additional if condition blocks together.

Update: All projects should have fakefiles.

This is an oversight and neither a bug nor a feature.

The FLL is designed to be built using the build settings.
The flagship program fake, should still be directly supported and fakefiles should be available.
Most of these fakefiles just trigger the build settings.

Update: Change the console structure to use bits and prepare console for future changes.

Fix bug whee the level_0 console public functions do not directly call each other and should instead call private functions.

Change the console types to f_console_flag_t and f_console_result_t.

Rather than using the full integer value instead use bits for both the flags and the results.

Rename "enable" to "normal".
Rename "disable" to "inverse".
Rename "other" and "additional" to "simple".
Add "complex" for planned future use.

All equivalence checks are changed to bitwise checks.

Update: The stand alone settings need to use the updated string and utf source files.

Cleanup: Remove unimplemented function.

Regression: Wrong bitwise operator used.

The commit ef89fafafe125e0afbf83476f255f52e176a9c72 has a mistake where the wrong bitwise operation is used.

Progress: Continue program related work.

Clear the setting flags when calling the settings load function.

Clean up some print function inconsistencies.

Update: Finish program related work for fss_payload_write.

This appears to be done now.
The next step for fss_payload_write is to use it as the starting point for the fss_write program that is intended to provide all of the fss_*_write programs.

I will likely make improvements to the lazy approach I took regarding loading the entire file when processing.

I found two bugs regarding the pipe processing.
1) The first character never gets printed for payload Content.
2) An end-of-content character must be printed after the Content if printing partial Objects or if the "payload" Content is not yet printed.

Progress: Continue program related work.

Add additional prunt functions.

Fix out of date parameter names.

Make content_prepend function parameter a constant pointer to a constant string.
Should this instead be a constant pointer to a string?

Progress: Continue program related work.

Lots of print related changes and improvements.

Primarily working on fss_payload_write changes.

Bugfix: The f_color tests are failing due to test design problems.

The mock function is incorrectly setting errno mock.
There is no errno as far as I can tell for getenv().

Improve tests by:
- Adding additional "unknown" string to match.
- Actually test the different modes.

Cleanup: Improve organization in f_utf, using addtional files.

Create more files to better organize structures and their accompanying functions.
Structures like f_utf_string_dynamic_t, f_utf_string_dynamics_t, and f_utf_string_dynamicss_t now each have their own files.

Cleanup: Improve organization in f_string, using addtional files.

Create more files to better organize structures and their accompanying functions.
Structures like f_string_dynamic_t, f_string_dynamics_t, and f_string_dynamicss_t now each have their own files.

Update: Provide the program name in the main library of status_code.

Looks like I can still include the standard program name in common.c without causing any problems by having an override in main-status_code.c.

Update: Merge fss_status_code into status_code.

The only difference between status_code and fss_status_code are different by two function calls, a library dependency, and some constants.

Simplify the code and shrink the resulting binary file sizes.

Bugfix: Output stream is not properly unlocked on signal.

The output stream is locked during some loops.
When an appropriate signal is received while in one of these loops, the program exits.
The output stream must be unlocked before returning.

Bugfix: Add missing f_type_array dependency.

The f_type_array dependency is now present in the build settings file.

Cleanup: The fake program doesn't depend on fll_iki.

Feature: Add support for additional dependencies and settings files in level_3.

The package.sh build system helper script now supports additional dependencies and settings files.
This allows for special build modes, such as how the controller program has support for "controller" and "init" programs.

Bugfix: Incomplete UTF-8 zero-width detection, particularly for combining characters.

The zero-width calculations should be and are not including zero-width and most control characters.
The combining characters and most of the control characters are now considered zero-width.

Cleanup: Add comment about special control code handling.

Cleanup: Add comment about BOM.

Bugfix: Incorect spacing when combining --unicode with other digit displays.

The original calculations are again the 6-digit Unicode "U+1234".
There are also 8-digit Unicodes "U+123456".

Update: Slight improvement in UTF unassigned detection and add or correct some ranges.

Change "character" to "sequence" to be consistent with the rest of the private functions.

Add several additional checks to ideally reduce the number of checks.
This is only a cursory pass and not much effort is put into fine-tuned optimization.
There is huge room for improvement.

I discovered some ranges that needed to be added as unassined and added them.
Include the invalid ranges as unassigned.

Bugfix: Two 0's are printed when --total is used and there are no matching Objects.

There is an optimization used that immediately prints 0 and returns if there is no matching data on load.
The problem is that the caller isn't told that it should stop processing because F_none is returned.

Remove the optimization rather than implementing a custom return code and changing the code to handle this.
The normal code is still run and still correctly determines that there are 0 Objects.

Feature: Add support for ZSH in addition to BASH.

Some systems have started provided ZSH for license reasons (they don't want to agree to the license of BASH).
I experimented with and found that I can make my scripts ZSH friendly.

There is no way to "detect" that ZSH is being used as far as I can tell so I defined a new environment variable SHELL_ENGINE.
Set this to "zsh" and then run the script via the "zsh" program.

Enable emulation mode of "ksh" when using ZSH to be BASH friendly.

The ZSH doesn't support "${!i}" substitution.
I found a separate way to do this in ZSH via "${(P)i}".
It is a shame that they cannot simply replace "(P)" with "!".

There are several cases where "bash" is being directly called.
Replace this with a "shell_command" environment variable.
In some cases, directly calling "bash" may cause a loss of needed environment settings and so "bash" is not directly called when using BASH but "zsh" is still directly called when using ZSH.

The ZSH does not automatically handle arrays as well as BASH does.
Explicitly define arra with "-A" and explicitly set the initial value to "()".
Doing this may introduce problems with older versions of BASH that do not support "-A".

The ZSH cannot expand parameters as intelligently as BASH.
Parameters followed by certain characters, such as a bracket, that are not encases in braces result in ZSH errors.
Mass change many of the parameter uses to always be in braces.
Not all cases are changed and there may be some areas where I intended to make such a change and missed.

The ZSH appears not to handle output redirection from shell functions.
This behavior is used heavily in the project for building and using the variables array.
Change the behavior (at the cost of making the code a bit ugglier and harder to read in some cases) to assign a variable defined at a higher scope (such as "key").

The ZSH also appears to utilize "path" as a variable for "PATH" or is case insensitive when it comes to environment variables and shell variables.
This is a serious problem.
The variable "path" is defined so rename that to "path_" to avoid conflicts (and I'll just have to suffer cringing every time I see that trailing underscore).

I stumbled onto some bugs as well while making changes.
The necessary changes change the code that is buggy so I am allowing it to be in the same commit.
One of the bugs is a typo where errror is used rather than error.
Another bug is where the c_warning is used and then c_error is used within the same string (should be consistently using c_warning in this case).
It turns out "has-build_compiler" is not defined but conveniently a space for it is missing in bootstrap.sh (must be an accidental delete given the coincidence).
Some of the "mode" properties are incorrectly being assigned the non-mode value when a mode value exists in bootstrap.sh.

Cleanup: Rename and relocate private is_unassigned files.

The private-is_unassigned.c and private-is_unassigned.h are in incorrect locations and have incorrect names.
Relocate and rename to make these private files consistent with other private files.

Update: Support Unicode 15.0.

I couldn't easily find what Unicode version I am trying to suppot so I added a unicode.txt document.

The initial work was done for Unicode 12.1 and later switched to 14.0.
I was still in the initial stages of learning Unicode and so I expect there to be notable incompleteness or incorrectness.
With the release of Unicode 15.0 I am able to determine a distinct set of changes and I have applied the changes.

Add a private_inline_f_utf_character_handle_digit_offset() inline function to simplify some of the redundant code.

Progress: The iki_read should also support the previous "--substitute" behavior via "--reassign".

A "--substitute" bug is now fixed where the "--wrap" is applied.
It seems to me that the old behavior of "--substitute" should still exist.
Introduce a new parameter called "--reassign" that provides the old substitute behavior.

Progress: Fix additional problems in iki_read.

This is a follow up to bcaeef117bede5037b0404ebf299446dd1be3fcc.

The substitute is not completely updated to also process the --literal parameter.

Should be using f_console_symbol_long_enable_s instead of f_console_symbol_short_enable_s when printing errors.

Cleanup: Remove no longer accurate help message in iki_read regarding "--wrap" with "--substitute".

The "--wrap" now works with "--substitute" rather than being ignored.

Update: Should be using f_file_stream_flush() instead of fflush().

There is a f_file_stream_flush() function that should be used instead of fflush().

Progress: Fix problems in iki_read.

As I suspected, the interruptions resulted in incomplete and problematic code.

Fix copy and paste problems where modulus should instead be a slash (divide).

Use _increase_by functions rather than _resize functions to be more memory recycling friendly.

When processing parameters the index relative to the argv should be used.

Change the logic in the loops to increment "i" across all parameter values rather than the total sets.

Fix copy and paste mistakes where "wrap" is being incremented for non-wrap data.

The "--whole" parameter is not being processed and having the appropriate flag set.

The print function has incorrect ordering and structure of some of the functions called.
The print function is further simplified now that settings is passing the flag along.

The "wrap" append functions are not comparing against the correct variable (I swapped them by accident).

Do not do "register" types of optimizations at this point in time (this can be done far in the future when things are stable-ish).

Be sure to clear the lengths using memset().

The variable "k" can be moved inside the if condition following its assignment.

Refactor: Change FILE * to f_file_t when printing.

Due to the by-design restrictions, the f_file_t cannot be defined in f_file project and be used in another level_0 project.
The f_print project cannot depend on f_file project and cannot use f_file_t.

I spent some time considering this problem.

The f_type project is a special case core project that othe level_0 projects can depend on it.
This project also provides types and f_file_t is a type.

Move f_file_t's definition into f_file project.
I want to avoid always pulling in file related headers.
The the f_file_t is defined in a separate file "type_file.h".
The "type_file.h" must be manually included when needed.

With type_file.h in place, the print projects all include "type_file.h" and utilize f_file_t.
The "FILE *" stream is now replaced wth f_file_t.

This simplifies the code, makes it easier to use, and makes it easier to maintain.
For example, "fll_print_dynamic_raw(f_string_eol_s, main->output.to.stream);" can not be "fll_print_dynamic_raw(f_string_eol_s, main->output.to);".

I made this decision in the middle of a "Progress" change process.
There may be code missed and tests may need to be updated at some point after the "Progress" change process is complete.

Cleanup: Remove unused/dead code.

Progress: Continue program related work.

There has been a lot of interruptions with this particular pass.
Additional review is recommended.
I specifically need to review the iki_read for all of the parameters and make sure that there are no regressions.

Simplify the code, replacing f_iki_content_t, f_iki_delimits_t, and similar with direct types such as f_string_ranges_t and f_array_lengths_t.
This reduces some of the flexibility but increases the maintainability.

Make some of the print error functions accepts the symbols for both the first and second parameters.

Add additional error print functions.

Fix problem with --help printing.

Comment consistency improvements.

The iki_read program is updated to follow the design changes regarding programs.

Clarify certain aspects of the IKI specification.

Progress: Continue program related work.

Add more common program print functions.
The parameter missing function is ironically missing the print messages.

I've decided to accept the loss of binary size for improved runtime efficiency (both of which are likely slight losses and improvements).
There are now "unlocked" and "locked" print line first and print line last functions for each program.
The boolean for designating lock is removed.
These functions are mostly wrappers and so the cost in size to be hopefully negligible.
I imagine time will tell whether this is an overall good or a bad decision.

Start working on iki_read.

Update: Add support for stand_alone builds in the example bootstrap script.

The bootstrap-example.sh script now supports building in "stand alone" mode for any program that has the mode defined.
The currently supported programs "fake" and "utf8" are still hard coded.
Future versions may check for the existence of the named files rather than being hard coded.

Update utf8 to compile.
Make the same changes for fake, but fake is not yet read because it has not been migrated yet.

Bugfix: The fll_program_standard_signal_received() changes are incomplete and break tests.

This is a forward port of the commit ed22b926b67429681841b6b0dc3d76daca1b451f that fixes the problem from the commit ed22b926b67429681841b6b0dc3d76daca1b451f.

I forgot to update the new "stand alone" build settings with the new private source file.
The tests now use this "stand alone" build for building fake and using that fake to perform the tests.

Fix a problem with existing code that has incorrect macros.

Update: Cygwin documentation.

Progress: Continue program related work.

Slight restructuring of memory allocation:
- Add or move double free and and unnecessary free checks.
- If amount 0 for increase functions, then do nothing.
- When resizing, perform a stale check in case strings point to a static string.
- The private_f_memory_structure_resize() should properly return the error response.

Remove fll_program_parameter_long_print_cannot_use_with().

The fll_program_standard_set_down() needs to check both the stream and the descriptors when closing rather than one or the other.

Explicitly set signal_received to uint32_t rather than int.
- The signal needs to also be uint32_t rather than f_status_t.

Add several new print functions for common print messages used by the programs.

Switch from flockfile() to f_file_stream_lock() and from funlockfile() to f_file_stream_unlock().
- There are still a lot more cases where these changes need to be made.

Add more function documentation.

Use "greater than" rather than "not equal to" for console verbosity checks.

More changes to these programs:
- fss_status_code
- iki_write
- status_code
- utf8

Progress: Continue program related work.

The pointer is a double pointer in the memory function and as such the NULL check should be performed in f_memory.

Add print source and header files to all programs.

Stub out the necessary changes regarding the new setting data type in all programs.

Move file stream functions into their own files.

Add missing file stream lock and unlock functions.

Add F_okay and F_okay_not status codes.

Get utf8, status_code, and fss_status_code working with new program design (including the new settings data type).

Progress: Working on program related changes and fix version number.

Continuing work in regards to making program related changes.

I managed to miss another set of files that have version numbers.
I should probably write a script to consistently handle this in the future to avoid these kinds of simple mistakes.

Change the behavior of the color loaded to allow for more flexibility.
The previous design was a quickly put togethor hardcoded approach.
I want to get away from such practices.

Add missing dependency in f_color.

I am at a cross roads of flexibility and maintainability (as well as size).
The practice of always having and using a typedef allows for great flexibility (allows for easy hacking/modifications).
As per my practice, I should have explicit functions for allocating, deallocating, and similar functions.
These waste space, consume time writing, and consume maintainance related time.
I want to increase the maintainability of the project given that my current goals are far reaching.
This means that I should switch to existing typedefs for any simple data type (except for special cases like strings and f_string_t).
I am starting this conversion with f_color, using the uintX_t types rathe than custom types like f_color_mode_t.

Start using enumerations over define macros.

Make the console parameter processing functions more flexible by returning the decision at the index rather than the converted decision value.
This allows for the caller to know which index is used.
The caller can do more work based on this without having to do more looping.

Add line_first_no and line_last_no standard parameters.
These add more flexibility for special case scripting.
Many core printing functions now do not print the leading new line.
All programs must be updated accordingly.

Add and document new console parameter initialization macros.
Start a new style practice with the console arguments, based around these new macros.

The f_file_stream_flush() should not need f_file_t parameter to be a pointer.

The memory functions now return F_data_not in more situations that make sense.
When size is 0 for allocation functions, this should be a paameter error when doing parameter checking.

The pointer should be allowed to be NULL when allocating.

Some fll_program functions are supposed to be using private functions due to internal usage.

The standard help options now have a standard printing function.

The fll_program_parameter_process() is removed.
Instead, call f_console_parameter_process directly.
The color context handling is moved from the now deleted fll_program_parameter_process() into fll_program_parameter_process_context().

The fll_program_data_t now accepts a pointer to the environment variable array for representing the environment variables are start.
The fll_program_data_t now uses flags rather than a boolean to represent program pipe (allowing for more than just input pipe, in theory).

Add new status codes:
- F_help
- F_help_not

Major work is completed into making the utf8 program more flexible.
- Moved all parameter processing into utf8_setting_load() and provide utf8_setting_t.
- This allows for callers to manually configure the settings without performing parameter processing if so desired.
- Re-design printing logic to handle the line_first_no and line_last_no parameters.
- The status used by the utf8_main() is now in utf8_setting_t.

Related changes have been lazily applied to all other programs.
Once I am finished with utf8 (which I might already be), then I will beging moving to each next program.

Progress: Begin breaking out internal parameters to allow for better caller control in programs.

Starting with utf8, start the process of breaking out the parameter settings into a variable that the caller can customize.
This should improve extensibility such that the caller can provide their own initializers.

Other incidental changes are made.

Progress: Changes to fll_program functions.

Reduce needed arguments to fll_program_parameter_process().

The color loaded is now handled in fll_program_parameter_process().

Add fll_program_parameter_process_verbosity().

Rename fll_program_standard_setdown() to fll_program_standard_set_down() and accept fll_program_data_t rather than f_signal_t.
Rename fll_program_standard_setup() to fll_program_standard_set_up() and accept fll_program_data_t rather than f_signal_t.

The fll_program_standard_set_down() now handles closing all file descriptors, incliding standard ones.

Change "bool process_pipe" to "uint8_t pipe" in fll_program_data_t to allow for multiple bits to be used.
Add "fl_print_t message" and "fl_print_t debug" to fll_program_data_t to give caller more control over different possible buffers.

Update: Major changes regarding file functions.

I like having support for "standard" debug and "standard" warning.
The problem is that there is no such standard.
These are made available in case there ever is.
I want to simplify the code, so get rid of this non-standard "standard" code.

The low-level file functions inconsistently used id, stream, and file structure.
Switch everything to use the file structure.

Relax function errors by having invalid stream or invalid file descriptor return without error bit set.
In these cases use special status codes F_stream_not and F_file_descriptor_not as appropriate.

Simplify the functions to be simpler.
Some of the functions, namely the close functions, also support conditionally flushing before close.
Remove the flushing and the passed boolean.
Let the caller use two functions directly rather than building this in.

Add missing function for flushing via the file descriptor.

The private_f_file_flush() function is missing several disable macro checks.
(This change needs to be backported.)

This change does not address the tests.
This change does not address the programs that use or might use the changed, new, or deleted code.

Cleanup: Fix comment regarding endif.

Regression: Recent changes in f_account header structure is incomplete.

The commit 0c4573ee9698e6f0980c4496a5f23b42946adbd3 (and possibly later commits) resulted in compilation failure.

Update: Implement stand alone build for UTF8 program.

Cleanup: Add missing dependency in UTF8 program.

Update: Stand alone Featureless Make custom config.h header.

Fix some mistakes.
Add several more disable macros to further shrink the size of the resulting binary.