Cleanup: make f_string_eol and f_string_placeholder a string instead of a char

In the back of my mind I keep reading f_string_eol as a string.
It is not.
Instead, it is a character.

To prevent this potential confusion, just make it a string and require the use of f_string_eol[0].
Make the same kind of change to f_string_placeholder as well.

Progress: featureless make

Move the print functions to their own private files (private-print.c and private-print.h).

Have the build operation create the build directory skeleton.
Have the build operation copy the settings files over, if specified in the build settings.

Update the code to be in sync with recent FLL changes.

Update: pipe and fifo, replace f_directory_mode with f_mode, f_file_copy()

Stick to only using fifo terminology in file types.

Replace f_directory_mode with f_mode, a global type to be shared between f_file, f_directory, and anything else.

Update f_file_copy() to use f_mode instead of mode_t.
This allows the caller to just send the mode.
The copy function already stats the file and processes it per file type, so it can make the decision on which mode to use.
This alleviates the need for the caller to also perform a file type stat check.

Update: todo documentation, directory copy and clone functions, update comment documentation

Update the todo.txt documentation.

There needs to be directory copy and clone functions for copy the contents of a source directory and not the directory itself.
To that end, add new *_contents() copy functions.

The comment documentation for clone was never updated and is incorrect.

Progress: add more directory and file related functions, other changes

This was started with the intention of providing all of the *_at() functions.
However, the POSIX spec seems to fall short in many areas making this more difficult than this should be.
I partially rolled back some of the planned changes and this changeset is the result.

I have observed that the function return documentation needs to be updated, but this will be done at a later time.
There will need to be some intensive testing later on but for now I am committing and moving forward.

Progress: featureless make

Get umask at start (done at start to limit the non-atomic nature of the poorly defined POSIX umask()).

Begin setting up for directory copy operations.

f_file_create() no longer accepts de-reference parameter.

Update: file and directory improvements, finish writing directory copy

Organize directory header structure, adding directory_type.h.
Add additional directory structures.
Directory copy needs to report what fails, so provide a structure for reporting each failure.
(There needs to be a verbose function for printing success/failure.)

Remove de-reference from numerous file functions.
POSIX denies certain operations of symlinks.
During copy operations, do not apply mode to symlink as it would now apply mode changes to the de-referenced link.
Allow block size to use default block size if set to 0 (convenience).
Add missing return statement to file copy (without it socket file types would incorrectly report F_unsupported).
Add link read functions so that symlink information may be obtained so that it can then be copied.
Add comments about poorly written umask() as per POSIX standard (at least according to manpages).

Other minor fixes and cleanups.

Feature: add push and pop directory functions

These functions should help make appending interactive or user-data for directory path building easier.

Cleanup: remove unused header

Update: minor improvements, finish f_file_copy(), add fifo file type

Finish implementing the f_file_copy(), adding support for all file types (except unknown).

The documentation for block, character, and FIFO is unclear to me at this time and my attempts to copy using mknod(2) is an educated guess.
Attempt to prevent file type from being passed via the mode_t when doing a copy (currently untested).

Add the appropriate file create functions to implement the copy operations.
Have the copy file copy only the directory itself and not the contents (to copy contents, the fl_directory_copy() function should be used).

The added fifo type is pretty much the same as pipe.
Mixing fifo with pipe terminology ended up being confusing so I opted to create redundant FIFO types to simplify the readability.

Use the word "regular" for a regular file instead of "file".
Using "regular" is a less confusing than using "file" (i.e. Regular File Type vs File File Type).

Cleanup: Replace F_file_open_not with F_file_closed, add additional status codes for consistencies

Socket was not fully converted into basic status codes (not having connect).
I can see future work in sockets whee I may actually add connect codes back, but I won't know until I spend dedicate time on it.

Add additional status codes that should probably exist for consistency purposes.

With F_file_open_not removed, split behavior into two checks:
- F_file for file descriptor errors.
- F_file_closed for file not open errors.

Cleanup: update all status codes in line with recent refactor and fix issues

This primarily puts all of the status code handling in alphabetic order.
The length sizes are updated accordingly.
Be consistent with S at the end of things, whereas S is not the traditional grammatical use but instead implies a set of.
Use the base F_* disable defines instead of using new ones for each level when they are specific to the F_* status codes.
Add additional comment documentation.

Any issues observed resulting from the refactor were also fixed during this change.

Refactor: use capital F, FL, and FLL for status codes to avoid potential conflicts

By only using the first part, the annoyance of all uppercase can be avoided.
This then allows shortening the names and removing words like "_error".
Also restructure where the "_not" are placed (placing them immediately after what they apply to).

This will be followed up by a restructuring commit.

Update: get the level_3 / programs working after major file / directory changes

This required making some fixes in the files related code.
This puts the UTF-8 file (utf_file) project notably behind an additional work is necessary to get that working correctly as well as having it be consistent with f_file.

I've decided that when written pointer is 0, then the caller is requesting to not get back the written size.
I am very likely going to do similar behavior with null pointers in other uses, which will help further simplify the design.

Other minor changes.
Of particular note is moving flags into the f_file structure.
This was effectively how the pre-file redesign worked, but it uses flags now instead of the "r", "rw", "a", etc.. string modes used by fopen.
Make sure an append flag is available.

Progress: continue redesign of file and directoy structure

This gets the code in a state where I can focus on updating all of the programs (level_3 files).
The UTF-8 related types have @todo and @fixme as I intend to come back later and finish them.

Progress: major redesigns with file and directory handling, this changeset is incomplete

In the process of writing the directory copy, I realized I needed to improve the file and directory management.
This triggered me to rethink how I was handling files and directories to some extend.

If memory serves me correctly, the POSIX 2008 was either too new or non-existent when I first wrote some of this.
Updating to use the newer POSIX functionality and changes seems worth this major change.

Add additional file functionality.
Lots of re-organization and redesign.

I still haven't finished this and would rather commit now, with incomplete code randomly throughout, than risk losing any changes.
In particular, the fl_utf_file is where I need to resume.
I need to then update all of the level 3 programs to use the new file/directory handling code.
After that I need to finish writing the directory copy, which should include investigating and implementing file copy operations for more than regular files and symbolic links.
I also need to remember to investigate copying hard links as a hard link instead of as a duplicate file.

Update: add additional file functions, fix bug with file stat in f_directory

Add additional f_file functions, move commonly shared code into private f_file files.

The f_directory functions were incorrectly using sizeof().

Progress: featureless make

Add and validate modes from the build settings files.
This provides some data integrity support.
If a mode is not defined in the modes property of the build settings, then that mode is not valid and the build process is stopped.

Bugfix: incorrect return status resulted in mistaken status handling

Progress: featureless make

Snatch apart the settings strings instead of mashing them together.
Process the environment build setting to enable selecting additional environment variable to expose to the process scripts.

Cleanup: fix build issues relating to build settings

Get the individual builds back in working order in regards to build configuration.

Update: add path expode using normal order

Oops.

For reasons unknown to me, I seem to have written the path explode in reverse order.
The path is intended to be processed from left to right.

Rename the old functions appending _reverse to their name.

Progress: featureless make

Update: numerous changes, most notably path and vfork to fork changes

Replace vfork() calls with fork().
- I have determined that vfork() is not safe.
- When calling clearenv() inside a vfork() child process, the parent process' environment ends up getting cleared as well!
- The child can alter the parents memory according to manpages, so stop using vfork() entirely.

Add path processing functions and related defines.

Enable path processing to allow for execvpe()-like behavior can be implemented.
- The execvpe() function is not used because it is not POSIX.
- Manually process the PATH environment to determine what to execute, even when PATH enviornment gets cleared.

Some consistency improvements in defines, such as f_console_max_size to f_console_length_size.

Fix mistake in memcpy usage, dynamic strings use char * for their string so passing & is incorrect.

The f_file_exists() is using access().
- This is misleading and incorect.
- Use stat() to determine if file exists because it doesn't require access to the file (aside from directory access) to check existence.
- Add a new function f_file_access() as the old implementation of f_file_exists().

The fll_execute programs now support additional functions for clearing environment variables.
- This effectively sandboxes the environment variables before calling the program.

Progress: featureless make

In particular, defines file to skeleton build.

Cleanup: remove f_string_eos, use 0 instead

I originally created f_string_eos, so that it could be potentially changed.
In the case of basic strings, using 0 is simpler, more consistent, and safer.

Update: add environment functions, add static strings, and other changes

Add environment project and associated functions for managing environment variables.
Add execute functions for setting environment variables.
- More work is needed to search the PATH to perform fll_execute_program_environment when PATH is not to be defined.

Provide stub define build settings files for each project.

Miscellaneous minor fixes/tweaks.

Progress: Featureless Make

Implement skeleton operation.
Simplify parameters and enforce a more standard structure on 'build'.
The "make" operation with its "fakefile"s can be used for more flexible project structures (at least once it is written).

Update: additional file functions, relocate function locations, add path separator length define

Progress: Featureless Make

Update: add directory functions, file functions, and status codes

Update: add path.h headerr

Update: finish the @todo in errno handling of recent directory additions

Progress: further work in Featureless Make, implement cleanup operation

Update: new directory related functions, file function updates, status code updates, directory level restructuring

Numerous updates to get the directory functionality better hashed out.
Some of the directory functionality is experimentally added.

Progress: continue work on fake (Featureless Make)

Update: add boostrap.sh stub and add readme.txt document

Feature: add f_utf_string_static as a non-allocated alternative to f_utf_string_dynamic

The is the UTF-8 string equivalent of the f_string_static type.

Feature: Add string assure functions to assure a given string exists at the beginning or the end

This is particularly useful for assuring that a "/" exists and the end of generated path strings.

Revert "Refactor: f_print_string_dynamic to f_print_string_static"

This reverts commit f225f4059d0e082a7bfae29e042a2120ac4bda33.

It occurred to me that this would make the function names more inconsistent.
This could get very confusing so just stick with "dynamic" in all the names.
"dynamic" is the original term and "static" in isolation is a reserved word.

The type names will remain as both f_string_static and f_string_dynamic.
That inconsistency is desirable due to the explicit meaning communicated by their names.

Refactor: f_print_string_dynamic to f_print_string_static

Refactor: all constant dynamic strings can be safely changed to static string

This is just a mass regex change.
There may need to be function renaming and re-ordering at a later time.

Feature: add f_string_static as a non-allocated alternative to f_string_dynamic

That is not to say that a dynamically allocated buffer cannot be placed in its string part.
Instead, it communicates that this is not never be allocated or deallocated directly.

This is implemented in such a way that f_string_dynamic is a sub-type of f_string_static.
This should allow for easy type conversions.

Progress: pass coloor modes and verbosity to build pre-process and build post-process scripts

Update: improve color mode handling

Improve handling of color mode so that applications can consistently react to the established color code.
In the fake program, this is useful for passing the color mode to the build pre-process and build post-process scripts.

Update: explode parameter priotization into left & right, add quiet and verbose options, and minor code cleanup

The (right) parameter prioritization function should be expanded into a left-prioritization and a right-prioritaztion.

Make +q/++quiet and +V/++verbose standard options for verbose.

Add length defines for console standard defines.

Make sure the status return is handled.
There were a few cases where it was not being handled.

Minor code structure cleanups for structural issues I happened to observe.

Progress: continue work on fake

Update: add snatch apart functions and improve logic of fss snatch functions

The snatch apart is to create separate sets of strings instead of merging them.
The snatch mash apart will mash all dynamic strings for all content for a single object but use separate strings for each separate object.

I accidentally, or perhaps habitually, used break when return is better when handling errors.
Make sure to document f_string_max_size as a possible return result.

Revert: f_array_too_large already existed, its just called f_buffer_too_large

Refactor: f_string_location to f_string_range (and related)

I am now favoring the term "range" over "location".

Cleanup: reword location to range

The word 'range' seems more appropriate than 'location'.

Update: switch back to lengths from inclusive ranges

Using start and stop ranges ended up being cumbersome.
Using length is simpler and a start range can be used by just adding to the source string before calling.

Update: add missing error handling

Progress: continue fake development

Utilize the recently added functions for appending console parameters for execution.

Update: numerous fixes and additions, mostly string related

Not sure how I let this one get through, but add missing return statement in a couple of private string functions where it is missing.

In retrospect, it seems that I was overzealous with some of the parameter checks.
Redo the parameter checks to not be as sting on string length and buffer size ranges.
Instead, just return that there is nothing to do instead of erroring out.

Add string terminate functions.
These functions are designed to guarantee that an end of string exists at the end of some dynamic string.

Add functions for appending one or more arguments to the arguments array for the execute functions.
This functionality is common enough (used extensively by firewall and soon to be used by fake).
Support providing an array of arguments to append.
This greatly simplifies long-winded code.

Minor fixes and cleanups in the execute functions:
- Add missing parameter checks.
- Rename results to result to be more accurate.

Add length defines for console symbols.

Progress: begin re-implementing fake program (Featureless Make)

The goal here will be to mimic the current FSS build scripts fist.
Then update the FSS build scripts to the more generalized design.
Then implement the traditional fakefile process (a makefile alternative).

Currently has "skeleton" mode, which may or may not be implemented.
This was added as a stub just in case I decide to implement it.

Update: add together snatch functions, update comments

Feature: add fss snatch functions for "snatching" content for a set of object names

These are intended to be used for simple purposes.
Directly implementing these in individual projects are recommended for more advanced usage.
I intend to expand on these "snatch" functions in the near future.

Bugfix: start position not being calculated fo fl_string functions

I missed adding the start position.

Cleanup: remove useless macros for f_string_location and update comments

Cleanup: replace variable name 'input' with 'location', add location parameter check

Using the word 'location' makes more semantic sense than 'input', especially given that the variable type is called a location.

Update: add back the dynamic_partial functions, add missing functions

After further review I realized that the dynamic partial behavior is going to be more common.
The rip functions are also not the same because it removes leading/trailing whitespace, which may be undesirable.

Some of the append_nulless function implementations were missing.

Update comments.

Feature: add fl_utf_file project

This is intended to be an f_utf_character handling version of fl_file project.
This f_utf_character is a 4-byte wide storage for a single UTF-8 character.

I accidentally committed the utf_file build settings in a previous commit: f69e57a.

Update: Redesign f_file and fl_file functions, simplifying f_file_position

Redesign the logic behind the f_file and fl_file functions to favor the buffer->used append strategy.

Remove f_file_read_range(), something similar can be added later if need be.

Povide f_file_reat_until(), that functions similar to f_file_read_at(), except the file position is not automatically set.
Using f_file_reat_until() is more efficient in array loops because it does not check the file position every execution.

Add f_macro_file_seek_data() and f_macro_file_seek_hole() to support the newer seek modes: SEEK_DATA and SEEK_HOLE.

The f_file_position structure is simplified.
The file position should only be for file related code and having buffer in there is just plain wrong.
The structure is further simplified in its property names.

Remove unnecessary invalid parameter checks.

Add f_file_default_write_size define.

Update: make fl_file functions more consistent and update documentation

Refactor the fl_file functions.
Rewrite memory management in f_file and fl_file functions.

Fix bug with size of bytes, renaming it to byte_chunk to avoid confusion.
Add block size property to f_file structure to allow custom block size handling (as opposed to the previous behavior of using a hard-coded default).

Make sure f_none_on_eof is actually returned.

Update: ensure f_no_data is returned when applicable for fl_string and fl_utf functions

Update: simplify and rework string functions

The rip and append functions are functionally identical.
Remove the rip function.

With the rip functions gone, the rip_trim functions are renamed to rip.
This way "rip" functions operate like a theoretical append_trim function, but with fewer words.

Make the string functions use start and stop ranges instead of lengths.
This eliminates the needs for the partial functions.

Add new nulless functions that check for and remove nulls from source strings while transferring them to the destination string.
This allows for converting the strings that may have nulls to nulless strings such that they can be used in null-sensitive functions such as those found in the standard C libraries.

Make sure the utf_string functions match correspond to the string functions.

Update: set default allocation step to 4

This will better coincide with UTF-9 4-byte wide characters.

Update: at f_array_too_large status and don't include terminating NULL in string lengths

Just like f_string_too_large, there needs to be a generic f_array_too_large to report that the array is larger than can be supported.
Also provide an f_array_max_size #define just like f_string_max_size.

The #define string lengths shouldn't include the terminating NULL.
This will prevent having to remove the NULL when converting to/from null-agnostic to null-aware designs.

Feature: add word, dash, and plus UTF-8 character checker

The use of the '+' operator is more common than in the past.
Add support for detecting if a character is a word character, a dash character, or a plus character.

Update: Fix string length calculation and report when no changes for fll_program functions

Both fl_string_rip and fl_string_rip_trim use include ranges and not lengths.
Record the start length to identify if there were changes and return f_no_data when there are not changes.

Bugfix: is_word tests were using the wrong function and there is no ASCII zero-width space

Cleanup: fic typo in the word "skip"

Cleanup: call clear macros in _new macros

Cleanup: remove spurious name in typedef struct declaration

Update: use f_string_length instead of uint8_t for width_max in UTF-8 functions

Cleanup: restructure bash script cleanup process

Explicitly return 0 in main.

The cleanup function can be called within the functions being removed.
This is handy in that the cleanup no longer has to be called after the main function.
The error code can then be properly returned without being lost due to the cleanup function.
Once this is done, return can be used instead of exit (which is generally safer).

Cleanup: whitespace tweaks and use define for printing long symbol

Update: implement missing serialized functions and fix bugs

Implement fl_unserialize_simple() and fl_unserialize_simple_get().

The last character in the last string in the unserialized array gets cut off.
- This happened because the stopping point was incorrectly compensating for the splitter character for the last character in the string.

The width (UTF-8 character width) is not part of the locations size.

Feature: implement UTF-8 special character check types (partial-stubs)

Types are:
- alpha
- alpha-numeric
- numeric
- word (alpha-numeric and underscore '_')
- word-dash (alpha-numeric, underscore '_', and dash '-')

The ASCII portion of this implemented and should work.
The UTF-8/Unicode portion is completely unimplemented (aka: a stub).

Feature: add parameter rip functions for ripping console parameters into an array of strings

Cleanup: add missing parameter documentation and swap mash with trim in names

The additional parameter documentation is missing.

Be consistent with other functions in how the string '_trim' is appended to function names.

Bugfix: The address has to exist to use, all references with address of 0 are invalid parameters

Oops.

Feature: add functions for combining the additional console parameter together

Refactor: fll_program_process_parameters to fll_program_parameter_process

Pave the way for additional fll_program_parameter_* functions.

Update: add missing dependency to f_color

Cleanup: move comment into correct position

Feature: implement append and prepend string functions

Feature: implement string mash support

String mashing is a way to append a string to another with a glue string in between.
The idea is that a space could be placed between the two strings.
A string is primarily used as the mash character so that UTF-8 can be natively supported as the glue character.

Update: only resize if necessary when processing string

Avoid unnecessary work.

Update: short variable name, reorganize function, fix types

The use of parameter_counter ended up being very wordy with "parameters.parameter[parameter_counter]".
- Change this to 'i', since that is unused and traditional.

Reorganize the additional parameter processing loop.

Use uint8_t instead of "unsigned short" for more consistency.
The width_max should be f_number_unsigned and not "unsigned short".

Add additional documentation for console ids in regards to what "empty" means.

Feature: add fl_console_parameter_to_string_dynamic_directory to fl_console

Provide a console argument handler for parsing out a directory path and returning it in a dynamic string.

Cleanup: fix include ordering

Bugfix: f_file_not_found should be considered an error

Bugfix: remove null pointer check from file stat

Do not assume that stat was passed as an uninitialized pointer.
In the case of passing a class by reference, the stat pointer would be non-zero.
This pointer is not dynamically allocated and therefore not an error.
The null pointer check is therefore invalid for these cases.

Update: Ensure internal visibility is used in private functions and fix header inconsistency in status code

Cleanup: fix wording in help in regards to special options

Cleanup: ensure help sentences end in period and use "build" instead of "built"

Cleanup: the standard print help functions only need color context

Passing the entire program data structure is not necessary.
Just pass the color context, this simplifies the code.

Cleanup: use correct wording in invalid parameter message