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

Regression: the --at parameter should be processed even when --depth is not specified

The implementation of --depth resulted in --at to not be processed when the --depth parameter is not provided.

Update: ensure error output has appropriate highlighting

Cleanup: minor cleanups

Bugfix: f_overflow should be returned with error bit set

Bugfix: string to number conversions should handle leading 0's as a valid number

Feature: add support for including empty content in fss_basic_read

Empty content is an object that has no content.
When there is no content for an object, no content is printed for that line and that line is not included in content totals or line selections.

Update: finish implementing fss_basic_read

Progress: continue implementing fss_basic_read, also numerous other fixes/tweaks

I decided to allow --at and --name to be used at the same time (and therefore at the same --depth).
The depth code is to be rewritten and that is only partially rewritten.
Many of the parameters are now written and the fss_basic_read needs to be tested and reviewed.
(There fss_basic_read is still incomplete, but there is enough working code to begin testing.)

Bugfix: "true" is now a reserved type, so replace variable names of "true" with "is_true"

Cleanup: add space to --help for duodecimal parameter

Feature: add support for duodecimal (base-12)

Now that duodecimal has been added to the FLL project, make sure byte_dump can print in that format.
There is no printf() code for base-12, so implement a custom print process.

Fix some typoes in the "hexi" decimal spelling.

Update: implement f_number_signed and f_number_unsigned, as either 32-bit, 64-bit, or 128-bit

Provide the types f_number_signed and f_number_unsigned as a way to define the default "number" type to be used for string to number conversions and array indexes.
By providing 32-bit, 64-bit (default), and 128-bit types, the type can then be adjusted to more easily work on limited hardware or expand to more capable hardware.

This will be the recommended number data type to use in FLL functions going forward.

Progress: f_conversion and fl_console changes

This includes adding support for duodecimal (base 12)

Progress: rewriting fss_* programs and all dependencies

I am changing the parameters and design of the fss_* programs, such as fss_basic_read.
There is no work done on the fss_*_write programs yet.

There were a lot of changes in the dependencies, including cleanups and improvements.

The parameters passed to the fss_* functions will now be more consistent across each of them.
This should make scripting much easier.

There is a lot of incomplete work and I am focused currently on getting fss_basic_read to work as desired.
I halted my work on f_conversion and fl_console to make sure none of these changes are lost.

I do not expect this commit to compile with everything due to the incomplete work.
I would rather post incomplete code than risk losing code as has happened in the past.

Progress: do not include closing brace when determining stop point in extended list

Progress: use the content_nests equivalents in place of the contents

When I copied basic_list code to use a starting point for extended, I missed creating "nest" equivalents to some code.

Progress: continue working on fss-003 Extended List

A nested type has been created.
I suspect that I will need to change the structure of the other types to improve consistency, but more review and consideration is needed before any such changes are made.

A read program was written but it is essentially a copy and paste of Basic List, with a few minor changes just to make it compile.
The program arguments of all the FLL programs will need to be changed such that adding support for "depth" selection can be used for things lile Extended List.

The memory allocation is implemented but not reviewed.
I converted the behavior to support nesting, but I need to review the logic to ensure I caught everything.

No time was spent on the write support.

Progress: begin implementing fss-003 Extended List

Update: FSS function documentation, use "location" instead of "input", have f_incomplete_utf use error bit

Update: finish implementing f_utf_character_is_valid() and related UTF-8 changes

UTF-8 BOM is actually not a thing but only a suggestion, see RFC 3629.
I consider it a very bad practice now that I have learned that it is also the zero width space.
Get rid of the UTF-8 BOM support, it is a bad idea and is not to be supported by this project.

The referenced rfc also provides an easier way to view the valid ranges that my previous resources (such as wikipedia).
This helped me finish this function.

Updated byte_dump to better utilize this and to remove no longer necessary code.
Fix an accidental incorrect "invalid detection" check use before calling f_utf_character_is_valid() in byte_dump.
Explicitly print a "." or " " for UTF-8 control characters (ASCII control characters are already handled before this point so it is safe to call f_utf_character_is_control()).

Progress: use a smaller byte structure for comparison in UTF-8 *_is_valid() function

The full 4-byte wide character is still used in some circumstances.

Progress: finish the main parts of invalid UTF-8 detection

This wraps up the work needed for all explicitly declared invalid sequences.
There are some sequences, such as "Overlong", that are considered invalid (according to Wikipedia at this time) but the source (namely Wikipedia) does not explicitly declare what they are.
I need to figure out what these really are and handle them.
There are also likely cases of accidental copy and paste that will be fixed as I discover them (sorry, the size of documentation I had to go through to get these invalid sequences is massive to me).

There are also some @todo situations that I would like to resolve.

Progress: more towards completing UTF-8 valid/invalid check

Update: int8_t and uint8_t are always size 1, so avoid sizeof(int8_t) and sizeof(uint8_t) calculations

Update: disable init until I can get around to it

I decided to start at least clean up some of the compile errors, but this was simply too much of a mess.
Instead, just comment out code and deal with it later.

Progress: continue adding to UTF-8 valid/invalid detection

Progress: begin converting byte_dump to using f_utf_character_is_valid()

The function, f_utf_character_is_valid(), can be a bit expensive, so only call it if the current character is not already known to be invalid.

The function, byte_dump_print_text(), will need to be updated as well, given that the invalid range now includes some sequences currently being swapped with a space.

Cleanup: fix alignment of help text fo normal, simple, and classic parameters

Progress: continue UTF-8 work

Update: types where not fully converted into new structure

Update: begin improving UTF-8

I am now moving to perform a more thorough implementation of UTF-8 support.
Cleaned up the functions.

Due to the sheer size of the changes needed, I am uploading this is stages to ensure nothing gets lost.
The work done is incomplete.
The funtions will need to be reviewed once everything is in place.

Update: redesign size types

The FLL project is now being designed around explicit type usage.
Update the size type limitation #defines to be based on this.

Update: use int8_t instead of char

Guarantee that we are always dealing with 1-byte values by using int8_t instead of char.
They should be identical, but this prevents a given system from doing something different.
char by default is signed.

Update: document f_type, switch f_bool fom unsigned short to uint8_t

Cleanup: document f_status

Cleanup: document f_socket

Update: documentation for f_pipe and add additional pipe functions

Provide f_pipe_warning_exists(), f_pipe_error_exists(), and f_pipe_debug_exists().
In theory, the program should be able to grab data piped from any of these sources, if both the source exists and a way to pipe the source exists.

Cleanup: documentation for f_path

Cleanup: documentation for f_memory

Update: documentation and increase f_fss_max_header_length to accomodate UTF-8 BOM

Update: start enum's at 1 where possible

By always setting enums as 1, the 0 value can be reserved as not-set.
There are still a few situations where enums must not start at 1.
Some are:
1) Type defenitions, so as in f_types where the status codes need to start at 0 for f_false.
2) Any enums that map 1to1 to an array, such as with parameter options.

Update: document f_file functions and add missing functions

After reviewing and writing some documentation, it occurred to me that a few more functions should be written.

Update: f_convesion, add comments and fix problems

Add comments (including correcting some existing ones).

Rename another case where digit should now be decimal.

Make sure the *decimal parameter only gets updated on success.
Be consistent about returning f_no_data.