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.

Progress: featureless make.

Remove the 'create' section operation, it is effectively redundant with the 'touch' section operation.
There is still potential for having both because 'touch' section operation has additional actions that could be undesired.
For keeping it simple, I have decided to not support both 'create' and 'touch' at the same time.

Implement 'delete' section operatin and update validation.
Implement 'link' section operation and update validation.

Add 'deletes' section operation that performs a "recursive" delete which allows for deleting non-empty directories.

Bugfix: directory remove is not handling all errors.

The errno ENOTEMPTY is not being handled and is now added.
The errno EOVERFLOW is not used and is now removed.

Update the relevant documentation.

Progress: featureless make.

Implement the compiler and linker section operations.

Rename and move the fake_build_execute() to fake_execute() to be shared among both the build and the make operations.

Progress: implement modes operation with todo for recursion and fix documentation

Recursion will be written at a later date.
Just copy over the mode operation code just like it is done with owners (vs owner) and groups (vs group).

Fix a copy & paste mistake where I forgot to change the wording in the mode documentation.

Progress: get the change file mode functions in an acceptable state.

Finish writing the file change mode and related functions.
Due to significant gaps in development and the notable complexity of the ugo+rwxXst modes, this is implemented in what appears to be good enough for now.
There are likely hidden logic flaws or incomplete/missing logic.

This adds an @fixme to more thoroughly review this and possible fix this at a later date.
For now, this allows moving forward to avoid spending too much time on this one area.

Progress: continue work on mode changes

The functions were renamed and re-organized to be more consistent with the project practices.

This changeset focused on getting the number-only changes done within the time allowed.
This adds a new function for converting the f_file_mode into a mode_t for the libc chmod compatibility.

Progress: featureless make and related

It turns out I need custom functions for processing the mode like the chmod program works.
During the process of writing this I discovered several different ways chmod accepts arguments that I wasn't aware.
As a result I changed my logic repeatedly and this code is in a very much incomplete state.

This is being committed primarily to avoid losing any data (more so than usual).
There will be a lot of clean up when I get back to completing this.

Update: rename f_file_change_owner() to f_file_change_role().

Change owner implies changing the owner.
This is not strictly true, due to how the chown() and similar POSIX functions works.

Instead, these change owner and/or group.
To avoid confusion with thinking this function exclusively changes owner, use a completely different word.
The chosen word is "role".

Update: print the canonical path, if available, but fallback to the provided path if not.

The line number is printed on error, so a person can always look at the source settings to determine what the provided path is.
Providing the generated canonical path makes it clear what the generated path is.

Bugfix: logic errors in fll_path_canonical().

Make sure not to include the '/' when incrementing the size_chunk.
The code starts with '/', so be sure to designate the previous_1 as '/' at the start.

Cleanup: uppercase the first letter in the messages.

Progress: finish implementing UTF-8 *_is_digit().

Cleanup: refresh dependencies.

Update: provide fll_path and fl_environment while providing an alternative to f_path_real.

The realpath() function does not work on non-existent paths.
Provide an alternative, fll_path_canonical(), that works on paths without concern for some paths existence.

The f_environment_path* functions need f_path, so move them to a new fl_environment project.

Cleanup: relocate f_path_explode_* functions to f_environment project.

These path explode functions are in regards to the environment variable PATH.
Having these functions exist in f_environment makes more sense.

Progress: featureless make.

Initial implementation of touch operation.

Feature: add f_directory_touch() and f_directory_touch_at().

This is the same as f_file_touch() and f_file_touch_at(), except that a directory is created if the file does not exist.

Cleanup: fix typo in name.

Progress: UTF-8.

Add functions: *_is_ascii(), *_is_private(), *_is_unassigned().

Rewrite *_is_valid() functions to use the valid UTF-8 ranges.
Have *_is_valid() also check that the ASCII is valid.

Be more consistent with the use of uint8_t over short.
Use const where possible for width.

Progress: wrap up emoji UTF-8.

Cleanup: featureless make skeleton fakefile tweaks.

Add iki-0002 to the header and add "fail exit" is global.

Progress: featureless make.

The return code 0 should not trigger an error (I forgot to explicitly return from the function).

Implement the environment variable handling.
Now that it is implemented, do not manage the custom environment variables via the "define" mapping.
Instead, let the environment variables be the data storage.
This now updates the environment variables and reads from the environment variables as requested.

The parameter values are supposed to load from the build settings if not defined.
When the build settings are loaded, then allow loading from the build settings.

Bugfix: IKI read is not identifying cases with leading characters.

An IKI read string that begins with text that is potentially valid, followed by non-IKI name characters, and finally followed by a valid IKI variable name is not detected.

Example:
  Should=define:"value".

The above didn't resolve, but with this fix should now find the full IKI variable: 'define:"value"'.

Update: add missing documentation for fake fakefile fail setting.

Bugfix: invalid read after buffer.

If arguments.used was not incremented, then the arguments.used represents the correct position.
If it was incremented, then append that value.

The following string triggered the behavior:
  print Return Code is \"parameter:"return""

Progress: featureless make.

Finish implementing the return code processing.

Allow the return failure strategy to be tweaked via the setting 'fail' which can have one of the following:
- exit: exit program on failure.
- warn: do not exit and if in verbose mode, print warning.
- ignore: do nothing.

The reserved parameter variable "return" is populated with the return result value.
For example, you can see the return result by adding the following after a run, shell, or similar operation:
  print Return Code is parameter:"return"

Add some additional warnings when loading settings.

Feature: add f_conversion_number_signed_to_string() and f_conversion_number_unsigned_to_string()

These functions handle converting a number to a string representation of that number.
The base units 2 through 16 are supported.

Progress: featureless make.

Implement the "run" and "shell" operations.

Remove unwanted printed newlines.

Security: memory leaks in execute functions.

Use f_array_length, not f_string_length, for traversing an array.

The variable "i" is being used when it should be "j".

Add numerous missing deallocation calls.

Deallocate immediately instead of after a waitpid().

Avoid redeclaring the "i" variable.

Progress: featureless make.

Wrap up the path change operations.

Cleanup additional print functions that are no longer needed.