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.

Security: Add additional sanity checks before freeing in memory array and fix structure problem in dynamicss callback.

Add additional checks to ensure a free() does not get called on a NULL pointer.

The dynamics delete and destroy callbacks in particular have the f_memory_array_resize() inside the loop rather than outside the loop.

Cleanup: Remove unused file that got overlooked when wrapping up the recent memory logic re-design.

Security: Invalid allocation size for fll_execute_arguments_add_parameter_set().

The size should be size * 2 because of the parameter and value are added.

Feature: Add -U/--under parameter to Featureless Make.

I discovered that the data build directory customization is incomplete while working on the Kevux Tools TacocaT program.

A new parameter to specify a sub-directory within the data directory, called "under", represented by -U and --under is now added.
This provides the ability to change the "build" part of the "data/build" directory.
This can even be an empty string.

The fakefile documentation and specification is updated because this parameter must now be reserved and exposed to IKI expansion.
I have not yet done a thorough test of this feature and I will hopefully do this before the next release.
I have performed a basic test and I can now compile the TacocaT program easily using this parameter.

Update: Fix some overlooked unit tests following wrap up of re-designing the memory logic.

I forgot to run all tests and overlooked updating these.

Update: Wrap up re-designing the memory logic.

Update the unit tests and stand alone builds as needed.
Also clear out the stand alone builds that are out of date and require being rebuilt from the ground up.

Progress: Continue re-designing of the memory logic, focusing on unit tests for recent changes to f_string_dynamic_t and similar.

This adds some test files that I did a git add on but forgot to do the git commit with.
Update many of the unit tests and fix any mistakes discovered.

Progress: Continue re-designing of the memory logic, focusing on unit tests for recent changes to f_string_dynamic_t and similar.

Progress: Continue re-designing of the memory logic, focusing on f_string_dynamic_t and similar.

Progress: Continue re-designing of the memory logic.

I would note that I am leaving the append() and append_all() for the IKI structures because they are complex.
In the long term I may end up adding back the append() and append_all() functions for each type.
At this time it is more advantageous for me to not have that consistency for easier maintainability while the project is evolving and refactoring.

I still need to look over the string and UTF string memory related functionality.
This will be more delicate and given the size of these two projects will be a bit time consuming.

Update: Existing F_none and similar uses are now F_okay.

This is the second part of changing the status codes.

This is a massive regex based change and so there is a lot of potential for mistakes.
Time will tell.

Update: Use F_okay instead of F_none as the first status code.

This change is in two parts.
This part is just changing the status codes.
The next part will be changing all code using the status code F_none as the standard return to instead use F_okay.

I believe that F_okay makes more semantic sense than F_none when providing a standard code.
The original idea of F_none is that there are no errors.
I think "okay" is even more accurate.

Furthermore, the F_okay better matches the return code of the HTTP standard "HTTP 200 Okay".

Update: Simplify disable defines for status codes.

I like the idea of having the pre-created disable defines for each group.
The problem is that this is extra maintenance and I do not see significant use for this functionality.
Remove these to make my life slightly easier.

Progress: Continue re-designing of the memory logic, mostly getting tests back in synchronization.

Get the tests working.
Some of the tests I am not mocking the allocation and performing the real allocation actions.
This allows for the unit test to also test memory if run with valgrind.
I did this after getting much of the work done and so I ended up not consistently doing this on all of the "works" tests.
Generally, the tests for functions with the double 's' have the actual memory allocations.

Progress: Continue re-designing of the memory logic also removing *_append() and *_append_all().

In some cases *_append() and *_append_all() functions are removed.
This is a lot to manage at this time so remove it.
At some future point in time I need to implement a good generic append and append all design.
This is likely to use some sort of callback that performs the individual copy calls.

Many of the existing *_append() and *_append_all() are left alone but may eventually be removed.

The dynamic string based ones, however, will remain as an exception case.

The names I originally chose for the callbacks are misleading.
Rename them to be "delete" and "destroy" rather than "resize" and "adjust", respectively.

Half way through changing this I came across the more complex cases for resizing.
These I need callbacks both both array of arrays and arrays of arrays.
I did not finish the process of converting this.

The f_type_array needs more work.
In particular, the arrays of arrays in f_type_array can be moved into a common f_memory function, such as f_memory_arrayss_resize().

The unit tests have not been updated but I did manage to get the unit test for the f_account done.
The stand alone build config.h files are not update to date either.

These changes have shown a significant improvement in the resulting binary size.
The current size is actually just barely smaller than the 0.6.7 equivalent build (when compiled using the same compiler for both).
The changes are not complete and so I anticipate the 0.7.0 branch to be smaller than the 0.6.7 branch as of this change set despite the 0.7.0 development branch having more functionality.

Cleanup: Remove double "const" and add missing changes that were supposed to be in the previous progress commit.

The previous progress commit is 8a9248d98b54f39824a335da036b7671d05bae1f.

Progress: Continue re-designing of the memory logic.

Bugfix: Stop using f_memory_array_append_all() for an array of IKI data.

There is some logic mistake, structural mistake, design mistake, or an oversight.
Just do not use it for now and instead use a traditional for loop.

I may get rid of f_memory_array_append_all() in the future or I may spend time investigating what my mistake is in this use case.

Update: Ensure pointers passed to the function are constant.

The function should never be allowed to change the pointer itself.
A double pointer is used so that the value of the pointer can be another pointer which can then be changed.

Progress: Continue re-designing of the memory logic.

This makes a second pass around f_thread memory and addresses other bugs found.

Progress: Continue re-designing of the memory logic.

I did a first pass through the f_thread related memory code.
There could be a second pass through the f_thread, but for now this is good enough.

I spent some time going through the build process and other such code to get unit tests running with the latest progress commits.

Fix mistake in f_file_stream_read() where F_none_eof is returned but F_none should be returned.

Include cleanup commit f6725366474492f1b7baabba7938854f6e6412eb from 0.6 branch.

Progress: Continue re-designing of the memory logic.

Bugfix: Use the settings-mocks for the f_type_array unit tests.

This is a follow up to the Progress commit 0dda50d25ee1fd477b495451c8e8b55b428a85a3.

After trying to figure out why the tests were failing, I finally discovered that the wrong file is being used.
The settings-mocks needs to be used to pull in the mocked data.

I felt this fix deserved its own distinct commit rather than being part of another Progress commit.

Cleanup: Add explicit casts in the f_memory memset() calls.

The pointer is cast to uint8_t to perform the arithmetic.
The pointer is not cast back but the cast happens in the function call.
Be explicit and designate that the cast back to a void pointer is intentional.

Security: Add additional checks against the parameters in fll_execute_program().

Regression: Incorrect type on memset() in array resulting in invalid read.

The particular problematic array is an array of f_string_t and not and array of f_char_t.

This is the opposite of the regression that is fixed in commit 3533e7f840c5d852f98372f2dd9c9066cc53c85e.

Bugfix: Wrong index is being used for the file in Featureless Make.

The values array should be used and not the location of the parameter.

Progress: Continue re-designing of the memory logic.

This wraps up the simple memory append all functions with added unit tests.
I anticipate that I need to do the more complex ones as well.

This adds the adjust and resize callbacks for use in more complex memory functions.
The more complex memory functions for adjust and resize are implemented with unit tests.

The unit tests for the type array callbacks are incomplete because I did not get time to finish writing them.
Those unit tests are written but are incomplete and do not yet work.

Regression: Follow up to invalid type used when allocating string, f_string_t should instead be f_char_t.

I missed the save button on this file and this change did not get committed.

Progress: Begin simplifying memory design, starting with f_number_unsigned_t array structures.

I find that the use of custom per-type functions to simplify the usability of the library.
I also find that this increases the complexity and size of the code base.

I believe that over time this will become more complex and even harder to maintain.
I have decided to start changing the design to go back to simple allocation methods that just require more variables.
This simplifies the code and in theory will make it faster by having fewer function calls on the stack.
This may even reduce the resulting binary size (and I hope it does).

The down side is that the users of the library will once more have longer function call lines.

This commit is the beginning of the redesign process.

I also added the "append" and "append all" methods for f_memory_array calls.

Regression: Invalid type used when allocating string, f_string_t should instead be f_char_t.

I noticed odd differences between the 0.6.x and the 0.7.x in terms of memory usage.
I discovered this to be due to a bug where the f_string_t is being used when the type should be instead f_char_t.
This is likely a bug introduced in some past refactor.

Cleanup: Surround constant variable in a scoped block.

Progress: Begin further re-designing of the memory logic.

This adds the append and append all functions, respectively.
This adds a paramete check to see if width is 0.

Update: Add comment in Featureless Make code to designate changes the must be done.

The use of main->program.parameters.arguments should no longer happen.
This is the old behavior and it looks like it has not been completely migrated.

This is wrong an can even have invalid read sizes.

Feature: Add f_simple_packet_t for holding the packet data.

The f_simple_packet_range_t holds ranges within a string.

This f_simple_packet_t holds the actual values for the packet rather than ranges mapped to some string.

I am omitting unit tests at this time because I am going to do some additional changes involving the allocation and deallocation code project wide.

Bugfix: The socket id is not the same descriptor for reading.

When binding and listening on some socket id, the accept call on that socket creates a new descriptor.
That descriptor is not the same as the original socket id.

Add a new id_data to the socket structure to represent the data transfer file descriptor that is created via the accept() call.
Add a new f_file_close_id() to close the file by the id in case the f_file_t is not available or in use.

Feature: Add f_time project, adding functions for safely handling struct timespec.

This adds f_time_spec_millisecond() and f_time_spec_nanosecond() for safely handling overflow and underflow when using standard FLL f_number_unsigned_t numbers.

Unit tests are added.

A comment in the controller prrogram is added to designate that the controller-specific functions should be updated to call these functions.

Cleanup: Style in this f_print source file.

Update: Wrap the static inline functions private_inline_f_print_to_error in custom disable macros.

As an exception case, wrap the private_inline_f_print_to_error() in _di_private_inline_private_f_print_to_error_ and _di_private_inline_f_print_to_error_ as appropriate.
Using a define condition on all of the possible cases would be difficult to manage.

An explicit define is simpler and easier in this exceptional case.

Cleanup: Reduce usage of static in functions.

Remove the static from variables in functions that are not likely to be called multiple times and are not expected to be recursive.

I am backing off the experiment into this optimization for now.