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.

Update: Add 3 presentation modes to byte_dump: normal, simple, and classic

Normal presentation will replace ASCII control or whitespace character with the UTF-8 characters that represent this with a picture character.
Simple presentation will use a single space to represent any given ASCII control or whitespace character.
Classic presentation will do what the "hexdump" tool traditionally does and use a single period to represent an ASCII control or whitespace character.

Update: add missing help options and fix miscellaneous minor issues

Bugfix: put '} // extern C' into correct location

Update: remove common type wrappers and use typedef instead of '#define'

I intend to begin transitioning from the core types like 'int', 'char', etc...
As part of this, I need to remove a number of the type #define wrappers.
This is also done, in part, because I learned that there are some equivalents to f_min_s_int.

Using explicit types is safer and better designed than something like 'char'.
The goal will be to replace 'char' with uint8_t (or int8_t as needed).

Furthermore, specifying int32_t and int64_t (and similar) should improve the code quality.
The use of types like "wchar", is dangerous because some systems use different sizes.
Instead, for something like "wchar", an uint32_t, might be used.
(although this project is to be designed around UTF-8 so the use of wchar is wrong anyway but it does make good example.)

Update: add a space after "combining" characters and catch a few more invalid UTF-8 sequences

Previously, I just printed a space instead of printing the "combining" characters.
It occurred to me that I could print a space following a known "combining" character to cause it to combine into a space.
This makes things easier to view and still displays the combining character instead of hiding it behind a blank space.
The downside is that this might cause problems if someone tried to copy and paste these combined characters.

Catch a few more invalid UTF-8 sequences that I came across while making these changes.
Fix an existing invalid UTF-8 sequence detection that seems to have been incomplete and incorrect.

Bugfix: last short parameter argument is not being processed correctly

For short parameters, only compare against a single character, not two.

Update: use unsigned long for argc

Update: Simplifiy digit/decimal and hexidecimal functions

Use simpler logic for determining if character is a decimal or a hexidecimal.
Rename digit to decimal.

Cleanup: move private functions into separate files

Refactor: ename bit_dump to byte_dump

This program is operating on a per byte basis.
The name 'byte_dump' makes more sense than 'bit_dump'.

Feature: implement --decimal display in bit_dump

Cleanup: Utilize f_console_parameter_ids to simplify parameters for fll_program_process_parameters()

Althought not ideal, the ids must be in an explicit order of no_color, light, and dark.
This has been added to the functional documentation.

Cleanup: provide helper structure f_console_parameters

This is provided to help shorten the number of parameters passed to functions.

Cleanup: make main() programs design more consistent across level 3 projects

Cleanup: replace argc and argv usage with a single structure of argc and argv (f_console_arguments)

Simplify the parameters being passed to functions by providing a helper structure called f_console_arguments to handle the argc and argv standard arguments.
Due to being standard arguments, I am leaving the names as 'argc' and 'argv' despite it being a violation of the naming policy of this project.
('argc' should be something like 'used', and 'argv' should be 'arguments'.)

The firewall had a naming conflict, so rename the usage of "arguments" in firewall into "parameters".

Regression: display "+" and "++" and not "-" and "--" for special parameter options

When I wrote fll_program_print_help_option() I completely forgot to provide a way to set eithe "-" or "+" and "--" or "++".
This resulted in the "--help" display of the options to incorrectly print using "-" and "--".

Add additional function parameters to allow setting the symbols when calling fll_program_print_help_option().

Update: Simplify console priority checking by providing fl_console_parameter_prioritize() and fix name of fl_console functions

Simplify the code for determining which console parameter of some set of console parameters has priority.
Abstract this functionality into its own function so that other projects can leverage this.

The functions in fl_console should be prefixed with fl_console.

Feature: bit_dump level 3 program

Provide a program to help analyze files, supporting UTF-8.

This should work similar to "hexdump" but is not intended to match it feature for feature.

Provides three byte printing modes (with plans for a fourth):
1) hexidecimal (default)
2) octal
3) binary
4) digit (planned)

Provides first and last byte selection support.

A width option is available for specifying the number of bytes to be printed on screen such that each byte is essentially a data column.
With a width of 16, then there would be 16 data columns, each displaying one byte.

Although similar to "hexdump", the first column in bit_dump represents the specific row number.

A text option is provided to display the bytes as a character (similar to how "hexdump" uses "-C").

A placeholder option is available for showing a placeholder where placeholder spaces would otherwise be printed.
A placeholder is printed to ensure alignment.
For example, a printable UTF-8 character that is 3-bytes wide would only visibly take up 1 character of space.
To keep the alignment with text to bytes accurate and consistent, two additional placeholder spaces are appended following the UTF-8 characte.

If the bytes terminate before an entire column set of bytes are printed, then spaces or placeholders are printed until the full column may be printed when in "text" mode.

This will detect and report invalid UTF-8 codes.

Handling printing the characters (via the text option) can be tricky.
There is more work needed to catch all cases.
Some cases cannot be handled if the character is wider than the expected width (causing alignment printing issues).

I am still a bit inexperienced with the intricacies of UTF-8 and I expect there to be issues in this first pass.

Update: restructure f_file, add f_file_exists(), add f_file_exists_at(), and other f_file related changes

Use "address" instead of "file" in f_file to help make things less confusing.
Shorten use of "file_information" with "file".

Implement f_file_exists().
Implement f_file_exists_at().

Try to avoid returning f_invalid_parameter to represent invalid parameters for standard C/POSIX functions.
Implement new exceptions, like f_invalid_name and f_invalid_desciptor, to accommodate this.

Use f_string_eol instead of "\n".

Update: console code and some macros

Add explicit dark mode console option.
Add support for order of operations priority on parameters  ("+n +l +d" would result in colors for dark background because +d overrides both +n and +l due to being the right-most parameter).
Rewrite level_3 programs to utilize the new fll_program_process_parameters() helper function.
Fix some screwed up macro definitions and uses.

Update: rename fl_program as fll_program, rename f_colors and fl_colors, move functions from fll_colors into fl_colors, and provide addition fll_programs functions

Cleanup the parameter processing code.
In the process:
- The fl_program was moved into fll_program.
- fll_colors_load_context() is at too high of a level, move it to fl_colors_load_context() (and deleting the now empty fll_colors project).
- Update programs to use the update fll_program helpers.
- The f_colors and fl_colors should now be f_color and fl_color.

Regenerate the package dependencies.

Bugfix: reduce total parameters for status_code and fss_status_code

When the "context" parameter was removed, I forgot to reduce the total parameter count.