Cleanup: Style improvement.

Bugfix: The byte_dump --first and --last are not always working as expected.

The problem is due to a calculation resulting in a negative value.
The code "width_utf == -1 ? 0 : width_utf - width_count" does not account for when width_count > width_utf.

Refactor the use of "characters" with "sequence" to reflect recent changes in terminology usage.

Regression: Remove invalid validation block.

This appears to have been introduced in 002bf17595459e65173be16f983977ead99593b6.

There is a lot of restructuring during that commit which may explain the mistake.

Bad code somehow got mixed in.
I'm not sure what this block is supposed to do but it is clearly wrong in multiple ways.
Remove it entirely.

Update: Follow up previous Unicode changes.

The previous commit changed a significant amount of behavior.
That commit noted that follow up changes would be necessary.

First things first.
I noticed that when I simplified the is valid checks I ended up over simplifying them.
There are several byte sequences that are not valid UTF-8 sequences.

I previously added surrogates and it turns out that UTF-8 specifically does not support Unicode surrogates.
Remove all related code.

The f_utf_char_t is supposed to be in big-endian format.
The macros are fixed to properly handle this.
This fix exposed problems in the conversion functions.
The conversion functions lack the proper big-endian and little-endian support.
Introduce a new structure and parameters to support designating the big-endian and little-endian.
Support a default order to host byte order.

The utf8 program needs to properly handle the endianness in a different way.
The bytes are in left-to-right format but when converted are converted in a left-to-right format but shifted to the right.
Swapping between little-endian to big-endian would be incorrect because the byte order is aleady correct.
The byte position is what is incorrect.
That is 0x0000c280 should be shifted to 0xc2800000.
Swapping the endianness would instead yield 0x80c20000 (which is incorrect).

The use of the word "character" as a variable name and in documentation can be confusing.
I have recently defined a "byte sequence", a "code point", and a "unicode" as specific types.
Change the word "character" to the appropriate name to make the code less confusing and more specific.
There are also other words used in place of "character" that might not be the ones listed above.

Some of the tests, particularly the emoji tests, have incorrect data.
I discovered that many sources out on the internet violate the standard and call code points an emoji that are not official recognized as an emoji by the standard.
I'm going with wikipedia on the new and updated emoji list.

The f_char_t is available so update old code that still uses uint8_t to instead use f_char_t for character related data.

Changes to the is valid code resulted in identifying invalid byte sequences that were previously considered valid.

Update: Unit tests for f_utf and relating changes or bug fixes.

Fix several problems exposed by unit tests.
Fix several unit tests to work as expected due to problems with the data files.

At some point I seem to have diverged from always ensuring that the f_utf_char_t is always big-endian.
I probably got lost in ensuring the differences between big and little endian that I ended up making the f_utf_char_t act little-endian in cases where host is little-endian.
The f_utf_char_t must always be big-endian.
However, there are cases where the big and little endian behavior must be processed.
Break up the macros into having "_be" and "_le" to make this possible.

The iscntrl() check return value needs to be explicitly handled to ensure that only F_false or F_true is returned.
This is already fixed in one function already.
Apply the existing fix to the other function.

The f_utf_char_t should be seen as a single character rather than a stream of bytes.
Unit tests now treat any non-zero value after the designated width as invalid.
The is valid checking code now tests for this invalid case.

The unit tests are improved.
Test for F_true and F_false rather than calling assert_true() and assert_false().
Error bits and other status codes were previously passing when they should fail due to the use of assert_true() and assert_false().

This commit changes the byte order of the f_utf_char_t.
This will break code such as the code used in the utf8 program.
A follow up commit is necessary to fix any byte order problems.

Update: Add unit tests in f_utf project.

These tests are created based on the comments in the code.
Unlike previous tests, I reviewed the Unicode database separate of my code.
This approach is faster but will not expose any Unicode Codepoints that I missed when writing the code.

This adds tests for the following:
- combining
- phonetic
- subscript
- superscript
- wide

Cleanup: Use correct range.

This is not a problem because but it does contain ranges that can never match.

Update: Add some unit tests for f_utf.

Add the structure for the remaining tests.
The (currently) unused tests are just copy and pastes and may need changes.

With the exception of the "valid" tests, these unit tests use statically generated data files containing bytesequences (unsigned 32-bit) in base-10 format.
The base-10 format representation of the bytesequence is used for easy reading using standard libc functions.

These static data files are generated using a combination of the Unicode database codepoints, a script I wrote, and the "unicode" program.
The Unicode codepoints used for each generated bytesequence set are also provided.

This implements the following tests:
- control
- digit
- emoji
- symbol
- valid

The intent of this is to test the entire spectrum of valid codepoints (except for the "valid" tests which tests every single possible value).
Due to every single value being tested by "valid" tests for both f_utf_is_valid() and f_utf_character_is_valid() results in a long running test.

Bugfix: Problems exposed by unit tests for f_utf.

Correct comments and add missing characters.

Add the missing f_utf_character_is_surrogate() function.

Change the is valid algorithm to one I developed for the unit tests.
These are cleaner and simpler due to bitwise operations.

Update: Add unit tests for is_punctuation in f_utf project.

This includes minor style clean ups.

Update: Add unit tests for is_private in f_utf project.

Update: Add script for generating Unicode Codepoints from integers.

A simple script that I am using for generating a range of Unicode Codepoints in the format needed by the generate_unicode.sh script.
The private use area is represented by multiple sets of all values within some range.
These ranges are a massive list.
This script generates these.
The only thing I need to do is use a calculator program to convert hex to integer.
These integers are then passed to the script as an inclusive range.

Cleanup: Incorrect comments in iki headers.

Update: Implement symbol function unit tests and fix comments.

This brings in and utilizes the symbol test data.

Update: Generate Unicode script to support generating test data.

The test data is generated from a line separate Unicude Codepoint file.
The generated test data is in base-10 format rather than hexidecimal to make it easier for standard libc functions like atoll() to be used.

Bugfix: Problems exposed by unit tests in f_utf.

Only UTF-8 symbols are tested.

Bugfix: Last character of file after conversion from code point is not printed by utf8 program.

The algorithm doesn't print the character until it knows when the character is complete.
There are no checks for when end of file is reached.
This results in the last character not being printed, even if the code is complete.

Be sure to return the status rather than always returning F_none under certain circumstances in utf8_detect_codepoint().
Update documentation about return value in utf8_detect_codepoint().
Initialize the character.used to 0 rather than 4 (because it has no data!).
For better practice, compare using >= rather than ==.
Remove unnecessary i = 0 assignment.

Bugfix: Incorrect 4-width characters are generated.

This is caused by a simple typo.

Cleanup: Remove execute bit from script.

The build scripts should not have the execute bit set.
These bits will get appropriately set during the packaging process.

Update: Finish adding Unicode symbol handling code.

I used a script that I wrote to assist.
Additional tweaks were still necessary.
There is a lot of room for error, but this saved me an enormous amount of time.

Feature: Provide simple script for assisting in the mass generation of Unicode handling code.

This is a very simple script and is not intended for complex tasks.

Update: Add unit tests for f_signal project.

Update: Rename f_thread_signal() to f_thread_signal_write().

I feel this function name should be more explicit.
That is, it should avoid confusion between read and write operations.

Bugfix: Problems exposed by unit tests for f_signal.

Fix ordering of functions.
Compare using "== -1" rather than "< 0" because the POSIX standard says "-1" rather than "less than zero".

The f_signal_read() function has several problems:
- Should be passing a pointer rather than an array to poll().
- Needs to check data_poll.revents.
- Missing the parameter checking.

Update: Unit tests in several projects.

Remove invalid errnor checks.
Design some of the mocks to be more consistent across the projects.

Bugfix: Problems exposed by unit tests in f_file.

The stream functions do not populate errno.
In these cases return either F_file_read or F_file_write with the error bits set as appropriate.

Update the documentation comments.

Cleanup: Update unit tests in f_print to follow current __wrap_fwrite_unlocked() mock practices.

Cleanup: The f_print project code syntax, adding an inline function.

Update: Get all f_conversion unit tests working.

Add missing mocks.

Bugfix: Problems exposed by unit tests in f_conversion.

The unit tests were disabled due to previous problems that are not no longer a problem.
This exposed a few areas that could be improved.

Rename "output" to "stream".
Make sure to call ferror_unlocked() to test for error.
Add loops to handle when fwrite_unlocked() doesn't write all the data but also doesn't throw an error.

Use "negative_or_zero" instead of "negative" to be more verbose and less confusing.

Bugfix: When any of -c, -p, or -s is the last parameter in test.sh no error is thrown.

These must have an error because they expect an additional argument.
Change the behavior of the code to cause an error in this cases.

I took the lazy way out and just set the variables to trigger an error rather than implementing a specific error handler for these cases.

Update: Next micro version (0.5.10).

Cleanup: Fully remove stale/unused variables.

I simply assumed the compiler warnings meant that the variables were not used at all.
Looks like this is an incorrect assumption.
The compilers appear to more intelligent than I expected and can detect that even though the variables are modified later on, they still are not used.

This is good news.
The bad news is that means I have bad code resulting from an incomplete clean up that need to be fixed.
This bad code is now fixed.

Bugfix: Package building test failures do not properly fail.

The wrong variable is checked and so the failure is missed.

Update: Add unit tests for f_status.

The f_status only has macros and I generally do not test macros.
These are special macros used everywhere so I decided to add macro unit tests.

Bugfix: Fix problems exposed by unit tests in f_status.

The signal bit can be confused with the error and warning bits.
The tests for checking if the signal bit is set need to test exclusively for the signal bit being set.
The tests for the error and warning bits do not care if this is a signal.
This is done to simplify some of the logic.
In the cases where the signal bit is to be tested, first check the signal bit and then check for the othr bits.

Cleanup: Remove stale/unused variables.

Update: Improve the logic in the string comparison tests.

Several of the F_parameter errors do not need to be returned.
This logic is already handled by the called functions as not matched.

Make sure the stop range is not longer than the buffer used.
When the buffer used is smaller than the requested range stop, then use the buffer used rather than the stop point.

Cleanup: Syntax.

Bugfix: Incorrect variable used results in F_parameter error.

Update: Implement Math Symbol Category.

Update: Handle more cases of combining characters following white space.

The way UTF-8 combining characters works continues to give me a headache.
This is a pass at resolving the case, but the logic is unfortunate.
I have a strong feeling that there is a regression from this.

At this point I feel unit tests are necessary.

Perform the combining check after checking white space.
Make the code more flexible by not returning on any invalid character.
An invalid character cannot be a white space, so treat it as not a white space and continue.
The resulting code should be more robust.

Bugfix: The print functions are not printing the last letter in certain cases.

The overflow check is testing against >= stop or length.
The equal sign is the problem here.
If the character ends on the stop point or the length, then a whole character would have been printed.
This is not an error and should not result in a return.

Changing >= to > fixes the problem.
Because of this, the additional width check is unnecessary.

Cleanup: Capitalize first letter of comments.

Bugfix: Finish addressing trimmed printing is not working as expected.

The previous commit c8c59e16bb4cb7936142bff4815b302ad57138de is incomplete.
Finish addressing the todos and also catch other cases where trimmed printing is not working as expected.

The addition of the combining character checks introduces additional complexity.
This complexity is stronger reason to write unit tests for fl_print.
There is a lot of room for error as a result of this additional logic.

Bugfix: Trimmed printing is not working as expected.

The length is being used in several functions where an exclusive stop should be used.

There are some improper max length checks.
These are likely the result of a refactor where range checks were replaced with length checks.

In some cases a counter is missing resulting in an infinite loop.

A stop length should be using a >= rather than an == because the incremented width could be greater than one.

Cleanup: Rename "output" to "stream".

Using the word "stream" is a better and more precise term.
The word "stream" is already in use elsewhere and using this makes the project more consistent.

Update: Unit tests, fixing minor problems and adding missing functionality.

Many of the testfile files have "tests" when they instead should have "test".

The f_print must have a clang specific define passed to work-around a clang problem.

I noticed that I forgot to implement several "returns_data_not" unit test while writing the f_fss unit tests.
Provide these missing unit tests for the f_type_array project unit tests.
This project is my de-facto standard for basing all of my standard data type unit tests and needs to be as correct and up to date as possible.

Update: Add the status codes.

I forgot to add these to a previous commit and almost mixed them in a different commit that they do not belong in.

Update: Add unit tests for f_fss project.

Update: Fixes and changes resulting from f_fss unit tests.

After reviewing the code I found that the logic is outdated.
The logic was written at the time when I was still far less familiar with Unicode.
The zero-width is being processed in the same way as combining characters.
This needs to change.

After reviewing the combining character logic, I realized that there are bigger problems.
The combining characters, for whatever reason, are processed from right to left.
This breaks normal streaming logic and requires post checks on all variables.
I am amazed that they let such a horrible idea get into the standard and I do not know why.
Regardless, the logic on many of these functions needs to change.
The logic is changed to more properly handle the combining characters and additional more explicit code comment documentation is added.
There will likely need to be follow up changes in the processing code but I am going to leave that for another time.

Change the code to be more consistent with how F_data_not is returned.
Rename functions to more consistently follow the naming strategy used (such as changing "_between" to "_range").
Add f_fss_is_combining() function.
Remove unused and unnecessary f_fss_shift_delimit() function.
Remove unused and unnecessary f_fss_skip_past_non_graph() function.
Update the FSS specifications to better clarify the combining character situation.

The combining character logic implies that I need to return status codes to designate that the return is happening at the start of some processing.
Create several "_start" status codes to address this need.

Fix a bug from a previous commit that is the result of a misplaced regex replace ("alphabeticbetic" should instead be "alphabetic").
Fix a bug where some files where missed when refactoring is_alpha() into is_alphabetic().

Update: Add Unicode Symbols for currency and modifiers and minor comment clean ups.

The symbols are being added in stages.
Add the currency and modifier symbols.

Update several comments with the todo and fixme notations.

Cleanup: Remove the parameter checking macros around the function definitions in the unit test.

The tests do not really matter when it comes to file size.
Simplify the test code by not using these macros.

These macros are still used to perform the call.
They just do not need to be around the function definitions.

Cleanup: Remove stale todo comment.

Bugfix: Unit test for f_serialize has incorrect dependencies.

Update: Add unit tests for f_print.

I opted to perform the bare minimum needed tests due to the size of this.
Eventually I need to check to see that the correct characters are printed.

Bugfix: Fix problems exposed by unit tests in f_print.

Swap the length a string checks, the length has priority over string.

When performing the character safely prints, the F_utf should only be returned for UTF-8 characters whose width is greater than 1.
The ASCII characters are now no longer returning F_utf.

Some functions are missing the clearerr_unlocked() and ferror_unlocked() calls that are needed for proper fwrite_unlocked() error checks.

Update the documentation comments, adding missing information.

Some of the *_to* functions are not checking if the counter "i" exceeds the length before checking for NULL.

The *_to* functions for *_raw_safely* do not exist and should to be consistent with the regular print functions.
Add the missing *_to*_raw_safely* functions.

Several of the *_to_except* functions are missing the offset parameter which should be passed for consistency with the regular print functions.

Random functions are missing the final print that should exist outside of the loop.
The "total" needs to be checked and if it represents that unprinted data is present, then print that data.

Feature: Provide rebuild option in package script.

I'm constantly using clean and build.
Create a single option to do both.

Cleanup: Restructure f_utf project to make it more manageable.

Update: The f_utf punctuation codes.

Bugfix: IKI variable substitution in fake doesn't always expand properly.

The commit 85738c3aed3949cc3f26b33e39d28b69dcc6d571 didn't fully solve the problem.

One problem is a copy & paste mistake in the declaration of fake_make_parameter_variable_option_build_s where the wrong define is used.

Make sure to conditionally allocate the arguments array before operating on the "used" position.

The used_content variable should not be needed because the arguments.used should be 0.
After conditional allocation, ensure that the arguments.used is 0 before operation and remove the no longer needed used_content.

When the reserved IKI variables that represent program parameters are used and exist in isolation for their argument, then they should expand as separate variables.
Consider these four examples:
  print 1 parameter:"build"
  print 2 parameter:"build".
  print 3 "parameter:"build""
  print 4 "parameter:"build\" between parameter:"build""

Lets say fake is called with the following "fake make -b /tmp/".
The "print 1" example would have the following parameters:
1) 1
2) -b
3) /tmp/

The "print 2" example would have the following parameters:
1) 2
2) -b /tmp/.

The "print 3" example would have the following parameters:
1) 3
2) -b /tmp/

The "print 4" example would have the following parameters:
1) 3
2) -b /tmp/ between -b /tmp/

The "print 1" expands into 3 parameters because the IKI variable is by itself for that given argument.
The "print 2" expands into 2 parameters because the IKI variable is not by itself for the given argument (It has a period '.' at the end).
The "print 3" expands into 2 parameters because it is quoted and is treated as a single argument.
The "print 4" expands into 2 parameters because it is quoted and is treated as a single argument and the "between" should still be between the two substitutions.

A break is added at the end of one of the loops because that part of the loop is only reached after a match.
When a match is identified, the loop no longer needs further iterations.

Bugfix: The quotes are always being defined even when there are no quotes in the FSS read functions.

Do not force either double or single quote by default.
If there are no quotes, then they should be treated as unquoted.

Update: Additional test settings and add initial coverage support.

The goal of the coverage is to support gcov.
I am very unfamiliar with gcov at this time.
The settings are experimental at best.
There will likely be numerous changes relating to gcov in the future as I learn the tool and devised a process to build coverage reports.

Update: The fake "build" fakefile Object needs to support modes and fix a related bug.

The fakefile needs to be able to support being passed custom modes.
The default behavior is preserved with this change.

This requires supporting that an empty string is passed as Content.
It turns out that the quoted empty string is incorrectly being skipped.
Make sure the quoted empty strings are not skipped.

Cleanup: Existing unit tests, adjust status check behavior.

I was lazy with the previous behavior and always cleared the error bits when performing the comparison checks.
Change the behavior to properly check the status code for when the error bit is expected and when it is not.

Update: Add unit tests for f_socket.

Bugfix: Problems exposed by unit tests.

Only call strncpy() if socket->name is defined.

Only set socket->id to -1 for f_socket_close_fast_e.
When received EINTR, do set socket->id to -1 for f_socket_close_fast_e.

Be consistent and make length parameter optional for the socket read and write functions.

Bugfix: Remove extra zero from hex-digit.

This extra digit results in an always true boolean logic.

Bugfix: Combining and Width detection for utf8 are not properly printing.

The wrong data is being passed to utf8_print_combining_or_width().
Change the behavior to send the correct string to the function.
Move the error printing to a single function and use this function in all such cases.

Cleanup: Incorrect function documented in comment.

Cleanup: Rename bytecode to bytesequence.

The term "bytecode" already exists and is used for a slighty different purpoe (representing compiled or partially compiled data).
This is a different context.
To avoid using the term improperly, switch to a more proper term "bytesequence" (as one word).
A byte sequence is a term representing a sequence of bytes.
This is more specific than binary and effectively emphasis that this is in regards to bytes.
Avoiding the term binary, however correct or not the term may be, helps avoid confusion due to "binary" and "text" data being considered two separate things.

Cleanup: Use macro_f_string_static_t_initialize2() with macro_f_string_static_t_initialize().

Using macro_f_string_static_t_initialize2() was the old way and is now deemed incorrect.
The macro_f_string_static_t_initialize2() applies the length parameter to both the used and size.
For static strings the size is always 0 because nothing is dynamically allocated.
Therefore, using macro_f_string_static_t_initialize2() for static string initialization is incorrect.

Update: Tweak endiannes for f_utf_char_t.

I continue to forget that the f_utf_char_t is a big-endian format regardless of the host endiannes.
I then end up comparing the endiannes logic to normal operations and find discrepancies.
I waste a good bit of time to ultimately realize that the f_utf_char_t is not in host byte order.

Update the comments to better represent this situation.
I also noticed that the big endian bitwise operations are going in the wrong directory.
I could be wrong, but I think I need to do a left shift rather than a right shift.
Or perhaps, this only needs to be done on a big-endian system?
I need to test this logic on a big endian system.

Feature: Add missing functionality allowing the utf8 program to convert back to binary data with invalid codepoints.

Even when there are invalid codepoints produced, it should be possible to convert the entire output back to the original data.
This is possible because the codepoint output by default still prints the invalid data as a hex-digit representing up to 4 bytes of data.
The combining and width parameters are also supported.

Update: Use F_utf_not instead of F_utf and other resulting changes.

The F_utf_not is semantically more correct than F_utf when returning an error for an invalid UTF-8 sequence.
Use F_utf_fragment where appropriate as well.

Updating all of the appropriate comments revealed some documentation and code structure problems in the fss projects.
These are cleaned up as well.

Update: Project f_utf.

While investigating the utf8 program, I looked into the f_utf project and found that it is still very much lacking.
At some point in the process of me writing this, the Unicode 14 was released.
I started the process of updating parts of the code and have made it as far as Gujarati with this commit.

Remove unused functions.
Add new functions for detecting if something is a superscript or a subscript.

Update the comments in the private functions to make it explicitly clear when a particular private function expects that only characters of width 2 or greater are provided.

There are some "todo" comments that need to be addressed before the stable release.
I'm expecting another release candidate at this point and so I am pushing off some of the Unicode updates onto after the next release candidate.

I noticed that the unit tests for f_utf only address the structures.
While this is disappointing it does save me the effort of having to write more unit tests for the newly added functions.

Regression: The utf8 program is only returning space when converting file from codepoint.

The non-space characters are always being defined as invalid.

Cleanup: Remove no longer being used 'u' from macros.

Cleanup: Stale code, improve usage, replace macros.

The primary focus of this commit is to remove stale code exposed by compilers.
This pass I used clang with -Wall.

Fixed some usage cases where the variables can be replaced with other variables.

I happened to notice some macros didn't need to exist and added the appropriate methods.
I did not search for other cases like this.
I only fixed what happened to be in front of me at the time.

Security: Add missing NULL at the end of string.

I was seeing "-Wno-missing-bracess" and "-Wno-logical-op-parenthese".
This looks exactly like invalid sizes.
I could not find the code that misplaces the NULL but in the process I found a different place where a NULL is in fact missing.
This adds the missing NULL.
I guess if one looks hard enough, then they will find what they are looking for.

It turns out that my original problem is actually two typos in a configuration file.

Update: Add unit tests for f_serialize.

Update: Rewrite the f_serialize functions.

The code is outdated and needs to be updated with the current practices.
I remember being uncertain on what to name several of these functions.
I didn't want an f_unserialize function because that would require a separate project (even if the naming makes sense).
Perhaps I may do that in the future, but for now just use the words "from" and "to".

Security: The realpath() calls malloc() and free() is not called (memory leak).

I change the code and didn't realize that realpath() conditionally calls malloc().
When I change th code to pass a variable initialized to 0, I ended up triggering realpath() to call malloc().
This results in a memory leak.

Instead, pass a statically allocated array.

Cleanup: Replace the number 0 with the word zero.

Cleanup: Rename pictures that have logo in the name twice.

These should be named icon not logo.

Update: Specifications.

Started using IKI format in the specification files.
Made changes and performed fixes as I noticed them while copying the specifications to the website.

Bugfix: The iki_read program is not handling verbosity correctly.

The newline should be printed at the end of the program unless in quiet mode.
This fails for two reasons:
1) The conditional checks before printing are wrong.
2) The quiet parameter is at the wrong position resulting in it being mixed up with the "no color" parameter.

Feature: The iki_read program should support wrapping a variable value.

One of the original design intentions of the IKI standard is to allow for substitution.
That substitution includes wrapping text with something like HTML markup.
The current design of iki_read falls short here.

While the substitution can be performed, the wrapping while preserving the existing value is not performed.
For example consider the following:
  emphasis:"Some message."

This should be substituted with the HTML5 "<em>" tag.
The substitute parameter requires knowing the value.
The replace parameter also requires knowing the value.

The emphasis HTML5 markup needs to be prepended and appended without having to know every single value.

To solve this, the -W/--wrap option is now available.
This is a 3 parameter option that acts similar to the -r/--replace parameter.
However, it will instead accept a "before" and "after" representing the before and after strings.
Either the before or after string may be an empty string.

The design of this feature re-utilizes existing structures.
These structures have context in their names that do not match "before" and "after".
This can be confusing, but this is considered an inconvenince at this time.
The goal is to keep the changes simple if at all possible with a stable release around the corner.
I also do now know what words to use to share between the different types without creating a new one to make such a change.

This feature is necessesary to ensure completeness with the original intent and design of both the IKI standard and the iki_read program.

Bugfix: Previous commit overlooked the counter resulting in some replacements not being processed.

Oops! This is what I get for rushing this out with little testing and review.

The problem here is that the "+3" is for the 3 parameter option "--substitute".
The 2 parameter option "--replace" must instead use "+2".

Feature: The iki_read program should support a more generalized substitution process called "replace".

In the distant past I mixed up having only two or three substitution parameters.
After getting confused, I decided to just have a 3 argument substitution.
The three argument substitution only substitutes if both the variable name and the variable value match.

This is great but it doesn't follow the completeness theorem.
The iki_read should also handle the general case in addition to the specific case.

Provide a two argument substitution called "replace" that handles the more general case.
When any variable name matches the given replace parameter, then the variable value is replaced for all matching variable names regardless of the existing variable value.

Fix small mistakes in the IKI specification.
I needed to refer to the "variable value" with this change and "variable variable" is simply not the correct way.
Use "variable names" rather than "object names" to be more consistent and clear in this regard.

Update: Add cmocka specific environment variables to the testfiles.

These environment variables are commented out by default.
The "define" "settings" Object defines the environment variable.
The "environment" "settings" Object exposes that environment variable to any called programs.

Update: Add unit tests for fll_status_string.

Bugfix: Fix problems exposed by unit tests.

Update: Add unit tests for f_status_string.

Bugfix: Problems exposed by unit tests and do some relevant code style clean up.

Update: Unit tests, fixing minor mistakes and add missing tests.

While these tests are not expected to be thorough at this time, there are several checks that should still be and can easily be made.

Some of the test files have incorrect comments.

Order test functions alphabetically.

Bugfix: Add missing return value handling in f_fss.

Update: Add unit tests for f_limit.

Update: The f_limit project is out of date.

Writing unit tests revealed that the f_limit project does not operate like the latest code.
Restructure and rewrite f_limit to be consistent with the latest practices and designs in the rest of the project.

Other projects utilizing this are also updated.

Bugfix: Incorrect and missing initializer macros in f_fss.