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

Feature: add "other" parameter support in program print

Printing support for short and long options exist but I never created one for other option.

Update: implement private f_utf functions, add missing function, and impove is_graph

The public functions should exist in isolation of each other, so the private functions are necessary.

f_utf_is_valid() is missing.

The is_graph functions should handle zero-width as well.

Feature: enable support default, protected, and hidden GCC visibility macros

Update: redesign byte_dump --last to be inclusive

The --last parameter should be inclusive for consistency with the rest of the project, namely FSS.

By redesigning the --last to internally be represented as a relative offset, the behavior can be simplified.
Doing this also adds support for potential future designs where a --length parameter may be provided that is a relative size parameter instead of an absolute one like --last.

Bugfix: --last does not count correctly when 2-byte or more characters exist

The last parameter does not take into consideration UTF-8 widths.
Redesign counting to accommodate the 2-byte, 3-byte, and 4-byte character widths.

Cleanup: refactor max_width to width_max

Use the newer naming practices.
These kinds of changes will be performed as I notice them.

Bugfix: conversion of char to utf character is not working

This is the result of a simple typo, the 'to' should be a 'from' in the f_macro_utf_character_*_char_* calls.

Add additional safety masks to the f_macro_utf_character_*_char_* macros.

Update: add initial handling of zero-width space in FSS projects

UTF-8 zero-width characters have the potential for being combining characters.
In such cases, the combiner/joiner should be considered part of what is being combined.
That is a combiner/joiner before a graph should be treated as a graph.
A combiner/joiner before a whitespace should be treated as a whitespace.

Disclaimer: I suspect that this will eventually need to be broken down to handle each specific case.
A combiner/joiner on whitespace that results in rendering a printable/visible character would be a violation of the whitespace design principles of FSS.
Further investigation is needed and will likely require changes.

Add appropriate @todo for further development of this functionality.

Rename max_width to width_max to follow newer practices.

Feature: add f_string_length_size max of (uint64_t - 4)

The goal here is that any string processing must be able to add a given UTF-8 width (4-byte) and not oveflow.
Much of the code in this project will not check this as it should be done so at a higher level (performance reasons).
The ideal time is that when allocating some string, always allocate at max f_string_length_size.

Update: rename whitespace functions to space functions and consider zero-width

Whitespace is now being used more explicitly in regards to UTF-8.

Zero-width consideratons added, but I think more work is needed in this regard.

Update: add missing zero-width UTF-8 functions

Also update documentation comments.

Update: Make classic mode more like hexdump

The hexdump program prints periods more than what is currently done.
Change this behavior to increase the use of non-colored periods.

The -p/--placeholder parameter is still used, so the combination of --classic and -p will have closer results to hexdump.

Update: byte_dump should utilize color2 functions and handle zero-width characters

Update: further clarify fss specification rules in regards to leading/trailing whitespace in object names

Feature: add color print2 functions

It is very common to have colors that are bolded.
Adding a new function to handle to color codes so that bold can be used makes sense to me.

I do not like using numbers in function names, but in this exceptional case, it makes sense.

Cleanup: remove extra newline

Bugfix: fix UTF-8 whitespace detection and provide zero-width detection function

The whitespace detection codes for UTF-8 were incorrect.

Non-printing characters, called zero-width, are not whitespace.
Move them out of the whitespace detection and provide a new function for detecting zero-width.

Handle additional UTF-8 whitespace character codes that I had previously missed.

Feature: implement support for the -T/--trim parameter

Provide support for trimming the object names on input and output.

After implementing this I suddenly remember that the standard might require that the whitespace before and after a valid object name are to be ignored.
This may be removed in the future and fixed in the library.
Additional investigation on how I want to handle this needs to happen first.

The standard is originally designed around ASCII, which only ASCII whitespace is considered whitespace.
This will probably have to be fixed to match the additional goals of the project in terms of whitespace handling.

Update: add simple documentation about private functions

Bugfix: correctly calculate end-- with UTF-8 and use correct function name

When walking back from the end of the string and handling possible UTF-8 characters, the byte width needs to be properly handled.

The functions in these projects are fl_ and not f_.

Includes minor code cleanup.

Feature: expand string functions and utf-8 string functions

The need for this was realized while developing this trim parameter feature.
This has been added as is for commit isolation and may be incomplete.

This utilizes private functions to reduce duplicate code.
While the use of private functions is generally unwanted in this project, this specific case seems to be an exception.

Add rip functions.
Add non-dynamic equivalent of some string functions.
Add trim functions.

Update: the print functions should increment by utf-8 char width and not 1

The UTF-8 character may be of a width greater than 1.
The loop must increment by this width and not the literal 1.

Cleanup: ensure macro_ is pefixed in string macros

Update: experimentally switch to uint8_t to UTF-8 character processing

Update: memory simple delete and simple destroy loop tweaks

Move the conditional outside of the loop for theoretical performance improvements.

Feature: allow trimmed output

New functions added for trimming leading and trailing whitespace from some string.

Security: fix memory leaks in FSS read programs

Cleanup: minor changes in f_print

Cleanup: FLL errors is now FLL status

Cleanup: add missing parameter documentation for f_print_string()

Progress: continue development of FSS Extended List

In particular:
- Remove excessive fl_fss_increment_buffer() uses.
  - The removed code may be a good idea long term, but for now use a simpler and more efficient approach.
- Fix some mistakes in the slash delimiter handling.
- Begin the initial work for recursively (or so..) processing the nested lists.

Update: add f_unterminated* status codes and fix f_unterminated_nest status codes

Add basic f_unterminated status codes just like f_unterminated_group status codes.
Fix missing status code conversions for f_unterminated_nest.

Cleanup: enable debugging by default for level and monolithic builds, just like with individual builds

Progress: continue working on fss_extended_list

Cleanup: add period at end of sentences

Update: build level and monolithic fixes and improvements

Add missing library: fll_file.

Make it even easier to compile against "level" and "monolithic" build processes by providing "--level" and "--monolithic" parameters to the generate.sh script and associated settings files.

Make sure package.sh clears other build modes (when --level is specified, make sur --individual and --monolithic modes are not set).

Update: implement *_delete_simple() and *_destroy_simple() macros and related changes

I do not want a *_delete() and *_destroy() that doesn't provide the ability to handle a status code.
However, in practice, the *_delete() and *_destroy() macros rarely needed the status response checked.
Additional f_status variables were created only to be provided for the status parameter of the stated macros.
This is a waste.

This provides and utilizes alternative *_delete() and *_destroy() macros called *_delete_simple() and *_destroy_simple().
These simple macros do not accept or process the status code.
The resulting code is simpler and easier.

I am on the fence whether or not to throw away the *_delete() and *_destroy() macros that utilize a status parameter.
Future versions may or may not replace the *_delete() and *_destroy() with the *_delete_simple() and *_destroy_simple() macros.

Update *_delete() and *_destroy() macros as needed.

Cleanup: fix spelling of occurred.

Feature: add new project fll_file

This project contains the function fll_file_error_print()  for handling common error output.

Refactor: make status codes more consistent

Better follow the naming paradigm where reasonably possible.
Use more consistent naming, which should also help with reducing the changes of enum to function name conflicts.
Alphabetically organize status codes per group.

Update: rewrite status code functions and related changes

Fix several problems with the status code processing, namely missing or incomplete data.
Add status code max size defines.
Add missing "#ifndef _di_f_status_codes_" to status codes.
Update cases where 'error' was not renamed to 'code' in status code sources.
Add missing status codes.
Fix incorrect define, "#ifdef _di_fl_status_invalid_" should instead be "#ifndef _di_fl_status_invalid_".
Fix incorrect sizes associated with status code output strings.
Prepare pipe support (not yet implemented).

Ensure f_utf is included and linked in all appriopriate dependencies.
Treat f_utf as a core level_0 project and update documentation accodingly.

Relocate fl_console_parameter_process() into f_console_parameter_process().

Cleanup: comments in f_utf

Feature: enable custom filter and sort in fl_directory_list()

Update: Document fl_directory_list() and finish implementing it

The said function is documented as incomplete and has now been completed.

Feature: implement pipe support in byte_dump

Bugfix: incorrect operators used in comparison

Should be using '&&' and not '||' when making sure the character is in the expected range.

Bugfix: When --last is set to 0, entire file is dumped

The --last value being set to 0 is internally used to represent entire file.
Explicitly setting --last to 0 makes no sense, so set the minimum allowed size for --last to 1.

Bugfix: only present error when --first and --last are both provided and --last is less than --first

If --first is specified by itself, --last is implicitly defined as the EOF.

Update: byte_dump should take into consideration the offsets when processing --first

This includes moving some of the variables into structures to simplify the design.

Update: use fl_console_parameter_to_number_unsigned() instead of atoll()

This includes minor source code changes.

Update: only print newline when --empty is used and --select is 0

In all other cases with --empty and --select, such as --select 1, if that selection is empty do not print any newlines.

Remove some impossible conditions.

Update: --name and --at in combination should process '--at' relative to '--name'

This logic is already done with --line and other parameters.
Doing this same thing with --name and --at makes the code/logic more consistent and reasonable.

Cleanup: display correct standard in help for fss_basic_list_read and fss_extended_read

Update: status code tweaks, including setting fl_fss_status_code_first as different from f_status_code_last

Cleanup: minor tweaks to comments

Update: finish implementing fss_basic_list_read

Update: finish implementing fss_extended_read

Update: print newline for empty content even when --at and --line, so long as --empty is specified