Update: basic list fixes and cleanups, including some other cleanups.

The EOL handling in FSS Basic List is incorrect/incomplete.

Slashes at the end of an Object must be delimited to avoid escaping the object close character.

Be sure to return an error when a newline is provided in an Object name on basic list object write.

The standard states that controlling character, such as a basic list open, must use ASCII character codes for simplicity and safety.
Therefore, a UTF-8 buffer increment is not necessary.
Use the simpler, more performant C math operator increment.

Cleanup coding strategy in basic list content write to be more consistent with more recent approaches.
Cleanup some comments.

Also cleanup incorrect loop comment in fss_basic.c.

Progress: basic list write, with minor basic list read and extended list read changes.

The basic list object write should only handle escaping slashes when it would be escaped.
Make sure to return an error when a newline is found.
Note that the stop point designates the end of the object so if the end of the object ends in slashes, then these must be escaped.

Perform some cleanups that I felt like doing while working on this.

Cleanup: fix help parameter spacing and add additional information.

The basic list standard does not support quotes.
Leave the quote parameters for consistency between the write programs, but add a note to the help explaining this.

Bugfix: the color output is incorrect.

Fix the dependencies:
- Remove dependency to fl_color.
- Add f_color.
- Add f_file.
- Add f_print.

Bugfix: FSS basic list read newline handling needs improvement.

The last newline is not being preserved in the content read.
The *_print_set_* functions end up printing an extra newline.

This behavior is inconsistent and invalid.
Instead, preserve the newlines, which are valid parts of the content.
Then, do not print newlines via *_print_set_*.

The empty list needs to have at least one newline when -e/--empty is passed.

Progress: continue working on FSS read/write programs and related.

Get comment delimitation working in FSS read/write functions.
- Comments are now escaped on read/write as appropriate.
- Rename appropriate private fl_fss functions.
- Add object_as boolean to designate whether or not this function is meant to read an object or content.
  - This ends up fixing a bug in the fl_fss_extended read function where a comment character before a content is incorrectly treated as an actual comment (this behavior is not allowed).
- Add similar behavior to the write functions.
  - The basic list and especially the extended list may not be complete in this regard.

Do some cleanup in the fss read programs that is related to the changes in this commit.
- There is still room for cleanups but that is not my focus at this time.

Add a -p/--pipe parameter to the FSS read functions to provide a way of returning data in the pipe-friendly format used by the FSS write programs.

Update: console improvements and fixes.

Get rid of total property.
This is redundant and too short.
Instead, use the location.used, which is an unsigned long as opposed to a uint8_t.

When I changed the result from an f_string_length_t to an f_array_length_t, I missed some places where the type needed to be replaced.

Progress: fss write functions and programs.

I reviewed, fixed, and cleaned up the write functions.
I have only partially gotten to the basic list and have not so much as glanced at the extended list.
These two I will start working on later.

Several bugs and problems have been identified and resolved.

Add back the UTF-8 processing.
- This time check the width and add each 8-byte sequence until width is reached to correctly process the UTF-8 character.

Progress: fss write programs and related, including console changes.

Finish updating the fss write programs.
I will sleep on this and then review them later to look for mistakes, oversights, bugs, inconsistencies, and possible cleanups.

Improve the console parameter handling functionality.
The sub-locations need to also have their locations stored.

Cleanup the struct stat file_stat name, renaming it to stat_file for more consistency.

Remove some memsets(), these might be better left to higher level operations.
Assuming I do not change my mind on this later.

Use the word "amount" instead of "length" when the increase/decrease is not the whole length but a fraction.

Reorganize some string functions parameters to be more consistent with the current design practices.

Feature: add -c/--content parameter to FSS read programs.

The default behavior is already a -c/--content.
This provides a literal parameter for good practice and better hackability.

This introduces a new possibility where both -o/--object and -c/--content are specified at the same time.
In this case, print both the object and the content.
It must be noted, however, that this only prints the escaped object and content, just like when -o/--object or -c/--content do already.
The objects in the basic read and extended read are printed with a space between them and their respective content.
The objects in the basic list read and extended list read are printed with an EOL ('\n') between them and their respective content.

Bugfix: consistently handle last newline location in fss basic list read.

The last newline should not be included.
This is done in parts of the code, but not all of it.

Progress: FSS related changes and improvements to console related.

Finish/Fix the basic object write private function.
It seems that I was so hasty to get this wrapped up last night that I missed quite a lot of conditions/cases and logic.
I discovered a case where the FSS basic read function might b incorrect: '"\\"\\\"'.
If the parts inside the single quotes are used as an object, then it should detect that there is no closing quote.
The basic read is not yet fixed, but the basic write should not produce this invalid object.

Minor tweaks to f_console and related console functions.
The f_true and f_false are still being used in the console initialization and should no longer be.
There are some has_additional settings that are set incorrectly.
The console parameter locations and similar should be array locations and not string locations.

Progress: FSS development and other changes.

Work on the FSS Basic and FSS Extended write functions, changing the design strategy.

The FSS Extended Write program needs additional consideration for how to handle multiple content (which may entail changing the logic of FSS Basic Write accordingly as well).
The Basic List and Extended List are currently not worked on but will be.

Use "quote" instead of "quoted".
After review, this makes more sense to me overall.

Fixes of other observed issues, such as missing "_t" in some macros.

Update the FSS documentation, focusing on the FSS Basic and possibly FSS Extended.

Bugfix: the fl_string_dynamic_terminate() function is not correctly checking the NULL.

In the case of when the array is not allocated (size == 0), the terminate is still checking the string index.
This is an invalid read.

Also, the logic is revered on the string index read.
The check needs to be "!0" instead of "0".

Progress: fss write programs synchronize.

Work on making the fss write programs function more similar to how the iki_write program functions.

There needs to be more work done in the fss_basic_list write at level_1, but that is being left to be worked on for another commit.
Looking at the code once again reminds me that the FSS read and write code needs to be reviewed in more depth, but I am going to put that off for now.

Other minor fixes and cleanups.

Update: iki_read and iki_write.

Make sure the private header files use "IKI" in the comments and not "FSS".

Switch ove to using F_status_is_error_not() instead of F_status_is_fine().

Make sure iki_write actually uses the stream write.

Fix verbiage of "content" to "data" to avoid potential misunderstandings that this is referring to a "content" as defined by the IKI syntax.

Fix some cases where f_type_error was still being used instead of the data.error.to.stream.

Rename the variable "input" to "pipe" to be more explicit.

Cleanup: minor syntax.

Bugfix: fss read programs should return 0 on invalid/empty files when --total is passed.

Progress: add additional f_file stream functions, improve existing f_file functions, and continue print changes.

The stream read and write functions should also be implemented.
This is just an off the top of my mind implementation and may need to be reviewed at a later date.

Change the existing f_file functions to re-use the existing string structure to avoid the more wasteful memset and memcopy from the static array.
This design now, instead, has a cost of potentially allocating more memory than needed at the size specified by file.size_read.

Continue the print changes.
There is going to need to be work done in regards to how I am reading opening and reading streams.
I started to do this in private-fake.c but then noticed some things that needed review, such as the path.current and path.top.

Bugfix: incorrect read.

The at variable is already being checked to be out of range.
Do not attempt to then check the variable in the array.

Security: Incorrect size increase in private_fll_iki_content_partial_escape().

The size increase test is "escaped->used + delimits + 2", but actual arguments passed to the increase function is "delimits".
The "+2" is missing.

This gets caught by the parameter checker when delimits is 0.
When delimits is, say 1, then an insufficient amount of memory is increased.
This will likely result in a segfault.

Bugfix: use correct variable name.

Update: check if stream exists before attempting to close stream.

Update: replace fake_print_message_file() with fll_error_file_print() and other minor changes.

The fake_print_message_file() function is no longer needed and should be replaced with fll_error_file_print().

Progress: wrap up most of the print changes.

This appears to get most of the changes in regards to printing.
There will need to be some testing and reviewing to double check for any mistakes.
(With such a massive set of changes, minor/subtle mistakes are likely.)

I will resume my work on updating and getting the fss write functions to be more like the iki_write in some of the design practices (in terms of program operations, parameter usages, etc..) where applicable.

Bugfix: iki_read_console_parameter_t_initialize is missing a parameter.

Also correct the iki_read_total_parameters length.

Update: bzip2 fakefile.

Make sure the bzdiff and bzgrep scripts are copied into the build/ directory.
Redesign the fakefile to be an example of how to use the "operate" section operation.

Progress: continue work on updating print code changes as well as synchronizing level 3.

Progress: print function changes.

After getting byte_dump switched to file descriptors and testing it, I discovered that the unbuffered write has massive performance issues over the buffer writer that is a file stream.
Do some back pedalling and then go down a different route.
Add functions for managing file streams.
Make it possible to have both the descriptor and the stream to give more control at the higher level on when to decide which to use.

There is still much more cleanup, back-pedalling, as well as redesigning the code to (now) use fprintf() over printf() and similar.

Progress: begin overhauling the printing infrastructure.

As part of making the level_3 projects (aka programs) more consistent, I started centralizing the print functions.

This started with status/error handling.
Then one thing led to the next and I ended up deciding to change the behavior to use file descriptors more consistently everywhere in the FLL project.
I also decided to go with the error print structure I original created in the fake program.
Verbosity has been moved into this structure.

The new level_2 project "fll_error" will store the error messages that are shared between the level_3 projects.

Given the size of these changes, I didn't complete the work.
This commit is guaranteed to not compile.

Progress: start getting FSS, as well as other programs, more consistent.

I ended up liking how I made iki_write better than how I made the fss write functions.
Work began to make these more similar and consistent and I stumbled on some other things that need to be centralized.

This would be the verbosity options and parameter decision making.
This includes related changes.

I also noticed that I started working on the "++status" parameter idea but left it very incomplete.
This formalizes the basic plan where I will instead have a "++status_in" and a "++status_out".
This should be very useful for having programs return status codes as well as read those via environment variables given than the status code the Linux code uses reserves the higher order bits for process signals.
It would be too risky and likely buggy to mix my internal status code system with the standard Linux signal/error status code design.
A sting can be read very easily in an environment variable and converted to the appropriate uint16_t digit.

The work in regards to making FSS and other programs more consistent is incompletely and will likely result in uncompilable code with this commit.

Update: move the, now standard, verbosity modes into the f_console project.

The f_console project already provides the parameters matching these modes.
This makes me think that this is the best place to relocate the verbosity modes.

Bugfix: add missing include to f_signal.

This was also missed in the previous cleanups, breaking compilation.

Cleanup: f_memory should also be using underscores "_" instead of dashes "-" in the filename.

Cleanup: f_single is not filly updated to using signal-common.h

Cleanup: used !x instead of x == 0.

This is a better practice.
While a compiler nowadays might optimize x == 0, it is better practice to use !x to represent the logic and reasoning.
One should always be aware of simple performance optimizations and practices, even if it might just be compiled away, if the readability is not too difficult.

Cleanup: header files structure, *-common.h, and use underscores.

Start using the *-common.h practice to move macro definitions out of header files with function declarations.
The *-common.h files are akin to private-* files in that they are special use or special purpose.
Therefore, the "-" is used.

In all other cases, underscores "_" should be used.
Fix files where dashes "-" were incorrectly used, replacing them with underscores "_".

Cleanup: syntax and structure.

Bugfix: more incorrect macro implementations.

The are some more macros needing to be updated to use the "_macro__i" instead of "i" for safety reasons.

Bugfix: incorrect macro implementations.

There are some cases where the wrong macro is being used.
The init program needs to be updated to use the "_macro__i" instead of "i" for safety reasons.

Refactor: color management system.

Change the behavior so that fewer arguments are needed for color printing.
This introduces a structure where the color codes are now in sets of "before" and "after".
This set of two color codes are now passed to the color print functions, thereby reducing the number of arguments needed.

Cleanup: rename f_print_string* functions to f_print*.

This shortens the name.
The "_string" part is not needed as this should be considered the default behavior/interpretation.

Cleanup: basic maintenance pass on some level_0 projects.

More maintenance commits to come.

Update: cleanup f_print and add f_print_to* functions.

Move shared/duplicated code into a private function.

Add the f_print_to* functions to allow for printing to a file descriptor, similar to dprintf().

Update: add support for verbose and color modes in bootstrap example script.

Getting verbosity is helpful when using this bootstrap script for testing.
Might as well add support for color modes as well.

This only implements the short parameters, it is not meant to simulate a full blown program.

Cleanup: add -fdiagnostics-color=always to GCC flags in build settings files.

This forces colors to be enabled.
GCC thinks colors should be disabled when Featureless Make runs it in a shell.
By setting this, the color is forced enabled and error messages become more readable.

Bugfix: iki_write needs to handle the error cases where -o/--object and -c/--content do not have parameters.

The -o/--object and -c/--content parameters both require an additional parameter.
If that additional parameter is missing, then error out.

Update: add missing -f/--file processing to iki_write.

I completely forgot to finish this.

The file option should now write to a file in append mode if specified.

Cleanup: IKI project dependencies.

Update: add project name when calling featureless make in build mode.

The downside is that the settings must first be loaded.

Cleanup: add -c/--content for consistency to iki_read.

The -c/--content is the default behavior.
This adds a literal parameter to reflect this.
No new functionality is added other than validation on the -c/--content parameter.

Bugfix: incorrect printout when using -w/--whole mode.

The start range is not being set when it should be resulting in the wrong start point being used when printing a given range.

Feature: add iki_write and all related dependencies.

Update: f_file, f_fss, fl_fss, fl_utf, level_3.

f_file:
  - Fix some function ordering.
  - Do not use "0" to represent closed files, instead use "-1".
    - "0" is used for standard input, which treating this as file closed prevents piped data from being read.

f_fss:
  - The f_string_range_t should have _t in its macros.
  - Updating all related code.

fl_string:
  - Fix some function ordering.
  - Add fl_string_dynamic_sink_line().
  - Rewrite function parameter ordering to have constants on the left and editable pointers on the right.
    - While I also like the logical flow of the previous behavior, during my development the practice of separating first by constants and then editable pointers won out.
    - Updating all related code.

fl_utf:
  - Rewrite function parameter ordering to have constants on the left and editable pointers on the right.
    - While I also like the logical flow of the previous behavior, during my development the practice of separating first by constants and then editable pointers won out.
    - Updating all related code.

level_3:
  - Make f_console_parameter_ids_t and f_console_parameters_t constants, where possible.

More of the project will need reviewing of function parameter ordering.

Update: next micro version (0.5.1).

Update: use *_size_increase() functions, improve logic, and return F_string_too_large.

Use the *_size_increase() functions more.

Anything declared inside of a loop is destroyed at the end of the loop and created at the beginning.
This is an easily avoidable performance concern.

When the max size is reached but allocation is still possible (but at a smaller than requested length) return F_string_too_large without the error bit set.
This is useful for when only 1 unit is needed but the resize is say 4.
In the cases where the resize must exactly match the given length, then treat F_string_too_large without the error bit as if it does have an error bit.

Update: get only exist status when processing return, use "return_code", and set return error manually where applicable.

The return code also stores signal information.
To properly return the expected return code, WEXITSTATUS() should be used.

In some cases a return code of "0" is always returned, even on error.
In these cases, now return "1" if an error is detected.

Use "return_code" more consistently, it is more explicit than "result" or "results".

Progress: featureless make, finish implementing reserved parameter support.

Cleanup: rename F_status_is_not_error() to F_status_is_error_not() (and similar).

Also utilize F_status_is_error_not() over F_status_is_fine() in Featureless Make.

Update: implement signal support, rewrite execute functions to accomodate signals, and update featureless make to utilize signals.

Update: Improve execution functions to use fewer allocations.

While the project is allocation heavy, I do try to avoid allocations where I reasonably can without breaking the design.
In this case, I can see no reason for allocation this memory in this way.
All that needs to be done here is just to point to the existing strings!

Update: add and example fakefile that compiles the Linux kernel using "GNU Make".

The Featureless Make program can be used beyond its intended purpose.
This provides an example of such.

As this product is open-source, I love to emphasize the freedom others have to take this and do as they would.
Hack away!

Bugfix: featureless make parameter substitution is incorrect.

The "return" code is appearing when the IKI "parameter" is used.
The reserved word check is operating on the wrong variables and is incorrectly injecting itself into the arguments list.

Update: Improve featureless make parameter processing.

Implement a better approach for addressing multiple operations.

For example, one can now (for whatever reason) do "fake clean make clean clean make".
Then the program should operate by running clean, then make, then clean, then clean again, and finally make again.

Progress: featureless make.

Finish implementing -f/--fakefile and updating -s/--settings parameters.

This adds a new function f_path_is(), which is a dirt simple function for checking if the path separator exist in a given string.

Progress: featureless make.

Fix refactor mistakes where some dependencies files accidentally had the type suffix '_t' appended in a previous commit.

Re-execute the dependencies script, refreshing all existing dependencies.

Begin adding a new parameter to specific a specific fakefile.
This part is incomplete.

Begin updating how the settings parameter works in regards to how the path to the fakefile is handled.
This part is incomplete.

Add example custom fakefile for the bzip-1.0.8 source.

Fix problems observed while trying to make these changes:
- The build process needs to store stage files per settings file so that multiple different settings may be built.
- The wrong path was accidentally used for loading the fakefile.
- The fake fakefile needs to use 'indexer' now instead of 'linker'.

Note: the fakefile stage files should also behave the same way as the build stage files, but this isn't implemented just yet.

Update: rename f_file_move to f_file_rename, add fll_file_move, and address printf().

The move function should operate as a move would expect, which includes cross-filesystem.
Rename the f_file_move() to f_file_rename() and ensure the limitations are documented.

The fll_file_move()  calls f_file_rename() and if that fails due to being across filesystems, then call the appropriate clone and remove functions depending on whether or not the source is a file or directory.

I try to avoid having any output strings in the project that is below level 3 (but level 2 may have exceptions).
Rewrite parts of the directory copy and clone functions to use passed functions instead of directly printing.

Cleanup some function's documentation.

Progress: featureless make.

Implement file move functions.
- There will need to be future changes to allow for moving across filesystems.
- This move across filesystems may need to be an fll_file_move() so that it can either do a directory clone or a file clone.

Fix a typo 'perforrm', which should instead be 'perform'.

Add 'F_mount' status code.

Implement the move section operation.

Progress: featureless make.

Fix mistakes where I forgot the '!' in the parameter check comparisons.
Fix mistakes where I used 'i' when I needed to use 'j'.

Finish implementing clone.
Finish implementing copy.

Progress: featureless make.

Seems I completely forgot some basic section operations:
- copy
- move

This prepares foo implementing a copy, a clone, and a move.

It seems that there is no directory_move or file_move function, so these need to be implemented.

Update: recursive functions, fix 'const const', don't error on max recurse depth.

Rewrite the fl_directory_* recursive functions, simplifying their design.
Add a max recursion depth.
I have a toleration limit on the number of arguments in a function and this just reached a limit.
Given that many of the parameters can be logically grouped and are also are also passed to other functions, implement a new structure.
While this simply changes where the complexity/problems happen, this does alleviate the number of arguments concerns.

Fix an accidental 'const const' declaration.

Don't error on max recurse depth.
This should just stop recursing for that directory and not generated an error.

Progress: featureless make.

Implement recursive change owner, change groups, and change modes functions.
These are implemented in the fll_file project.

Then utilize these for the recursive owners, groups, and modes section operations.

Fix specification where I forgot to rename "archiver" to "indexer".
In documentation it is "indexer" and not "index" for the indexer program whereas "index" is a section operation name.
Fix documentation where I forgot to rename "archive" to "index".

A bug in fl_directory_list() was discovered where the parameter check for path is incorrect.

Cleanup: add missing dependencies to featueless make bootstrap.sh script.

Cleanup: rename linker/archiver to indexer in featureless make and tweak bootstrap.sh.

The linker program 'ar' creates an archive which is essentially an index.
By switching the words from linker and archiver to indexer, I believe that I can avoid terminology conflicts.
This avoids conflicting the 'linker' in terms of 'ar' and the 'linker' in terms of 'ln'.
This avoids conflicting the 'archiver' in terms of 'ar' and the 'archiver' in terms of 'bzip2'.

Use "return" instead of "exit" in bootstrap.sh.

Progress: featureless make.

The fake_execute() should return the "return code" for optional processing by caller.

Implement the reserved parameter IKI vocabulary name "return".

Remove the arguments.used checks inside of fake_make_operate_process(), the validation process already handles this.

Fix names for fake_make_parameter_variable_* defines.

Relocate some define/parameter documentation from specification to documentation and update the specification accordingly.

Cleanup: fix wording of documentation.

Update: featureless make fakefile build section operation should allow a custom file name.

The documentation mentions this to some extent.
Actually implement this and update the documentation.

Cleanup: featureless make example bzip2 build data settings files.

The shortcomings have been addressed.
Simplify the example build data settings files by removing unnecessary settings.
This should further emphasize how simply and easy the featureless make build operation can potentially be.

Add simple documentation to the bzip2 example build data setting files.

Feature: featureless make should support custom source paths in data/build/settings.

The standard path is used by the featureless linux library.
If any other project, such as bzip2, has its own directory structure provide a way to more likely support that when using the build operation.

This is not intended to handle all possible cases.
This is only intended to handle simple cases such as with bzip2.

For more complex builds the fakefile and the make operation should instead be used.

This adds a path_standard setting that is a yes/no boolean for designating if/when to follow the standard source path structure or not.
When this is 'yes', then the standard sources path such as 'sources/c/' is used or when -S/--sources is supplied then the path would be 'XXX/c/' when using "-S xxx/" as an example.
When this is 'no', then the sources path specified by a new setting 'path_sources' is used but when -S/--sources is supplied then the path would be 'XXX/' when using "-S xxx/" as an example.

The result of this change moves the "sources/" directory from required to optional.
This directory is no longer checked for during the check required directories process.

The bootstrap.sh script is exclusively intended to be used for compiling the featureless linux library.
Therefore, the 'path_standard' and 'path_sources' are unimplemented within that script (beyond being defined in the variable list).

Bugfix: featureless make should not attempt to link to non-existent library.

When the no library sources are specified then the library is not built.
The problem is that the code is still trying to link against this library that was not built when compiling the static program.

Update: featureless make should not autp-prepend "-D".

Having this does simplify the configuration.
The downside is that it limits the flexibility and requires compiler-specific code to be added and potentially added.

Removing the auto-prepend "-D" will reduce the amount of language or compiler specific code in featureless make.
If another C compiler exists but uses something other than "-D" for defines, then only the settings file need be updated.

Bugfix: fake settings parameter is ignored.

The default value is always being used.
Change the behavior to use the loaded settings that was processed based off of the parameter -s/--settings instead.

Update: Add some example build settings for featureless make for bzip2.

The bzip2 project has a relatively simple and small makefile and does not get updated often.
This makes bzip2 an ideal example of how to build a build settings file.

There are a few shortcomings that I believe I need to address after creating these in the fake project.
These have been documented in the example settings until I can get around to change them.

I would also like to create fakefile examples for bzip2 as well.

Progress: featureless make.

Finish writing if conditions for number operations like >, <=, etc...

There still needs to be work where numbers such as 1.2 or arbitrarily large numbers are supported.
This only provides support for integers, positive or negative, that have a max value of uint64_t, which is generally ~2^64.

Progress: featureless make.

Continue work on implementing the section operation "if" conditions.

Update: add/update functions and refactor f_file_mode to f_file_mode_t and related.

Add functions f_environment_exists(), f_file_group_read(), and f_file_owner_read().

Update function f_file_mode_to_mode(), implementing it.

Refactor f_file_mode to f_file_mode_t and related.
This appears to have been missed in a previous refactor.

Refactor: Append '_t' to all types and related macros.

After using uint8_t and similar, I have decided to adopt the '_t' notation for types.
This helps further reduce the possibility of naming conflicts.
With this change a function, for example, for file mode could be 'f_file_mode' whereas a type for file mode would be 'f_file_mode_t'.

This further allows me to change the design of the *int*_t types used as an array.
Such as renaming 'f_uint8_tss' to 'f_uint8ss_t'.

Progress: featureless make.

Continue work on the if operation section if conditions.
Looks like I needed some functionality in f_file, currently incomplete.

Progress: featureless make.

Begin working on "if" operation logic.

Make sure the return states are handled by adding a "success" boolean.

Uncomment the code where I was confused by the logic.
What seems to have caused the confusion was that the "if" condition should have been an "else if" condition.
With this change, the logic makes more sense because it is no longer checking against a modified status variable.

Update: add file type name strings and lengths.

Cleanup: fix order of parameters and shorten "seek_to_this".

Update the parameters to follow the practice of constants on the left and pointers on the right.
Shorten "seek_to_this" to "seek_to".

Cleanup: add comments to file.h.

Progress: featureless make.

Implement section operation "operate".
Assure that recursion to an operation already on the operation stack is prevented.

Feature: provide common string related memory increment functions.

There are a lot of string functions.
In this case, it seems worth more to use functions instead of relying on macros, given how common this is.

This does not update most of the existing code that may want to use this.
Future consideration will likely be made in regards to the array of array string types.

There is no intention to expand this process to other types.

Progress: featureless make.

I forgot to finish converting the fake_print_error() and fake_print_error_file() functions to fake_print_message() and fake_print_message_file() for the private-fake.c code.
Fix the messages with fake_print_message_section_operation_path_stack_max().

Update: header includes should be local.

I noticed that I have been, perhaps habitually, using the system include path logic for including headers in the local source.
This is dangerous.
Avoid the possibility of including headers from the system when the headers provided by the project itself should be used.

Progress: featureless make.

Begin adding support for more complicated section operations.
Add break/exit to allow for manually exiting or breaking.

The error/warning systems needed to be rewritten to handle additional situations where "fail" mode is set to "warn" or "ignore" instead of "exit".
Errors may need to be warnings or not printed at all.

I noticed that I have been, perhaps habitually, using the system include path logic for including headers in the local source.
This is dangerous.
Avoid the possibility of including headers from the system that are actually headers provided by the project itself.

Other minor fixes and cleanups.

Progress: featureless make.

Process environment variable names, enabling support for the "define" section operation.
The function isascii() is incorrectly used when isalpha() should be used for identifying a valid first character for an environment variable name.
When calling execution section operations like "run" and "shell" make sure environment variables are passed to the environment.

Fix mistake where "group" is used when "groups" and similar mistakes with other words.

Add more output when in verbose mode on completion of certain operations.
For now, just avoid color output in these cases.

Fix minor mistakes in status variable when calling error handlers.

Actually set the fail type when the fail section operation is specified.
Fix the relating error message when the fail type is invalid.

Bugfix: file change role invalid parameter on < -1.

Having tests for "< -1" resulted in false positives for invalid parameters.

It appears that the uid_t and gid_t types are unsigned.
The value -1 is simply a special case use.

Update: don't tread buffer.used = 0 as error for print functions.

Instead, return F_data_not without error bit to default as not an error while still allowing the caller to consider the situation.