Bugfix: FSS Extended Write is incorrectly adding a delimit slash for the first quote character.

If the first character in the string is a quote, then a delimit slash only needs to be added when there is a space after the quote.
If there is a graph character after the quote, then the delimit slash is not needed.

Progress: Further simplify tests, merging the number and the string helper tests.

The number helper can also be used as-is for the string helper and so rename the file and functions to a "payload" helper.
I originally had "at" in the file names because I was passing an index.
That index parameter got removed but I forgot to remove the "at" from the name of the functions.
The "at" is now removed.
I began adding the strings tests but I ran out of time to do further work on them.

Progress: Add string unit tests for fl_fss_payload_header_map(), and reduce redundancy in numbers.

This adds unit tests for the string abstruse type.

The numbers tests are all almost identical.
Abstract their design out into a helper function and a callback.

The string tests will likely need similar helper functions as the number tests.

Bugfix: If the first character has a width greater than one then F_utf_fragment is incorrectly returned when using quotes.

A F_utf_fragment is incorrectly when writing a string that would use quotes and that first character has a width greater than one.

The code is incrementing the string by 1.
This should instead be incrementing by the character width.
The loop itself should increment by the character width as well.

This bug has been exposed by unit tests.

Progress: Add join unit tests for fl_fss_payload_header_map(), focusing on number types.

Cleanup: Rename existing fl_fss abstruse tests to use "join" and "split" rather than "combined".

I forgot all about the function and files ending in "combined".
I am about to start writing tests for the "join" flag and noticed this discrepancy.
Rename everything to prevent any confusion.

Progress: Add some unit tests for fl_fss_payload_header_map(), focusing on number types.

This does not add tests for the join digits flag.
Such tests will be added at a later time.

Cleanup: Fix spacing.

Cleanup: The OSLv1 license, fixing grammar and clarifying intent.

This does not change the license other than fixing grammar and making the intent more consistent and clear.

This also adds a day to the license data that represents that last time this license has been modified.
The version number is changed only when there is a functional or substantial change to the license.

I have noticed that in some places individuals decide the "includes" is a restrictive word.
It is not, especially given that it is literally an inclusive word.
This changes the wording from "includes" or "including" to something like "including but not limited to" avoid any of that non-sense.
The proper application of the English language would result in the "but not limited to" being redundant and pointless.
This specific language is added just in case somebody does not understand the English language when it comes to the word "including".

Try to be consistent and use "lawful" instead of "legal" (except in cases where both are mentioned).

Generally, referring to "lawful" here also includes "legal".
The "lawful" is chosen to represent actual law rather than the more questionable "legal"  terminology.

The wording of "access to use, implement, etc.." can be misinterpreted such that the "access to" is applied to implement (and etc..) such that it becomes "access to implement".
The actual intent and design is not simply around "access to implement".
Instead, it is around "to implement", period.
Clarify this by splitting out "access to use" into "to access", "to use", etc...

Refactor: The map "name" into "key".

I find myself constantly typing "key" rather than "name".
I like the idea of using "name" as it is the "name" of the "key".
However, I have decided to refactor this from "name" into "key" given my natural tendency to type "key" when thinking about a map.

Progress: Begin next development pass on fl_fss_payload_header_map().

Preserve the error status when exiting by checking and returning at the end of the function (before setting F_okay).

Fix the logic regarding the number macros when it comes to expanding an array of numbers into multiple destinations.
The object key must be set.
The macro needs to be accepting the destinations array rather than the specific destination string.
The case where f_fss_payload_header_map_flag_join_digits_e is set is not yet tested or reviewed.

Cleanup: Minor changes to bootstrap-example.sh.

Update: Add missing snippet from OSLv1 license.

This piece of the license appears to have been lost somehow and is now added back.

Bugfix: Incorrect mode when featureless make is building settings.

This is a forward port of commit e70ac676f1907f17bcf24e428008183b8ccb96f5 from the 0.6 branch.

In the 0.6, this problem happens only on printing.
In this branch, the 0.7 development branch, this is used in different parts of the code and may have unintended functional consequences.

Oddly, this problem is not observed for the same files that the problem can be seen when using the 0.6 branch built programs.

I have opted to fix the problem rather than to investigate further.
The logic is clearly flawed and the fix is identical from the 0.6 branch.

Update: Disable -fstrict-flex-arrays=3 flag because it doesn't work on GCC 11.

I just did tests on GCC 11, which is not too old.
The -fstrict-flex-arrays flag does not work there.
For now, just disable the flag by setting it to the non-existent gcc_13 mode.
The mode can be added to the mode list and enabled if so desired.
I may make version specific modes available in the future (or not) but that will require some planning.
The fakefile should be designed to test the GCC version, but I would rather avoid such logic by design.
Let the distributor or the system administrator handle such decisions.

Update: Make the Open Standard License 1.0 formal.

I don't see any opportunities to get this reviewed and finalized and so I am formalizing it as-is.
I can always improve it if the opportunity arrives and increment the version number.

There are no changes to the license other than remove the "informal" and "draft" parts.

Security: Conversion is not handling NULL case when base unit is an unsupported type.

Feature: Add -a/--analyze to test.sh script.

Adding the -a/--analyze parameter to the test.sh script should allow for easier testing with the analyze option.
The idea here is to make it easier to perform these checks and to improve the quality of the releases.

Cleanup: The fl_print_format_convert() documentation comments should have the status documentation under the status text.

The status documentation should not be in the "@return" section.
The documentation for the "status" parameter should be describing this (and now is).

Cleanup: Remove out of place documentation comment.

Cleanup: Remove out of place semi-colon from documentation comments.

Cleanup: Fix wording in documentation comment for 'compression'.

Cleanup: Fix grammar in documentation comment, replacing process with processes.

Cleanup: Use F_true and F_False instead of TRUE and FALSE in the documentation comments.

Cleanup: Function documentation comments, removing or fixing invalid comments.

The Doxygen wizard reported warnings that exposed these problems.

Bugfix: Bash does not like "let x=" without an r-value.

Bugfix: Add missing f_compare link to FSS Identify program.

Update: Add the ability to explicitly skip a program.

The controller program is not yet migrated to compile under 0.7.x.
This adds the ability to the bootstrap example script to allow for simply skipping packages.

Bugfix: Remove unused files from build settings that break the build.

For some reason going through the bootstrap example script reveals this problem but directly using the packaging system does not.
This likely means that there is a difference between the system fake program and the one used during the bootstrap example script process.

Update: Get stand alone UTF8 build working.

Bugfix: Add missing dependency to f_compare.

Bugfix: Remove unused path.h include.

Update: Get the Byte Dump stand alone build working.

Add missing f_compare dependency.

The f_compare dependency is ultimately not needed.
There are no f_compare functions used because the dependent projects' functions that use f_compare are disabled.
The design could be further improved by adding disable defines around specific headers the might be worth disabling when the dependent module is not needed.
Such a change is considered out of scope.

Bugfix: Disable defines used for private_f_memory_adjust() and private_f_memory_resize() are incomplete.

There are additional functions that call these private functions that require additional disable defines added.

The _f_memory_FORCE_secure_memory_ and _f_memory_FORCE_fast_memory_ should be paired with their appropriate _di_f_memory_resize_ and _di_f_memory_adjust_ disable macro.

Bugfix: Remove stray double-quote from Byte Dump.

Update: Add -Wno-missing-braces, remove unused threadless, fix test.sh parameter, and fix minor mistakes in programs.

Add the -Wno-missing-braces to all settings.
This warning is not exactly accurate and it is annoying.

Remove stale code around individual_threadless from package.sh.

The test.sh has a parameter to test_operate_build_project() that is missing.
The lack of this is causing the test_thread_individual variable from not being received.

Several of the programs have some mistakes that come to light only when using -Wall.
- Remove unused variables.
- Should be using "void_main" rather than "main" in specific situations.
- Add missing return statement.
- Add missing f_abstruse dependency in fss_read.

Update: Unit tests and mocks with latest compiler and linker settings.

Update: Get clang working by separating out gcc specific settings, such as -fstrict-flex-arrays=3, and related changes.

The "-fstrict-flex-arrays=3" flag is not supported by clang.
Create a new mode call "gcc", make that the default, and move the "-fstrict-flex-arrays=3" into the gcc-specific setting.

Update the unit tests and mocks with these changes.
Make the unit tests and mocks more consistent by having these same settings.

Add a missing period at the end of the clang specific mode documentation comment.

The example bootstrap script handling of threads is improved.

Update: Break up the string ascii and string format disable defines and update working stand alone builds.

The _di_f_string_ascii_s_ set and _di_f_string_format_s_ set strings now have more granular disable defines.

Update the Featureless Make stand alone to not use build_sources_library.
This should be using build_sources_program only.

Cleanup: Remove packages that don't need to be included in stand alone fake build.

Update: Fix inconsistencies and other minor problems discovered while writing the example program.

Feature: Add example program for providing an example on how to build a standard FLL program.

The stand alone build system is also setup and working.

Update: Remove incorrect dependencies and remove some defines.

The f_fss_status code defines are removed to favor similar simplification done for the f_status defines.

The f_account is not used by the fll_execute project as far as I can tell.

Update: Finish refactoring firewall from 0.6.x to 0.7.x/0.8.x.

I have tested this out and compared the show results between the 0.6.x version and the 0.7.x version to confirm consistent results.
From this point forward problems are to be up for consideration as possible regressions.

Separate out more of the functions into separate files.

I reviewed the header includes and removed the headers that do not have apparent direct use.

Progress: Continue refactoring firewall from 0.6.x to 0.7.x/0.8.x.

Fix a few more bugs and add file path to some warnings.

This appears to partially work now with some of the rules not being applied.
More in depth review of the problems is required to wrap this up.

Progress: Continue refactoring firewall from 0.6.x to 0.7.x/0.8.x.

This fixes some obvious problems.

The firewall rules are not currently working and I am going to guess that it might be related to the buffering logic.

Progress: Continue refactoring firewall from 0.6.x to 0.7.x/0.8.x.

This gets the programming compiling.
There still remains some code to change.
The runtime needs to be tested.
I expect that there are things wrong given how much I jumped around while migrating this.

Cleanup: Switch from _ui_ format string to _un_ format string to match the print format arguments.

The _un_ format string is provided to directly match '%un' which is intended to directly match f_number_unsigned_t.
This is intended to make things easier (and safer) to hack.
That is, changing the data size of f_number_unsigned_t.

The _ul_ format string is specifically intended to be an unsigned long, period.

Progress: Continue refactoring firewall from 0.6.x to 0.7.x/0.8.x.

This is very close to be ready for review and testing.
I converted most of the buffers into the new structure but I need to check for isolation.
I am pretty sure that there are currently some isolation problems with the FSS Object and Content ranges.

I also noticed some typos and such that will need to be fixed (this therefore probably does not compile just yet).

Progress: Refactoring firewall from 0.6.x to 0.7.x/0.8.x and other FLL project wide changes.

Add the f_console_parameter_state_type_total_d and update all programs.
Add (and use) additional f_string_format strings.
Add fll_program_print_help_operations().
Add fll_program_print_help_special_options().
Begin using more helper flags for common behavior, such as "main_flag_version_copyright_help" type of flags.
Add missing documentation comments for some functions.
Remove duplicate "#ifdef __cplusplus" blocks in several programs.

Begin to refactoring firewall to follow the 0.7.x and eventually 0.8.x project design.
The firewall program is far from ready and will not yet compile.

Update: Use typedef on a structure tag to avoid the need for void pointer on the callback for f_state_t.

Using a typedef on the structure tag allows for having the structure reference itself.
In this case, the callback that is part of the structure accepts its own structure as one of the callback parameters.

I previously did not know that I could do this and opted to use a void pointer to provide this.
With this approach I get more safety, integrity, and less memory usage (for not having to add a variable that is a cast of the void pointer to the f_state_t).

Feature: Add _f_memory_USE_reallocarray_ and _f_memory_NO_zeroing_on_larger_ macros.

The _f_memory_USE_reallocarray_ designates to use reallocarray() rather than realloc() in the f_memory project.
The _f_memory_NO_zeroing_on_larger_ designates to not perform the memset() to 0 for malloc() or realloc() calls where the new size is larger than the old size.

The programs provided by this project might expect the memory to be zeroed.
Please use _f_memory_NO_zeroing_on_larger_ carefully.

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.