Update: The standard program setup should explicitly unblock all signals other than the default.

The fll_program_standard_setup() function blocks certain signals.
Do not assume all other signals are unblocked.
Explicitly unblock all other signals.

Bugfix: Parameter after either the -N or -W is being processed.

These should not expect an argument and are configured to do so.
Set the expected arguments to 0.

The command:
  byte_dump /bin/bash -N --help

Should now print help.

Feature: Add missing signal functions f_signal_action(), f_signal_pause(), and f_signal_suspend().

The f_signal_pause() just calls pause() and returns F_none.
The return value of pause() is meaningless if I am understanding the man pages correctly.
It should always return -1 and then sets errno despite this not being an actual error.

Regression: Incomplete IKI variable expansion when an extra ':' is found.

The commit feb9184911c738b66c4181f58527cbfd94cdb25c introduced the use of F_next to restart the outer most loop.

I missed a single case where status should be set to F_next.
The problematic code is setting the status to F_false.

Security: Invalid read when processing not condition minimum value.

The right side of the or condition should only perform the minimum check when j is within the range of the array.

Regression: Pre-allocate is using the wrong array.

I mixed up the arrays, the code managed to compile, and the error went unnoticed.

The problem is introduced by this commit: 99e025d4b5b1110733e4049416d848f8bc632fb3.

Cleanup: Remove bad path part from string in testfiles.

The 'parameter:' is not valid and does nothing here.
This is likely the result of a copy and paste that didn't fully delete the parameter IKI variable.

Bugfix: Guarantee that the child processes are terminated.

The terminate signal is not being received for unknown reasons.
The signals are unblocked for the child process.
And yet, it continues to block.

The final part of the terminate due to signal is to forcibly terminate (sending the kill signal).
This is now happening for child processes.

Sending the kill signal allieviates the problem where the controller program will not terminate.
This fix causes the reduces the severity of the problem such that the terminate should still terminate.
However, this fix does not solve the problem with the terminate signal not being received by a child process that is not blocking the signal as far as I can tell.

Bugfix: The copy operation doesn't work properly with trailing slashes.

The generated path might not be valid when a trailing slash is supplied on the source or the destination.
Increase the static array size to accommodate at least 2 added separators.
Only add the separators if one does not already exist.

This does not attempt to clean up the code if there are multiple separators beyond the first.
(That is to say "copy a/// b///" will not become "copy a/ b/".)

Cleanup: Tweak the delimits behavior to re-use the existing array to reduce memory overhead.

Bugfix: IKI substitution is incorrectly applied.

The function controller_rule_action_read_delimit_apply() is remapping the array and applies the delimits.
Another function is then applying the same delimits again, but against the remapped buffer.
This results in the delimits being applied to the wrong locations in the string.

Get rid of the controller_rule_action_read_delimit_apply().
The use of this function results in an incorrect string when printing validation.

Thoroughly clear the entire IKI data when processing the actions.

Security: Invalid reads on NULL terminated strings with a max width greater than 1.

The max width cannot be reliably trusted in NULL terminated strings.
Check if each character in the expected max width is not terminated early due to a NULL.
If it is, then adjust the max width.

Feature: The fake program should support the "current" parameter.

This is the compliment to the "top" variable parameter.

The current working directory, also known as the present working directory, should be an IKI variable.

Use the f_string_dynamic_append_assure() rather than f_string_dynamic_append() to only add the trailing slash if it is not already present.

Update the documentation.

Bugfix: Text is being incorrectly stripped out.

Remove old code that is reset the used buffer when it should not be.

Update: Reduce number of allocations by pre-determining size when easily possible.

There are several cases where the expected size can be calculated.
Pre-allocated the expected size to reduce reallocation and improve performance by reducing memory overhead.

I also noticed that the comment is no longer correct and that the not quoted check could be reversed.
Changing this simplified the code, slightly.

Bugfix: Reserved parameter IKI expansion is not adding spaces and the "top" reserved parameter should always end in a slash.

The IKI expansion on reserved parameters, such as "parameter:"fakefile"", should include spaces as appropriate.
For example, given a call to "fake -f my_fakefile", the parameter:"fakefile" should expand into "-f my_fakefile" but is instead expanding into "-fmy_fakefile".

For security reasons, the expanded paths, such as parameter:"top", should always have a trailing slash.
Consider "rm -Rf parameter:"top"tmp" vs "rm -Rf parameter:"top"/tmp".
On the left side, if parameter:"top" resolves into an empty string, then the command is: "rm -Rf tmp".
On the right side, if parameter:"top" resolves into an empty string, then the command is: "rm -Rf /tmp".
The right side would end up destroying a path outside of the project root, such as "/tmp"!

Feature: The fake program should support the "top" parameter.

The "top" is already available but it is not exposed through IKI variable parameter replacement.

Update the documentation, including adding missing documentation about "return".

Remove unused "return:option" and "return:value" parameter (this is not used because it is not valid).

Bugfix: IKI variable substitution results in incorrect parameter structure for reserved parameters.

The commit 9ebfcc071f11f82b435cfa0f73e4961912571c38 didn't address this case.

There is an existing "separate = F_true;" that suggest that I was planning on working on this.
I probably overlooked and forgot about this block.

Do not increment the parameters array and instead prepend a single space only when needed.

Regression: An if-condition followed by a completed if-condition is not being processed.

The commit 4ddc0910eb872bf242895e1e5e804f50f671901d did not address this use case.

Example:
  if == x x
    print x is x
  if == y y
    print y is y

Cleanup: Documentation in regards to the newly added +E/++Error and the changes from +q to +Q.

Update: Add support for +E/++error, change '+q' to '+Q', and fix some past tense words.

Selecting a quiet mode that still prints errors is very helpful in embedded fakefiles inside of controller rules.

I noticed that almost all of the verbosity related parameters are upper case except for the "quiet" parameter.
Change the "quiet" parameter from "+q" to "+Q".

I noticed some words in the past tense.
The goal is to use present tense.
Using past tense a habit I hope to get out of when programming.

Bugfix: Error verbosity is not being preserved.

Update: Testfiles now need to use the "exist" rather than "exists".

Bugfix: IKI variable substitutionr results in incorrect parameter structure.

The commit d94d5337c44d7b2d6f3ed183e8d2c94b4bdad1f6 exposed an existing bug.

There parameters are not always expanding properly resulting in the parameter being empty, having the incorrect order, or being improperly merged with another parameter.
Change the array resize behavior to resize after incrementing the arguments rather than before.
Detect and handle special cases where separation needs to be applied and when separation does not need to be applied.
Remove random space that is being accidentally appended when printing arguments (probably an accident from a previous commit).

The commit 6012208c61e616a5d31d285ba8873f55b987bf70 did not fully solve the problems it attempted to solve.
Handle additional cases, such as:

  settings:
    parameter a iki <-assure_space unassure_space->
    parameter b value

  main:

    if exist 'parameter:"a"'
      print yes (parameter:"a")
    else
      print no (parameter:"a")

    print 0 parameter:"a"
    print 1 parameter:"b"
    print 2 parameter:"b".
    print 3 "parameter:"b""
    print 4 "parameter:"b\" between parameter:"b""
    print 5 'begin parameter:"a" middle parameter:"a" end'
    print 6 "begin parameter:"a\" middle parameter:"a\" end"
    print 7 begin parameter:"a" middle parameter:"a" end
    print 8 begin parameter:"a"! middle parameter:"a"@parameter:"a" end

Should produce results like:
  no (iki <-assure_space unassure_space->)
  0 iki <-assure_space unassure_space->
  1 value
  2 value.
  3 value
  4 value between value
  5 begin iki <-assure_space unassure_space-> middle iki <-assure_space unassure_space-> end
  6 begin iki <-assure_space unassure_space-> middle iki <-assure_space unassure_space-> end
  7 begin iki <-assure_space unassure_space-> middle iki <-assure_space unassure_space-> end
  8 begin iki <-assure_space unassure_space->! middle iki <-assure_space unassure_space->@iki <-assure_space unassure_space-> end

Move the relevant arguments and iki data into a shared cache to save memory consumption.
Rename path_cache to cache_path for consistency.

Bugfix: Single quotes are not being properly detected in FSS Extended Read functions.

A copy and paste mistake where f_fss_quote_type_double_e when instead f_fss_quote_type_single_e should be used resulted in the quote being set to NULL.

Also do some code clean up.

Update: Change "exists" to "exist" in fakefile syntax.

The use of "exists" is grammatically correct and the use of "exist" is grammatically incorrect.
This is not in English grammar.
The practices of this project are to focus on using "s" strictly for plural.
The practices of this project are to use simple or base words more often.

The area in which proper grammar is allowed is when interacting with the user rather than with code.
A project like Fake has a target user who is a programmer.
This is a grey area.

The project is already using "if define" rather than "if defined".
For the purpose of keeping a consistent design, I am favoring "exist" over "exists" for this grey area.
Another bonus is that "exist" is shorter than "exists" (however trivial).

Update: Strip out NULL characters after applying delimits.

Once a rule is read and the IKI data is parsed, apply the IKI delimits.
NULL characters replace the delimits.
Strip out all NULL characters from the string after the delimits are applied.

Update: Replace Unicode Terminate escape sequence with Non-printing escape sequence.

Use "\!" instead of "\U-".
It is simpler and has the convenience of not being part of an IKI variable.

Update the alphabetic ordering.

The documentation is missing context IKI variable.
Describe all supported context IKI variables.

Bugfix: Delimits are not being applied for IKI variables.

The controller program is not applying the delimits for would-be-valid IKI variables.
This becomes a huge problem when these would-be-valid IKI variables are passed to the fake program.
If the would-be-valid IKI variables are properly delimited, then the fake program would see them as valid IKI variables.

Bugfix: IKI variables are incorrectly being processed when there is a non-IKI IKI-like string.

The delimits, after the first, are not being processed.

This is the result of an accidental double increment.
When checking against a possible IKI variable and it is determined that the string cannot be an IKI variable, a double increment occurs.
What is happening is that the break statement only breaks out of the immediate loop.
There is a second loop that does an increment is not being broken out of.

Utilize the separator_found boolean to determine whether or not to perform the additional break.

Cleanup: Fix alphabetic ordering.

Some of the color structures cannot be alphabetically ordered.
These can be, so make it so.

Security: Invalid read for formatted printing using partial ranges on a string.

If the start position is greater than the used buffer, then an invalid read occurs.
Properly verify that the start position is not greater than or equal to the used length of the string.

Feature: Add support to the "print" operation for escape sequences just like the "write" operation has.

The print now prints raw data.

Fix documentation comments.

Cleanup: Converted type is actually uint32_t rather than f_utf_char_t.

The f_utf_char_t is supposed to be an uint32_t so this is not a problem.

The intent and design of this, however, is that f_utf_char_t is a special case representing the character as a string rather than as a digit.
The f_utf_char_t is stored as a 4-byte integer to store each byte representing a character.

The uint32_t is simply a straight up 4-byte integer.

This is the numeric value of the code point rather than the representation as a string.
This is an important semantic difference.

Feature: The featureless make program now supports the "write" operation.

This is an oversight on my part.
There should be an operation to write to a file.

There are two forms of this new "write" operation.
1) Truncate a file (deletes all data within a file).
2) Append to a file.

A file is created if it does not already exist in both cases.

The "write" operation supports some standard escape sequences as well as some non-standard ones.

Standard Escape Sequences:
- "\f": Form Feed.
- "\n": New Line.
- "\r": Carriage Return.
- "\t": Tab.
- "\v": Vertical Tab.
- "\\": Backslash Character (may require additional slashes in certain circumstances.)
- "\0": NULL Character.

Non-Standard Escape Sequences:
- "\U+": Unicode Sequence (followed by a valid Unicode sequence with a minimum 4 hexidecimal digits and a maximum of 6 hexidecimal digits).
- "\U-": Terminate a Unicode Sequence, allowing for "\U+000A\U-5" to be equivalent to "\n5".

Cleanup: Fix documentation comments.

Bugfix: Incorrect information is printed on certain errors.

Remove unused line variable.

The f_fss_count_lines() function appends to the calculated length variable.
The number is not being reset.
This results in each iteration adding to the previous:
  Line number 1, count = 1.
  Line number 2, count = 3.
  Line number 3, count = 6.
  etc...

Reset the line number on each pass of the loop to get the correct line number.

An error message is printing "1" when it should be printing "2".

The "%Q" should be used instead of "%s" for the static string.

Replace "parameter" with "Content" to be consistent with other error messages.

Cleanup: Update controller examples.

Bugfix: "State is now ..." should not be printed when quiet is passed.

Bugfix: Empty strings improperly pass validation checks.

An operation such as the following:
  if exists 'define:"does_not_exist"'

Results in an empty string.

The empty string is passing the existence check.
Empty strings should fail existence checks in this case.

Handle all such cases that I am able to quickly find.

Refactor: "if defined" and "if not defined" to be easier to use in fake program.

Using "if not defined parameter work" can be confusing.
Using "if not parameter work" is shorter and easier to understand.

Using "if defined environment PATH" can be very confusing.
Using "if define PATH" is shorter and a lot easier to understand.

Break apart the "if defined" (and "if not defined") logic into two operations:
1) "if define" (and "if not define").
2) "if parameter" (and "if not parameter").

This makes the behavior easier to understand as it directly maps to the "defined" and "parameter" settings.

Update: Ensure first if block is initialized to operate.

Cleanup: Remove unnecessary includes in fake program.

Cleanup: Fix spelling mistake, 'tread' should be 'treat'.

Update: Use "settings" instead of "setting" for better consistency between fake program and controller program.

Featureless Make is using "settings" and the Controller program is using "setting".
Fix this inconsistency.
The term "settings" sounds more accurate than "setting".

Update: Restrict environment to PATH and LD_LIBRARY_PATH by default.

Change all of the setting files and fakefiles to restrict the environment variables.
Only PATH and LD_LIBRARY_PATH are exposed so that custom build environments can easily be used by default.

Feature: The controller program should expose the "define" and "parameter" at the Entry and Exit level.

The "define" and "parameter" should be made available in the Entry and Exit files.
This allows for passing data to all Rules.

Update documentation.

Security: Invalid read when using -s/--settings in fake program.

The Featureless Make -s/--settings parameter handling code has a typoe where the wrong enumeration is used.
This results in an invalid read.

Update: Make environment variable handling design consistent between fake and controller programs.

The Featureless Make system does not have a way of passing all environment variables.
Add a flag to designate whether or not environments is empty because it is not defined or is empty because it is defined as empty just like the controller program does.

This then allows for more flexible control over whether or not the environment variable security.

Update the example setting files and fakefiles to expose PATH and LD_LIBRARY_PATH by default.

Update: Further reduce memory allocation pressure by increasing default small allocation.

Double the default small allocation size from 4 to 8.
This accepts the compromise that this will increase the amount of memory used in certain cases.

Feature: Add missing function f_environment_get_all().

A get all environment variables function should exist.
The POSIX/libc standards do not seem to provide one.

Utilize the "environ" variable to load all of the environment variables into a string map array.

Security: Environment value has invalid read.

The string may not be allocated.
Check that the string.used is not 0 but if it is then pass an empty string.

Bugfix: Condition blocks are still being processed when they should be skipped.

Re-design the block code to simplify the logic and make the code more readable.
This is only a partial re-design.
I did not perform an extensive review.
I am considering writing some runtime/program tests to better catch problems and regressions.

Update: The "engine" rule setting should support parameters.

Cleanup: Remove unused task feature.

This functionality did not make the cut for the 0.6.x stable release series.
I may revisit this in the future.

Update: Change default controller settings path to './'.

This feels more natural to me now that I am writing and testing the controller settings.
I originally wanted the default to be self contained.
If I want to run in a sub-directory such as 'controller/', then just pass '-s controller'.

Refactor: Rename "script" setting to "engine".

The scripting engine is now called "engine".
This fixes ambiguity issues between the "script" action and the scripting engine.
This makes the code and configuration files easier to read and understand.

Update: Change execute error code handling to better accommodate standard GNU Bash return codes.

This introduces the status codes F_call and F_call_not as part of the required changes.
This also introduces F_yes, F_yes_not, F_no, and F_no_not.

Improve the wording of some of the error messages.

Cleanup: Fix word mistake.

Feature: The fake progam is supposed to support a piped fakefile.

I thought I implemented this already.
I just tried to use it and found it that I had not implemented.
This feature is supposed to be in the stable release.

Update: Next minor version (0.6.0).

Update: Improve design in f_conversion to be safer when handling variables allowed to be replaced.

The constants are allowed (and encouraged) to be changed as desired by some developer or distributor.
This means constant strings like f_string_ascii_1_s could, in theory, be any length.

Change the do..while loops into normal while loops.
Change the while loop using sizeof(f_char_t) to instead use the actual constant string structure(via a pointer).

This situations was identified by the -fanalyzer functionality of GCC-12.1.
The -fanalyzer from earlier GCC versions, such as GCC 11, did not identify this.

The sizeof(f_char_t) is not strictly needed for the fwrite_unlocked() calls because they are wrapped in a loop.
The sizeof(f_char_t) can be assumed to be 1 in general and even if it is greater than 1, the loop will still ensure success.
Removing the sizeof(f_char_t) simplifies the design.

Bugfix: Signal code is not being set when accepted signal is received.

Update: Add additional checks just in case execution is attempted with both program name and arguments have no data.

Cleaup: Spelling mistake in debugging documentation.

Update: Example bootstrap script now supports building all programs.

Looping over all programs, building them, and installing them is a very common process.
Adding support for this to the example bootstrap script should save me some time and effort.

Also change the separate clean and build commands into a single command using the rebuild command.

Update: Add note about ulimit privileges potentially causes failure of example controller rules.

Update: Add the last of the unit tests for f_thread.

This implements the last of the intended unit tests for f_thread.

Bugfix: Problems exposed by f_thread unit tests.

Notable fixes:
- Rename f_thread_semaphore_file_create() to f_thread_semaphore_file_open().
- Rename f_thread_semaphore_file_delete() to f_thread_semaphore_file_close().
- Rename f_thread_semaphore_file_destroy() to f_thread_semaphore_file_delete().
- Have f_thread_semaphore_file_open() accept a double pointer for semaphore because sem_open() returns a pointer.
- Initializer f_thread_semaphore_t_initialize is on a union which is initialized differently from a normal digit.

Progress: Add more unit tests for f_thread.

Bugfix: Problems exposed by f_thread unit tests.

Update: The featureless make should default to 'make' mode.

This makes the fake program closer to how make operations.
With this changed, just type 'fake' and it operates as if 'fake make' was the command given.

Progress: Add more unit tests for f_thread.

Bugfix: Problems exposed by f_thread unit tests.

Progress: Add unit tests for f_thread.

There is still a long way to go but this is a good start.

Ideally, the f_thread will be the last project I write unit tests before the stable release is made.

Bugfix: Problems and clean ups exposed when writing f_thread unit tests.

This in particular extracts the structure related functions into separate files to better follow the functional oriented programming practice.

Cleanup: Add missing new line.

Update: Add the last of the planned f_utf unit tests.

Implement the white space unit tests.

Update: White space function changes.

Make the is white space functions accept "strict" to be more consistent with how other functions operation.
For the next development release I want to consider separate functions to avoid passing a boolean as a parameter to do this (for performance reasons).

This changes behavior in some cases and if I did something wrong then there will be a regression.
Look out for white space regressions specifically in the FSS programs.

Update: Use "decimal" instead of "digit".

The unit tests are failing because the function no longer exists.
The use if "digit" is probably the result of an over zealous refactor.
Rename the affected functions back to "decimal".

Update: Implement more f_utf unit tests.

Only the is white space tests are yet to be implemented.

Bugfix: Problems in f_utf exposed by unit tests.

The is alphabetic needs to perform the is valid check because its default catch-all is returning F_true.
Ideally at some point (probably distant point) in the future, the literal codes for alphabetic will be matched rather than calling all of the other functions.
In this situation the is valid check can be removed.

Several of the is digit test value assignments are not checking if the value (the pointer) is NULL.

Some of the is word sequences are incorrect.

Add missing f_utf_character_is_alphabetic_numeric().

Fix function name for f_utf_character_is_control_format().

Several is word checks for f_utf_char_t are improperly comparing the entire sequence to an ASCII value when only the first byte should be compared.

Update: Finish f_utf unit tests for digits.

This does not handle the alphabetic variation of the digit unit tests.
There are still several other (non-digit) unit tests that I plan to get to.

Update: The fake program should check file existence when clean is combined with another command like build or make.

When the make or build command is specified after a clean command, the clean command should do an appropriate file dependency check.
This acts as a safety measure such that if the make or build command could not normally be run due to the missing required files, then the clean operation should not be run.

Rename a related function to a shorter name.

Bugfix: The fss_identify needs the latest version of f_utf_is_digit().

Bugfix: Entry file not found when --settings is used.

The incorrect range is being used on the wrong variable.

Progress: Continue on f_utf digits.

This also fixes problems observed in running the unit tests.

Bugfix: The < 0xc2 test is supposed to be against the first byte rather than the second.

Bugfix: A typo resulting in treating < 0xc3 as invalid UTF-8 when it is instead < 0xc2.

This is for 2-width characters, such as: '²' (U+00B2) and '½' (U+00BD).
These character should not be treated as invalid.

I have not yet investigated to see if I need to make other corrections.
This is just an obvious mistake that I found and immediately fixed.

Progress: f_utf unit tests and make significant change Unicode digit/decimal functions.

The controller program is using f_utf_is_alphabetic_decimal().
The previous functionality of that function is now handled by f_utf_is_alphabetic_digit().

I reconsidered some of the design I implemented in the previous commit (e696e3941592c6910f2f8ecc87a698d4f618c3b4).
The design of reading the value for the variable "value" and then saving to it is too much complexity.
Simplify the design and just expect the caller to read the "value" and decide if it is or is not in range.

Get rid of the "*_is_decimal()" functions.
The "*_is_digit()" functions work like the "*_is_decimal()" functions did.
I am avoiding the term "decimal" because it refers to base-10.
The term "digit" is a bit more general.
The only downside is that fractions might fall under "digit" (really they are two digits), which this function currently does not handle.
The "*_is_numeric()" functions will recognize fractions.

I didn't get as far as I wanted to.
The number of Unicode values to assign has worn me down.
The tests processing is not complete and I haven't gone back and done my normal review.

I tried to keep the "value" as small as possible, but unsurprisingly some language out there has a digit that represents billions.
I am forced to use a 64-bit data type for this.

Update: The f_utf project regarding digits and perform other clean ups follow up.

I had not gotten around to testing the programs after the previous commit.
I did not get to writing the function f_utf_is_alphabetic_digit() (and then forgot about this important part).

The controller program is using f_utf_is_alphabetic_decimal().
The previous functionality of that function is now handled by f_utf_is_alphabetic_digit().

Update: The f_utf project regarding digits and perform other clean ups.

Redesign the digit and decimal behavior.
The is digit functions now refers to base-10 but does not attempt to return the identified digit.
The is decimal functions now refers to base-10 and supports providing the identified digit.
The is decimal functions also support other base units than just base-10.

The alphabetic digit/numeric functions now also have a alphebetic decimal function.

Clean up more places in the code using "sequence" rather than "character" or "characters".

Functions like f_utf_character_is_alpha_digit() are now like f_utf_character_is_alphabetic_digit().

Add related unit tests.
The is digit functions have unit tests that tests if the digit returned is correct.
I have not reviewed all of the "numeric" Unicode digits to confirm/deny that my is decimal functions are complete.

I observed what looks like bugs in the alphabetic functions.
In these cases the final return statement is returning F_false when they instead should be returning F_true.

There are minor corrections in documentation.

Update: Use a regular int instead of uint8_t for counting digit in conversion function.

The calculations are based on data.width, which is an int.
Make the code more consistent and less error prone by matching the data top.

Security: Floating point exception due to incorrect number type used in conversion function.

The power is being used as the entire value.
To do this it must be capable of holding the entire supported digits of f_number_unsigned_t.
Using int results in a floating point exception.

Bugfix: Add missing endianness check to f_convesion.

This just adds the inverse shift on the assumption that the original code is correct and is for little-endian.

Bugfix: Uppercase 'T' needs to be supported.

I incorrectly used lower case 't' in both condition blocks when I need to check for both lower and upper.

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.