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.

Cleanup: Add extra parenthesis to prevent warning from clang.

Update: Stand alone Featureless Make build settings.

Cleanup: Remove the FSS Embedded List Program.

This embedded_list in fss_read should be used going forward.
The embedded_list in fss_read is not working yet and is just a copy of extended_list.
I will eventually get around to updating the embedded_list in fss_read to work as intended and expected.

Update: Set the pipe flag consistely across programs.

Use the same practice of designating the pipe as a main flag, even if the program isn't using the input pipe.

For the fss_read programs that use the word "pipe" in a main flag are renamed to "pipe" "format".

Update: Control program to latest design practices, migrating from 0.6.x to 0.7.x design.

This gets the control program to compile under the latest design practices.

I did not to an in depth review as this program does not currently do anything.
Once the controller program is updated I will eventually come back to this.

Update: Move standard console parameters enumeration into a standard enumeration set and provide appropriate functions.

This should make the commonly used code slightly easier to maintain.

The control project is omitted because I am in the process of migrating it.
The migrated version will contain the appropriate changes from this.

Cleanup: Byte Dump program defines and comment.

Bugfix: The Byte Dump program prints extra new lines.

Migrating from the old way to the new way results in extra new lines because of the first and last new line being printed.
Remove the extra new line being printed but still print in all other cases.

Bugfix: Byte Dump program 6-space string has only 5 spaces.

Add missing space.

Feature: Add f_select_signal() and update unit tests.

This adds the missing pselect() wrapper, f_select_signal().

Workaround: Clang compiler problems, add _clang_not_a_compile_time_constant_workaround_ define in Byte Dump program.

CLang fails to handle this well and errors out with: "initializer element is not a compile-time constant".

Provide a custom define _clang_not_a_compile_time_constant_workaround_ to be used as a work-around for the problematic CLang compiler.

Bugfix: Add missing return statement in Byte Dump function.

Update: Remove unused fl_signal and fl_signal_state_interrupt.

The fl_signal_state_interrupt() function is not used and is replaced by fll_program_standard_signal_received().

The entire fl_signal can be and is removed.

Bugfix: Byte Dump program binary mode is printing wrong number of padding.

Cleanup: Set named 0 enumeration in Byte Dump program.

Update: Relocate several static stings into single location for Byte Dump program.

Bugfix: Fix new lines when printing help.

I noticed a couple of programs are missing the correct new lines when printing the help.

Update: Minor fixes and consistency changes.

Fix some small things that I noticed while I was migrating the byte_dump program.

Update: Byte Dump program structure, following newer standards.

I noticed two things while working on this that need to be addressed for all programs.
1) When using threads, the signal for piping data (such as byte_dump /bin/bash | head) does not trigger.
2) The color code modes are not being processed correctly.

These observed bugs will be fixed in some other commit.

Update: Finish memory array related changes.

There are still the append() and append_all() function to change but I am going to leave that for another time.
This finishes the recent set of Progress commits addressing the memory array related code.

I have observed a notable reduction in binary size but the primary goal here is reduction of duplicate code and simplification of code.

I should eventually be able to re-introduce macros to map these helper functions back to the base array type to reduce binary size by a significant amount.
This should only be done once the API has stabilized more.

Progress: Continue memory array related changes.

I noticed that I could also implement f_memory_array_append() and f_memory_array_append_all() methods if I used memcpy() and a multiplication over the type size.

This:
    const f_status_t status = f_memory_array_increase_by(source.used, sizeof(f_socket_t), (void **) &destination->array, &destination->used, &destination->size);
    if (F_status_is_error(status)) return status;

    for (f_number_unsigned_t i = 0; i < source.used; ++i) {
      destination->array[destination->used++] = source.array[i];
    } // for

    return F_none;

Could instead become:

    const f_status_t status = f_memory_array_increase_by(source.used, sizeof(f_socket_t), (void **) &destination->array, &destination->used, &destination->size);
    if (F_status_is_error(status)) return status;

    memcpy(destination->array, source.array, sizeof(f_socket_t) * source.used);

    return F_none;

This could then be logic could then be moved into something like f_memory_array_append_all(), further simplifying the code into:
    return f_memory_array_append(source.array, source.used, sizeof(f_socket_t), (void **) &destination->array, &destination->used, &destination->size);

I need to think of the function structure that I want and so I only decided to comment in this commit.
Such a change is not implemented yet but may be done at some later time.

Progress: Continue memory array related changes.

Progress: Continue memory array related changes.

This converts a lot of the projects to use the f_memory_array_*() functions.

Break the f_thread private functions into their own files.

Progress: Continue memory array related changes, replacing the f_memory_structure entirely.

The f_memory_array set of functions now fully replaces the f_memory_structure functions and related macros.
I think those structure macros are nifty but they are not in use enough anymore and the f_memory_array structure is what I am going forward with.

There is still an enormouse amount of changes to do.

Progress: Add memory array allocation functionality and begin to use it where possible.

The pattern for handling the standard array structure is now well established.
Provide a memory array functionality for handling the most basic form.

This should reduce repeated code where possible.
It would be interesting if this reduces the size of the resulting binary but with inline optimizations it may be possible that this actually increases the size of the resulting binary.

Update the comments and tests.

There are a lot of files that will need to be updated to use these new functions.
Most of these are in the f_type_array project.

Update: Add FSS Simple Packet related functionality and remove delimit and comment types.

The FSS Simple Packet functionality is added, to provide for processing of the FSS Simple Packet.
The f_fss_simple_packet_ranges_t represents a set of ranges for designating where/how the packet is defined within some string.

The delimit and comment types are just helper type definitions for existing number types.
Simplify the design by getting rid of those, replacing them with the type that they effectively represent.
A lot of code is updated to reflect this change.

Feature: Add specification FSS-0010 "Encrypted Simple Packet".

This is an encrypted variation of the FSS-000F "Simple Packet" specification.
The third control bit (from the left) represents that the Simple Packet is encrypted.

The requirements for the format of the actual contents of Payload Block is further relaxed due encrypted data needing to be private (for what should be obvious reasons).

Update: FSS-000f specification, adding reasoning and improve the wording.

Add a simple paragraph about the reason why the size bit includes the Control Block and the Size Block in its size representation.

Fix a mistake in the words where the standard has "...of that that...".
The back to back use of "that" is confusing and probably a typo.

Cleanup: Remove extra space in documentation comment of the standard.

This does not alter the standard itself and so the version date is left unchanged.