Update: Add restrict optimization to f_memory functions.

The design of the memory operations require that array, used, and size do not point to the same memory address.
Help prevent potential aliasing by adding restrict keyword.
The functions with only a single pointer in its parameters still has the restrict keyword added.

I opted to avoid adding the restrict keyword to some of the append and append all functions.
Those would require more attention before I am certain whether or not they should be allowed to have overlapping addresses.
I think they should not, but just in case, I put doing that on hold.

The callback could also use restrict but I have decided not to do that as well due to the number of files that I will need to change.
I will do this later.

Progress: Begin adding unit tests for fl_fss_payload_header_map().

I added the single digit unit tests for signed and unsigned.
I started to add uint8_t with the test files but then I realized that I actually should implement uint8s_t.
I am leaving those test files currently but I will change them at a later date.

This adds a helper file for the payload header map private functions to simplify some of the code.

Bugfix: The f_string_dynamic_strip_null() memmove()'s out of range.

The i is a position rather than the total count.
Add 1 to the i.

This will need unit tests written to better catch these problems.

Progress: Actually wrap up initial pass of fl_fss_payload_header_map().

I somehow missed adding these changes for the commit 6999271214129e432376dd625f2cc6d097037d40.

Progress: Wrap up initial pass of fl_fss_payload_header_map().

Everything for the fl_fss_payload_header_map() function is written.
I can guarantee that there is some logic error or mistake somewhere due to the codestorming practice that I did with this (in addition to doing it across multiple weeks).

I experimented with different approaches in the different private functions.
I will eventually follow up this with a clean up pass that add functions to reduce the redundant code and also standardize the logic implementations where reasonable.

My next task in regards to this function will be to write unit tests.
This will find the problems and I will use the unit tests to kick off the rewrite of the private functions.

Refactor: The f_string_quantity_t into f_quantity_t.

This makes the f_string_quantity_t consistent similar to how f_string_range_t was refactored into f_range_t.
This is done because there is no actual string value in f_string_quantity_t.
There are only numeric values.

Bugfix: Runtime tests have incorrect space for "not a comment" line tests.

I overlooked a bug when I generated these files.
Now that the bug has recently been fixed, the unit tests are failing as they should.
Fix the incorrect tests so that they pass and fail correctly by fixing the "expect" relevant files.

Progress: Continue working on fl_fss_payload_header_map().

The current state is being saved so that I can refactor the f_string_quantity_t and related into f_quantity_t.

Progress: Continue working on fl_fss_payload_header_map().

Mostly focus on private_fl_payload_header_map_maps().
There is a lot of similar code design with subtle but key differences.
This is going to be really easy to make an mistake with.
Writing unit tests is going to be the ideal way to ensure the logic here is correct.

I did a lot of back and forth jumping around while trying to remember where I was last and what I need to do.

Make the build settings files more consistent in regards to threads and coverage modes.

Update: Add hopefully more secure compiler flags by default.

Use the "-Wl" for specifying the linker flags.
- Make sure "now", "relro", and "nodlopen" are set.

Add FORTIFY_SOURCE set to 3.

Add stack-clash-protection and strict-flex-arrays set to 3.

This project is designed around NULL checks.
- Make sure the no-delete-null-pointer-checks flag is set to prevent the compiler from removing these security/integrity checks.

Use stack-protector-strong rather than stack-protector for test flags.
- Future versions may enable stack-protector-strong by default for regular compiling.

Update: Make the -m thread option in the example bootstrap script more easily customizable.

Progress: Add Embedded List unit tests for fl_fss, but the Content test is incomplete.

The FSS Embedded List processing code is incomplete for the Content.
Put the unit test on hold until the code can be addressed at a later time.

Cleanup: Remove comments.

Bugfix: FSS Basic List and FSS Extended List print comment at the start of the Content.

When the Content exists at the start of the Content, the comment character ('#') is printed when it should not be printed.

This is a bug where the code initializes the newline_last at the range.start.
The code logic then always expects the newline_last to represent an actual new line.
This is not necessarily the case for when newline_last is pointing to the initial range.start position.

Add a check when processing a comment to ensure that the newline_last is in fact a new line.

Progress: Add Basic List and Extended List unit tests for fl_fss.

This adds the "works" unit tests for Basic List and Extended List.

Update: Wrap up fss_read changes regarding empty Content.

This is the follow up to the progress commit f71195801aaea4f1c58fd19875cd8a04d2cbd8bd.

Restructure the not used checks to a single location to make reading the code easier.
Make sure to only increment the line on empty Content when the empty Content flag is set.

Progress: Improve FSS program processing and fix related bugs.

Clean up the logic in the fll_fss functions, removing redundant code.

Improve handling of F_fss_found_object_content_not cases in a more consistent manner.

Improve logic of the fll_fss payload functions.
Remove dead code that does nothing.
Have the payload processing properly determine and communicate when the "payload" section is missing.
Update the documentation comments.

Improve the FSS read programs relating to the above changes.
Fix problems in the FSS read programs where sometimes the EOL string is directly printed rather than calling the appropriate object/content end callbacks.
The callbacks handle the uses cases for when the pipe is used but the direct EOL string printing does not.

Rename the FSS read progams print functions to have the "data", "message", "error", and such practice be more consistently followed.

This fixes several of the problems in the FSS Read programs where the "-e/--empty" parameter is not being properly respected in many cases.
I am not sure I got all of the situations and the logic from all of the changes that I made needs some review.

For the FSS payload read program, add a new special parameter called "--payload".
This allows giving the user more control over how to handle the cases where the payload section does not exist.
Specifically, there is a payload "create" mode that allows for ensuring that the "payload" section always exists.
This should ideally help make scripting simpler and therefore easier.

The parameters must be re-processed once the '-A" is passed for the fss_read combined program.

I added a print_content_empty callback and then commented it out in this commit.
This seems like it would be practical to have but I am not certain any FSS specification would need this at this time.
Further investigation is needed in this regard.

Add some more TODO and FIXME comments so that when I come back to this code and can better resume where I left off.

I did very little testing of these changes.

Cleanup: Comments in f_console and redundant header includes in tests.

Feature: Add f_console_parameter_reset() function for resetting the console parameters.

Bugfix: FSS Extended read fails to handle non-terminated quote as per specification.

This is a follow up to the problems discovered while writing unit tests and referenced in this commit: 70cbbe34121dc5679961df711e70724f13104489.

Given the line:
  a " b c d.

The following Content should now be returned:
  [0] = "
  [1] = b
  [2] = c
  [3] = d.

This adds a new FSS state flag 'f_fss_state_quote_not_e' to give the caller the ability to manually designate that the quotes are being disabled.
Currently only the FSS Extended utilizes this flag.

Refactor the private function private_fl_fss_basic_read() into private_fl_fss_basic_or_extended_read() to make it more explicitly clear that it provides functionality fo both FSS Basic and FSS Extended.

This changes to the code such that when an unterminated quote is detected then the calling function will set the disable quote flag and then call the function again.

The relevant FSS Extended unit tests are updated.

Progress: Add "works" unit tests for several FSS object and content reads.

This is a follow up to the commit cb7fc88118cefd6756e1ae7aab83891d887cfb4c.

Writing these unit tests exposed some bugs, such as:
- The one solve in commit ba257a8b8385ec8dedfc9bc9bb596e420ca552f8.
- The FSS extended read is not handling unterminated single quote correctly.

An unterminated single quote in an extended requires that the quotes be treated as normal text, as per the standard.
This means that the quote should be broken up into unquoted content.
This is not the case and is considered a bug.
For example, consider the following line:
  a " b c d.

That line is currently being interpreted by extended read as a single content called:
  [0] = " b c d.

Instead, this should end up being 4 contents:
  [0] = "
  [1] = b
  [2] = c
  [3] = d.

The unit tests files that I created here should expect this and therefore the extended read tests currently fail.

I am also adding the basic list tests but I did not get to implementing the basic list content read tests yet.
The test data files exist but I need to review them and write the appropriate code.

The extended list and the embedded list tests are not yet written.

Bugfix: Incorrect stop position is calculated when FSS content ends at the start position on FSS read operations.

When the start position is say, 0, and the determined stop position ends up being 0, then an incorrect stop range is calculated.
This happens because the stop position is subtracting one from the current position.

Add checks to ensure that the stop position is never subtracted beyond the initial start position.

The initial start position is saved at the beginning of each affected FSS read function.

This now potentially returns a start range before the stop range.
The FSS read programs should also need to be updated following this commit to handle these cases.

Progress: Update stand-alone fake build to reflect recent changes and fix comment bugs.

The previous work made several significant changes to the built packages.
Update the disable configuration file as appropriate.

Some of the comments have the wrong disable comment text.

Progress: Add "works" unit test for basic object read and basic content read.

My goal is to get to writing the payload tests but getting these other unit tests figured out first will make that process easier.

These "works" unit tests are intended to be very simple at this time.
There are no checks for comments.
The NULL data is not checked, partially due to the use of getline() and string comparison.

Cleanup: Fix documentation style regarding optional parameters in the fl_fss and the fll_fss projects.

Change the wording to be consistent with the rest of the project.
There should be "(optional)" in the comments.

Progress: Add basic unit tests for other fl_fss functions.

This adds only the parameter checking and the F_data_not return checking unit tests.

Cleanup: Refactor mistakes in the fl_path unit tests.

The fl_path project was migrated from fll_path.
The unit tests were not updated correctly.
This is an inconvenience rather than a bug.

The project comments also have "IKI" where the comments should instead have "Path".

The includes comment should be "FLL-1 includes" instead of "FLL-2 includes".

Progress: Continue adding FSS Payload processing code.

This also adds the beginnings of unit tests for the fl_fss project, specifically for the fl_fss_payload_header_map() function.
The tests for fl_fss_payload_header_map() will be rather complex and so I will likely break the tests for fl_fss_payload_header_map() into multiple files.

Cleanup: Invalid environment define "CMOCKA_TEST_ABORT" in testfiles.

This invalid configuration doesn't break anything unless someone uncomments it.
Then, the expected functionality does not happen.
The fix is easy, just add "define " at the start of that line to the right of the comment character.

Feature: Add double, single, and grave quotes for NULL cases as a common string.

Adding an open and close quotes to represent empty, aka NULL, strings in the FSS files is going to be common.

Define these as a single string rather than always having two function calls or having each project define these quotes each time.

Bugfix: Function private_fl_fss_basic_write() is missing "const".

The function implementations for private_fl_fss_basic_write() is missing the "const" type attribute in some parameters.
The declaration of these has the "const" type attribute as expected.

This inconsistency is considered a bug.

Progress: Continue adding FSS Payload processing code.

I did a lot of cleaning up and reorganization.
This adds a several flags that I intended to use but the current state of these is highly subject to change.

There are still a lot of incomplete changes, especially regarding existing code and the newly added flags.

Update: Correct the date for the recent backtick to grave specifications changes.

The commit f9c449c00b39902477a2b2443265848455f941ac neglected to include the updating of the date in the specifications.

Feature: Add f_string_dynamic_strip_null() and f_string_dynamic_strip_null_range().

The ability to strip out NULLs from a given string as a common function is needed.

Provide two similar but different functions.
The f_string_dynamic_strip_null() moves the NULLs to the end of the string and the shrinks the string used length as appropriate.
The f_string_dynamic_strip_null_range() shifts all of the NULLs found to the end of the given range without modifying the array used length.

Unit tests are added.

Only basic logic is applied and so there is no especially focused optimization in the parsing logic.

Cleanup: Add the word inclusive to the range documentation in additional places.

Cleanup: Rename 'structure' to 'buffer' in parameters.

The use of 'structure' is an old way of how I was doing things.
Using 'buffer' is more precise.

Refactor: The backtick into the grave.

Both the Unicode standard uses the word "grave" rather than the word "backtick" to commonly refer to the U+0060 character.
Change the use of the word from backtick to the word grave throughout the project.

This is a breaking change for the relevant programs, such as fss_write and iki_write.
Documentation, such as the website documentation and specifications, will need to be updated following this change.

Progress: Make control program at least compile.

I just did some quick tests and getting the control program to compile is just this simple change.
I believe there are still several programs, like the control program, that still need to be migrated from the 0.6 style to the 0.7 style.

Update: Switch to using the common format string structure where possible.

There may be other cases, but these are the ones I was able to quickly find.
After glancing over this I would also note that the common parameter argument printing could also be made common strings.
These would be common strings that are specific to something like fll_program.

Update: Add %/Q strings as a common format string structure.

Update: Add additional parenthesis around status in F_status check macros.

This is an extra safety check just in case.

Update: Add %ul strings as a common format string structure.

Printing color coded unsigned longs, which are generally f_number_unsigned_t, is expected to be common.

Update: Optimize bitwise logic regarding removing bits.

I intended to eventually do this and I finally got around to it.
Change the logic to use "x &= ~y" rather than "x -= x & y" or "if (x | y) x -= y".

In the case of "x -= x & y", the resulting object code is identical in my tests.
However, the code is simpler to write with the "x &= ~y".

The "if (x | y) x -= y" results in a lot more commands in the object.

Cleanup: Should be using the word 'read' and not the word 'write'.

Update: Add custom defines for the random seed macros via random/common.h.

I try to avoid the direct use of core/standard macros like GRND_NONBLOCK.

Add f_random specific macros for these GRND_* macros.

Update: The FSS-000E specification needs to say "one required object" and not "two required objects".

This is an oversight from the commit fdc1d99415cd72519c9c3ac36f5e8b69428ea0f2.

Cleanup: Fix incorrect endif disable macro comment.

Feature: Add f_random project for providing basic calls to getting and using entropy.

Update the stand alone build config files.

Add the appropriate unit tests.

Cleanup: Remove extra period at the end of documentation comment.

Update: Explicitly cast UTF conversion to/from and simple packet bit operations to a uint32_t.

If the type is changed or the defines are used with different types, then the shift operators may become problematic.
Prevent this potential problem from happening through explicit casts to uint32_t.

Refactor: The build stand_alone and disable files for simple packet refactoring.

The commit 96de6de49ac98d68b6c6f12fee8ca99dae8cbe8d missed these files.

Bugfix: The f_fss_simple_packet_encode() is not setting the entire size.

The code is casting to uint8_t too soon, causing the bytes after the first to be lost.

Cleanup: Remove stale comment in fl_fss payload.h.

It seems that what the comments describes is done.
The maps array is an array of strings.

Bugfix: Fix incorrect wording regarding negative times and add some clarification regarding defaults.

The time specification is mistakenly using the word "after" when it should be the word "before" for the example "2022:-5".

I decided that I needed to better clarify what I meant by default and not make it sound so strict.
Add additional language to better communicate that when the year is not specified, it is not specified.
There is no required interpretation and a default is simply a recommendation.

I am going to start trying to establish a habit of using UTC for my timestamps.
My local time zone, the date of the specification is still the 15 of December, 2023.
However, to stick with UTC for records purpose I need to the start doing this now.
There may be occasional inconsistencies for a while until I establish the habit of using UTC.

Refactor: The fss extract functions to be fss decode functions.

The commit 4713c80244fe1bc00da097eb27987e77c98601f0 introduced f_fss_simple_packet_encode().
Rename the f_fss_simple_packet_extract() and similar functions to f_fss_simple_packet_decode().

This makes the language more consistent between the two different functions.

Feature: Add f_fss_simple_packet_encode() for encoding the Simple Packet header.

Update: Strip NULLs from the payload number converters.

Add logic to strip the NULLs from the numbers.
The FSS functions use NULLs to reduce reallocations but the payload sends everything.

Don't introduce unexpected NULLs when writing the numbers.

I need to review the logic for any mistakes which I find is often best after sleeping on it.
Even better, I should write some unit tests to expose any potential logic flaws more easily.

Update: Socket size_read/size_write checks, result == -1, and explicit passing .generic.

Make sure size_read and size_write are not 0.
If either is 0, then return F_data_not.

Make sure the result checks are "== -1" rather than "< 0".

Explicitly pass .generic for the address union.
This probably isn't necessary but being explicit seems safer.
The memory address of the address union, regardless of the union type being used, is cast to 'struct sockaddr' in most cases.
This makes the use of ".generic" very practical.

Add documentation comment about F_pipe being returned.

Problems with the address unions ".sin_family" must be set or unclear F_pipe errors are returned.
I may in a future commit perform this assignment during setup because the "form" parameter makes this practical and reasonable to do.

Update: Further re-design f_socket_connect().

This is a follow up to commit 596997daebd53246b205d0221c5c616bfafb7d23.

Make sure to set the appropriate sizeof for the socket length.

Update the documentation comments to communicate that the socket length is updated on the function calls.

Make f_socket_connect()'s socket parameter a pointer.
Set the socket length in f_socket_connect() to the appropriate size.

Add documentation comments regarding the pointers that must not be NULL in f_socket.

Update the related unit tests.

Update: Re-design f_socket to better support handling of different struct sockaddr types.

The networking types are already in use, such as address family (AF_*) and protocol family (PF_*).
The known and supported socket address structures (struct sockaddr) do not directly relate to either.
Create a new enumeration that directly maps to these socket address structures (struct sockaddr), called an address form.
A 16-bit integer is hopefully more than is ever needed for this.

Rewrite f_socket_bind() and f_socket_connect() to use the socket.form enumeration.
The custom *_inet4(), *_inet6(), and *_local() functions are removed.

Add a generic, or fallback aka failsafe, type for handling the most basic socket address tructure (struct sockaddr).

Update: The fss-000e (Payload) specification should allow for the "payload" Section to be optional.

In cases where packets that are being sent only need to send the "header", then it makes sense to not have a "payload" Section.
This should help reduce network traffic by avoiding the extra "payload:\n" characters when the payload Section is to be ignored.

Update: Add missing documentation on status code from f_socket_connect().

Update: The unit tests where socket.id needs to be set properly.

The commit a55af231dacdf355323d42ba6e06f0188eb7d387 the socket.id bug in f_socket_connect() but failed to update the unit test.

Bugfix: Update unit tests and fix problems exposed after fixing unit tests for f_network_is_ip_address().

This is a follow up to these commits:
- 0e69871e03990990e0ebdf1b496ece67c40f4b5e
- 309f2625e983ef164c52543b492365fe92eed6d5

Add additional tests.
Fix bad test data, such as where the string lengths are incorrect.
Perform tests when "where" parameter both is NULL or is a valid pointer.
The tests now handle validating the "where" parameter, when specified.

Add additional comments to better communicate the logic in f_network_is_ip_address().
Properly handle the "where" parameter assignment.

Bugfix: Unit test should reset size after free.

The size must be reset due to the manual free otherwise a memory error occurs later on.

Update: Unit tests for f_network().

The commit 309f2625e983ef164c52543b492365fe92eed6d5 did not update the unit tests.
The tests currently do not pass due to a regression that will be addressed in a follow up commit.

The referenced commit was rushed so that I could get to the f_string_range_t and related migration.
I didn't bother to review the code or run the unit tests.
I will now have to follow up with a more extensive review and fix any problems.
The unit tests need to also be updated to handle all of the new behavior of the changed function.

Refactor: The f_string_range_t to f_range_t and f_string_range_double_t to f_range_double_t.

Update: The f_network_is_ip_address() to use f_string_range_double_t (soon to be f_range_double_t).

This allows for getting both the address and port range positions.
The POSIX/libc functions do not support the bracket notation in an IPV6 address.
The string detected by this must then have the brackets filtered out.
This new structure allows for saving the range.

I did a quick run-through write-up of the logic for these changes but I have not spent any time reviewing or testing the logic.
Hopefully there are not logic bugs or mistakes.

Feature: Add f_string_range_double_t, updating build settings and unit tests appropriately.

I need a string range structure that has two ranges for some given string for the network related code.

The unit tests are updated or added as appropriate.
Any bugs discovered in the related unit tests are fixed.

The build data is rebuilt.

I originally wrote f_string_range_t to be specific to strings.
I now think that this needs to be conceptually more generalized.
The purpose of such a generalization is to simplify the code logic and design.
Renaming f_string_range_t to f_range_t and now renaming f_string_range_double_t into f_range_double_t is the intended change.
This would then be moved out of the f_string project and into the f_type project.
This is too much to do in the scope of this commit.

Instead, the f_string_range_double_t is being added under f_string_range_double_t.
I will then follow up this commit with a refactor of the f_string_range_t and f_string_range_double_t.

Bugfix: f_network_from_ip_string() and f_network_to_ip_string() design problems.

Change the inet_pton() and inet_ntop() function calls to use the explicit .v4 and .v6 union members.
Being explicit is much safer.

The inet_pton() function also returns zero without the errno set when the address is invalid.
Handle this case, returning F_address_not (with error bit) when zero is returned by inet_pton().

The unit tests for these functions are incorrect and are not all called (which is why their incorrectness was not previously discovered).
Make sure to use h_errno where appropriate.
Make sure the mock function for inet_pton() allows for returning zero or non-zero.
Make sure the family type is set so that the expected return codes are returned.
Make sure the ip string is set so that the expected return codes are returned.
Handle the newly added F_address_not case.

Add the missing unit test function calls:
- test__f_network_from_ip_address__fails
- test__f_network_from_ip_name__fails
- test__f_network_from_ip_string__fails
- test__f_network_to_ip_string__fails

This could use more review and testing.
Such extra review will be performed while I continue to write TacocaT.

Cleanup: Use upper case "ID" rather than lower case "id".

Bugfix: f_socket_connect() should require non-negative socket.id.

I seem to have this one backwards.
The socket.id must be something other than -1.
If the socket.id is -1, then just return F_file_descriptor without error bit to designate that no descriptor is available to connect with.

Update: Specifications for Payload and Simple Packet.

Add "type" as a recommended Object in the header section for the Payload.

Change the size units being used in Simple Packet.
The numbers used in some areas are completely wrong 2^4 is not 32-bits.
Instead use the word "bytes" or "bits" and update the units.
The Payload Block Structure uses "bytes" rather than bits as that is the general focus of that section.
All others use "bits".

Progress: Continue adding FSS Payload processing code.

Add the common, recommended, payload Object strings.

Progress: Continue adding FSS Payload processing code.

Cleanup: Remove spurious space.

Update: Fall back to MAXNAMLEN if NAME_MAX is not available.

On systems like BSD, MAXNAMLEN is available in place of NAME_MAX.

Progress: Resume working on custom payload functions.

I'm getting more back into things and this is a small step towards pickup up where I left off.
There are several todos that I will consider and either implement or not.

This performs the work that I mentioned in the previous commit in regards to redesigning the approach in fl_fss_payload_header_write() (now called fl_fss_payload_header_map()).

Progress: Continue adding FSS Payload processing code.

I started doing some re-designing to improve the approach and prepare for signatures/checksums.

I realized somewhere during that process that I wanted to eventually control or even randomize the header order for integrity, organization, or security reasons.
The current approach makes that impractical.

I decided to save the current state so that I can then pivot to a better approach that will accommodate the above needs.
Appropriate todo notes are added to this end.

A lot of the existing payload code will be re-designed, again, as a result of this.

Progress: Continue adding FSS Payload processing code.

I decided to use two caches.
One for the main cache.
The other for a smaller, multi-purpose cache.

The second cache should be smaller and so re-allocations should be cheaper.
Use re-allocations on this as much as possible.

There are some code changes that I was indecisive around and jumped around on implementation.
I think I cleaned that all up but I may have missed something.

Progress: Begin adding FSS Payload processing code.

I haven't gotten much time lately but I wanted to at least move this forward even if only a little.

This only performs some basic or minor progress regarding the f_abstruse project.

Progress: Begin adding FSS Payload processing code.

This will use the f_abstruse project.
This is very incomplete and is mostly drafted out.

Update the Featureless Make stand alone build with the latest changes.

Apply the related cleanups from 4ced1b0ba41334ce94d0a9b511b363a6031da136 (Cleanup: Have enumeration types support "none" and have the "// enum" comment at the end.).

Add some documentation comments.

Cleanup: Have enumeration types support "none" and have the "// enum" comment at the end.

This makes the code more consistent with the intended style practices.

Update: Simplify the f_abstruse types a little.

Being a union, the single valued integer types provide very little gain and introduce a cost in complexity.
Remove the integer types that overlap and just stick with the f_number_signed_t and f_number_unsigned_t for single value number types.
Multiple valued number types remain because there is potential for design differences due to the memory allocation and size differences.

The f_char_t type is removed.
Just stick with f_string_t.

Update: Specification FSS-000E (Payload), add "signature" Object section.

Provide an optional "signature" Object and associated Content rules to the specification.
This better separates defining how the "header" and "payload" can be signed or have checksums applied.
The actual rules are left rather vague and flexible for implementation specific decisions.

A suggested strategy for using the "signature" is provided within the example.

Feature: Add f_abstruse project.

This is the initial design and may be subject to significant change as I begin to use it more.

The idea here is to provide a type that can act as a catch all for any sort of header of any specific type.
I use standard types and provide void pointer types for everything else.

I have some concerns about supporting void pointer types due to the special case of how to handle this allocation actions.
I have decided to withhold the "append" and similar standard functions for now until I get a better grasp on how this should be used.

A union is used to use the same memory space at the cost of the largest size.

A dynamic string is likely the most common case.

The resize and similar functions provide warnings that the caller needs to be careful about allocation and de-allocation.
This poses extra security concerns for when callers of these functions do not properly or safely handle the data.

I intend to use this in the FSS Simple Packet processing code, such as writing (building) the Simple Packet string.

Update: Restructure f_type files and add missing f_number_signed_t.

Break apart the f_type headers into multiple header files by major type groups.
This should make navigating the files a little easier.
Some of the header files are order sensitive.

The f_number_signed_t is now implemented.
Added appropriate unit tests.

I manually added the disable defines in the fake stand alone configuration file.

Update: Minor clean ups and have f_socket_connect() return F_file_descriptor.

The f_socket_connect() should return F_file_descriptor when socket.id is in use.
Add appropriate unit tests.

Cleanup: Add missing "e" in the "the" in comment.

Bugfix: Problems exposed by clang-13.

The Vedic Extensions Unicode checks are out of order.

Remove unused "last" variable from private_fl_utf_file_write_until().

Cleanup: Fix unit test documentation comment for f_directory_remove_custom().

Update: Add check in f_socket_disconnect() to explicitly check socket file descriptor.

Avoid depending on libc calls and instead explicitly check the socket file descriptor.
Return F_file_descriptor_not when -1.
Add unit test for this.

Update: Replace f_fss_simple_packet_identify() with f_fss_simple_packet_extract() and f_fss_simple_packet_extract_range().

The implementation of f_fss_simple_packet_identify() appears to be some sort of hybrid between actual code and brainstorming.
This appears to be by accident and the resulting logic of the function is nonsense.

Fix the logic in f_fss_simple_packet_identify().
I also see no reason to perform an identify call.
The FSS Packet design is so simple that I could just add 1, 4, or 5 to determine any of the parts.
Therefore, instead implement f_fss_simple_packet_extract() and f_fss_simple_packet_extract_range() to extract the Control bits and the Size integer.
The Payload part is not extracted but for the f_fss_simple_packet_extract_range(), the range for the Payload is determined.
This allows for the caller to determine how they want to manage the memory allocation.

This is a case where object-oriented would shine had I used C++ or some other object-oriented language.
I don't have this option available and so I am going to only have f_fss_simple_packet_t and f_fss_simple_packet_range_t with their respective f_fss_simple_packet_extract() and f_fss_simple_packet_extract_range() functions.

Unit tests are now provided for these two new functions.

Bugfix: Mistakes in the FSS-000f Simple Packet specification.

The "Size Block Structure" section has the wrong example.
Fix the example to display the Size Block structure, which is a 32-bit digit.

Change the "Control Block Structure" section to use "size" annotations rather than bit examples.

Update: Fix unit tests after adding additional sanity checks.

The commit 3dee02180d1ab33471e57b17c1485532fee1c597 introduced additional sanity checks.

Several unit checks did as little as necessary to perform the tests when it comes to mocking.
The additional sanity checks impose additional restrictions.

Update: Add missing too large and too small status code handling for F_payload too large and too small.

I missed these in the previous commit 2b61b24b69bb7bf7dec41759dfb4f9cb4b188ffd.

Update: Take advantage of lucky convenience where F_okay could be bumped from 197 to 200 thereby matching HTTP 200 status code.

I recently noticed that the F_okay is very close to being a 200 code after swapping F_none with F_okay.
This was never planned but it is incredibly convenient.

HTTP Status 200 code now matches FLL Status Code 200.
What luck!

Update: Add too large and too small status codes for F_payload and F_packet.

The packet and payload are very likely to have too large status codes.
Add the too small status codes for consistency.

Update: Relocate some of the more common or expected to be common format strings to global statics.

This is a minor resource optimization.
There will hopefully be more optimizations in the future where several of the commonly used strings (within individual projects) are moved into a single location for that given project.

Cleanup: Add comment to help clarify the size * 2 logic.

This will comment should help future proof accidental incorrect changes to this value.