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.

Update: enable debug by default via "-g" CFLAG

This can always be removed manually or the binaries/libraries can be stipped later.

Feature: add 'dependency' generation to package.sh and update all dependencies

This will help ensure that dependencies will be accurate and less error prone (so long as the script is run after making changes to any projects).

Dependencies are processed from the projects individual data/build/dependencies file.
The order of the dependencies does matter and is processed from top to bottom.
The 4 core dependencies must be first if they are depended on (and in this order: f_type, f_status, f_memory, and f_string).

The dependency generation for individual projects will generate the libraries to link against if a given project has any library source files.
Linking is done in highest level to lowest level to help ensure no linking errors happen.

The dependency generation for level projects and monolithic project are done based on the library and header sources.
All files specified in the build_sources_library and build_sources_headers are generated.

This script has been run and the dependency updates generated by this script are included in this commit.

Cleanup: f_types dependency is now called f_type and dependency f_errors is now called f_status

Cleanup: make sure memory functions are prefixed with f_memory

Cleanup: rename f_types to f_type

Cleanup: rename f_paths to f_path

Cleanup: rename f_strings to f_string and fl_strings to fl_string

Update functions and macros accordingly.

Cleanup: rename allocation macros to have f_macro_ in their name

Update: implement utf strings, ensure endianess, and add isgraph()/isspace() methods to UTF-8 equivalents

Expand the UTF-8 character type (a 4-byte wide character represented as a big-endian 32-bit integer) into working like f_string and f_dynamic_string.
Provide all similar functionality.

I have decided that the isgraph(), isspace(), etc.. functions fo UTF-8 should also call the ASCII equivalents.
Update all relating code.

Use memcmp() and memcpy() for comparing UTF-8 characters class (4-byte integer) to the UTF-8 char strings (multiple 1-byte char).
When doing this, make sure to do so with the proper endianess.

Add missing f_utf_character_to_char() function.

Wrap some of the macros parameters in parenthesis for safety reasons.

Add f_utf_is_big_endian() and document its use.

Provide custom EOL, EOS, and placeholder defines for UTF characters (4-byte integers).

Update: improve status code handling, remove unnecessary code, and update status programs

The fl_status_is_fine(), fl_status_is_warning(), and fl_status_is_error() functions are no longer needed or valid with the current design around using error and warning bits.

The status conversion code should be more aware of digits.

Get rid of the "context" parameter in the status programs.
Redesign logic in the status programs to work with changes and function correctly (and consistently).
The status programs will eventually need to perform more extensive tests on parameters when digits or non-digits are required.
The current design only provides a very basic test on the first character of a given parameter.

Bugfix: do not include private headers

Manually including private headers from within public headers will result in compilation errors.
The private headers will still get included via the private source file.

Update: provide f_utf_is() and f_utf_is_character() functions

Update: handle invalid UTF-8 fragments

A 1-width UTF-8 character (that is not a valid ASCII character) is used to designate part of a complete UTF-8 character block (aka: 1-width UTF-8 characters are fragments).
Because this fragment cannot exist in isolation, it must be handled as either an invalid or an incomplete UTF-8 fragment.

Provide new status codes for handling incomplete UTF-8 fragments.
Update appropriate functions to detect and handle these invalid or incomplete fragments.

Update: redesign console processing code

Simplify the console structure and reduce the size of codes and parameters.

The "extra" parameter seems a bit overkill, remove it and help keep this project more along the lines of the idea of "Featureless".

Rewrite and document fl_process_parameters().

Implementing functions were only functionally updated.
Additional changes are likely necessary for the logic, such as supporting multiple calls like "program -h +n +l", which by order of operation the final "+l" should override the "+n".

Security: safely print f_dynamic_string

The f_dynamic_string is not NULL terminated and should never be directly passed to a function that assumes strings are NULL terminated.

Cleanup: f_color, fl_color, and related

In particular, some of the color print functions are not following the naming convention.
The function fl_print_color() should instead be fl_color_print().

Make sure appropriate #define statements have macro in their name.

Add some @fixme comments because f_dynamic_string is designed with the intentions of not being NULL terminated.
Directly using it with standard functions like fprint is dangerous.

Cleanup: rename f_errors to f_status, fl_errors to fl_status, and fll_errors to fll_status

Originally f_errors was meant only for error handling but it quickly turned into status code handling (which includes errors).
The naming system of f_errors is now confusing and misleading so change it to f_status.

This makes far more sense, for example:
- f_error_is_error vs f_status_is_error.
- f_error_set_error vs f_status_set_error

Cleanup: remove error test macros

This is legacy behavior that is no longer needed.
Update any existing uses of these deleted macros.

Cleanup: rename return_code to status_code and fss_return_code to fss_status_code

The "return codes" were originally intended to be literal return codes.
When the error codes were converted to have error bits, warning bits, and signal bits, this no longer became the case.
Refactor return_code into status_code to be more accurate.

Update: improve return code error conversion and support converting strings to numbers

Update: readme file and add additional notes on the FLL dependency structure

Cleanup: only use f_macro_ for defines that structurally mimic functions

Cleanup: define fl_directory_name_max as 255 to match PATH_NAME

Update: add UTF-8 support to fl_console

Also remove unnecessary looping.

Update: add more support for UTF-8 and improve effected functions

Use a 32-bit unsigned integer instead of a structure of 4 characters.

Add -lf_utf to dependencies on updated level projects.

Be more thorough when implementing simple fl_seek_* functions.
Support both processing char as well as f_utf_character in string processing.

Continue updating code documentation.

Update: add missing error code to string conversions

Update: implement UTF-8 support in fss processing code and add additional functionality

Additional functionality includes implementing f_utf_character in f_utf.

Includes numerous other small UTF-8 updates.

Some macros have been wrapped in parenthesis to avoid unobvious issues such as when adding an exclamation before a macro call (and the possible order of operation issues).

Update: use max_width instead of maxWidth, remove f_utf_bom check from f_is_space, and provide f_macro_utf_byte_width_is for UTF-8

Cleanup accidental use of maxWidth, when the proper syntax style is instead max_width.

After further review, I have decided to move the f_utf_bom check back outside of the f_is_space() function.

Provide f_macro_utf_byte_width_is() function for getting UTF-8 character widths but returning 0 if the character is ASCII.

Bugfix: f_socket and fl_socket, numerous problems

It looks like the f_socket and fl_socket were not completed or otherwise written incorrectly.
Change the behavior to at least compile.

Feature: implement monolithic build in the generate.sh and package.sh scripts

Update: add UTF-8 BOM detection

Add support for detecting UTF-8 BOM in the f_utf_is_space() function.
Add new function f_utf_is_bom().

Feature: add initial UTF-8 support via f_utf

This provides the most basic functionality for processing UTF-8 characters.

Additional modules will be updated to natively process strings as UTF-8.

Cleanup: add build_sources_settings setting to build settings files

Cleanup: remove duplicate line in build settings file

Cleanup: remove the objects build directory during generate.sh cleanup

Update: implement bash support in generate.sh

The generate script now supports handling bash scripts.

Feature: support custom 'defines'

Some libraries or packages have custom defines, such as the firewall _en_firewall_debug_.

Provide simple documentation of the defines, in the data/build/defines file.
Provide build settings values for specifying these custom defines.
Provide parameter for manually overriding defines.

Some path settings have been renamed to avoid confusion (such as '--c_path' is now '--path_c').

Enable _en_firewall_debug_ by default.

Cleanup: remove 'DEBUG: ' from debug output

Update: add build_libraries_fll build setting

Add a new parameter to make it easier to switch between individual compilation, level compilation, and monolithic compilation.
This parameter will only be used for fll-specific libraries.

For programs (aka: "level 3") commented out examples for linking against level-based and monolithic are provided.
The configurations can then be easily swapped out by a couple of simple sed statements, such as:
  - sed -i -e 's|^build_libraries_fll\>|#&|g' data/build/settings
  - sed -i -e 's|^#build_libraries_fll-level\>|build_libraries_fll|g' data/build/settings

The above example will switch to the level based compiling, while disabling the individual compiling.

The level based compiling compiles each of the levels 0, 1, and 2 as a single library for each level, resulting in libraries such as:
  - libfll_0-0.5.0.so
  - libfll_1-0.5.0.so
  - libfll_2-0.5.0.so

The monolithic based compiling compiles all of the levels 0, 1, and 2 as a single library, resulting in libraries such as:
  - libfll-0.5.0.so

The standard names of individual, level, and monolithic do not overlap by default and can therefoe be installed side-by-side.

Update: replace f_const with const

The typedef f_const is no longer used in place of const.

Feature: work directory support

Work Directory provides an easier way for developers to compile and test a particular set of FLL libraries and programs without conflicting with the host system.

If the host system has some version of the FLL project installed, the versions in the work directory will be used instead of the system directories.

Specifying the work directory is done via the '-w' or '--work_directory' commands.

To better achieve this functionality in the install.sh script, four new additional parameters were created:
- --libraries-static
- --libraries-shared
- --programs-static
- --programs-shared

These provide additional relative or absolute paths for installing the programs and libraries into.
The relative paths for --libraries-static and --libraries-shared is the library directory (which can be specified via --libdir).
The relative paths for --programs-static and --programs-shared is the program directory (which can be specified via --bindir).

Update: version 0.5.0

Feature: level-1: fl_program

The version function is used between all programs in this project.
Move that functionality into its own library: fl_program.

Cleanup: private firewall files do not need to be #ifdef wrapped

The #ifdef wrappers are intended for custom overrides, which should apply only to functions treated as "public".
These firewall files beginning with private- are private and do not need these wrappings.

Bugfix: install script destination parameters not being respected

I used the wrong name in the grab_next variable when designating to grab the next includedir and libdir.
There is also a mistake where I was copying the destination_prefix onto itself.