Feature: Add fl_path_clean() for stripping out NULLs and redundant slashes.

Update: The fl_path_canonical() should handle the NULL cases.

Allow for NULL within the strings.
Update the processing code and add some unit tests.

The documentation comment about canonical->used being reset to 0 before processing is incorrect and is now removed.

Update: Use the pre-defined typedef structure style for the main program type.

Make sure that the typedef is defined early for a later defined type.
This allows for circular use of the main, such as with callbacks.

This is being done across all of my programs.

Cleanup: Fix function alphabetic ordering in unit tests.

Several of the test files have the parameter_checking function out of order.
I also happened to notice that the work test in some cases are also out of order.

This out of order is likely a problem caused by early day mass test generation.

Update: use directory back and current strings.

These should be used rather than the inline strings.

Feature: Add several reverse string search functions.

These "_back" functions work based on the stop position of the range.

Update: Add missing constant qualifiers and update function comments.

Some functions are missing the standard constant qualifier on the pointer parameters.

Improve grammar in some of the documentation comments.

Feature: Add new function fl_directory_empty().

Simplify the process of determining if the directory is empty.
The entire list of directories do not need to be processed in this case.
Only check if the first child in the directory exists.

Cleanup: Typo in documentation comments and add missing status codes to fl_directory_list().

Bugfix: Add missing disable define for private_fll_execute_path_arguments_fixate().

Cleanup: private_fl_payload_header_map_multis() needs _di_fl_fss_payload_header_map_ instead of _di_fl_fss_payload_header_maps_.

Cleanup: Remove extra "_map" from private function name.

Bugfix: The IKI and EKI specifications do not require escaping inside of Content.

This is an oops on my part.
I thought I was correcting something that I missed and I ended up causing a problem.
I think this problem was introduced in this commit: e9621b09db34cfd9ac6264c77068c34afa5bfb17.

Bugfix: Specification files need proper escaping for example code.

The IKI/EKI need to be properly escaped inside the example so that when the specification file itself is processed, the examples do not get substituted.

The examples that have what would be valid FSS Basic Lists also need to be escaped for the same reason.

Cleanup: Comments in examples in specifications must be escaped.

These comments are intended to be printed so that they can be shown as an example.
Escape them.

Update: Next micro version (0.7.1).

The following are the commands that I ran to make this change:
  # find build/ level_? specifications/ documents/ licenses/ -type f -exec sed -i -e 's|0\.7\.0|0.7.1|g' '{}' ';'
  # find build/ level_? specifications/ documents/ licenses/ -type f -exec sed -i -e 's|^version_micro 0|version_micro 1|g' '{}' ';'
  # find level_3/ -name *.h -exec sed -i -e 's|_program_version_micro_s F_string_ascii_0_s|_program_version_micro_s F_string_ascii_1_s|g' '{}' ';'
  # find level_3/ -name *.h -exec sed -i -e 's|_program_version_micro_s_length F_string_ascii_0_s_length|_program_version_micro_s_length F_string_ascii_1_s_length|g' '{}' ';'

Bugfix: Runtime tests are missing the main programs.

Add the appropriate programs to the `testfile`.
I probably overlooked this because the programs likely already exist in my PATH.

Update: The eki_read runtime tests.

I review a number of the tests but not all of them.
They look correct as far as I can tell.

Update: Finish fixing iki_read for runtime tests.

The iki_read must still print the unmatched variables.

The `iki_read_process_line()` is indeed still valid to have.

The total should still be printed even when there is no data or the start range is out of range.
This ensures that a 0 is printed in these situations.

There may or may not be eki_read fixes needed but runtime tests do not exist for that yet.
A follow up commit shall address this.

Update: Clarify precedence of the --select for IKI Read.

The `--select` parameter is processed after the `--line` parameter.

Update: Clarify precedence of the --name, --at, and --line for IKI Read.

Add description of the order of operations, or precedence, for the `--name`, `--at`, and the `--line` parameters.

Progress: Continue fixing iki_read (and eki_read) for runtime tests.

Minor changes that I started working on before vacation.
I forgot to write the notes and make a commit.

I appear to have changed some of the name parameter handling.
There is a clear bug where I mistakingly used the wrong array for a range check in a loop.

Use the state status rather than a custom status for managing the status.

Some of the print parameters are using the output.to directly rather than the print variable passed to the function.

Correct some of the function documentation.

there are still 165 test failures that I need to review.

Progress: Continue fixing iki_read (and eki_read) for runtime tests.

Some of the non-whole (as in the `--whole` parameter) runtime tests are actually invalid.
Update them with the correct results.
I manually reviewed most of these and found that the update is more correct.

I will back port these tests and fix the 0.6.x branch accordingly.

Progress: Continue fixing iki_read (and eki_read).

This addresses some of the `--total` processing.
It looks like I had not completed a lot of that code.
Much of that is added back.

I also noticed that I need to keep tabs on the `--select` parameter.
I will need tests for this and I may have missed some logic cases.
My first objective is to just get the 0.6.x runtime tests to work in 0.7.x.
(Or, I need to fix the 0.6.x tests to be correct.)

The expected next steps:
- Review and address what is left for IKI Read that is incorrect.
- For anything identified in the 0.6.x runtime tests that is invalid shall be fixed in 0.6.x.
- Update the EKI Read with all of the changes from IKI Read.
- Make a copy of the IKI Read runtime tests and see how EKI Read passes or fails.
- Address unexpected failures.
- Fix the tests for expected failures, which would be relating to having multiple Vocabularies/Objects.
- Write all of the new runtime tests for EKI Read.
- Make sure everything all passes.
- I probably need to update the help and describe the order of operations for some parameters.

Progress: Continue fixing iki_read (and eki_read).

I am using the 0.6.x iki_read runtime tests files to help identify problems.
This will also help identify problems with the 0.6.x iki_read.
(Of which I believe that there are some.)

This has a huge focus on addressing the `--line` and `--total`.
There are still known problems to solve, such as:
```
iki_read tests/runtime/iki/source/test-0000-basic.iki -L -a 1 -n hello
iki_read tests/runtime/iki/source/test-0000-basic.iki -L -a 1 -n hello -t
```

The EKI code is being partially updated while I am working on the IKI code.
However, big parts of it that are outdated are being left alone until I have IKI working correctly.
I will then update EKI accordingly and write the appropriate runtime tests.

Progress: Continue fixing iki_read (and eki_read).

There is overlap between how `--at` and `--line` work when not using `--whole`.
Do not treat using both as an error.
Instead, just have `--at` be the higher priority and then perform `--line`.
This results in a `--line` that can only potentially print something if it has a value of 0.

This is only the case for `--object`.
Both the `--content` and the `--literal` may potentially have multiple lines.

I removed the existing `--line` logic.
I will rewrite the logic for determining the number of lines when printing the `--literal` or the `--content`.
There will also need to be another file that haas multiple iki lines.

I was adding the line break behavior to break out of the loop when the line matches.
Much of that, but not all of that, has been removed until I come back to write the new logic.

The runtime tests are not yet updated.

Progress: Continue fixing iki_read (and eki_read).

This brings in the recently added 0.6.x runtime tests as-is.

Address some of the failures, such as the `--total` parameter.

I expected failures due to the incomplete state of the 0.7.x iki_read code (as a result of recent changes).

I will then need to add the eki_read runtime tests and add the `-s`/`--select` runtime tests once the existing problems are resolved.

Cleanup: Improve spacing style for fss_read generate.sh test script.

Add spacing to allow for lining up the lines to make it much easier to scan through with human eyes.

Update: IKI Read help message regarding --line parameter.

Make the `--line` parameter help message consistent with recent changes from the 0.6.x stable branch.

Update: Improve error reporting in runtime tests during generation.

The generation now prints the specific command that failed.

Progress: Begin fixing iki_read (and eki_read).

I noticed a lot of issues and fixed the problems on the 0.6 branch first.
This caused me to jump around back and forth a lot for the 0.7 branch.

This disoriented me.
I decided that I am going to commit this current state as a progress commit.
I will write the runtime tests for the 0.6 branch.
Then I will port those over to this.
Then I will use the runtime tests to help identify where I last was and what I need to change or finish changing.

The `--select` settings also need to be updated with regards to this.

Feature: Add support for eki_read program by extending iki_read, also adding --select and changing --substitute.

The eki_read is a variation of iki_read that instead supports the Extended IKI standard, known as EKI.

The iki_read and eki_read share common code.

This introduces a new parameter called `--select` or `-s`.
This allows for selecting the Vocabulary name (Object) at a given index.
I specifically chose `-s` to make the behavior more closely in line with the `-s` and `--select` from the fss_read programs.
The only difference being that the fss_read programs operate on the Content rather than the Object.

This decision forces the `--substitute` to now use `-S` instead of `-s`.
This is a breaking change that I will not back port.
The use of `--substitute` will still work with the 0.7 and 0.6 releases.

This completes the following progress commits:
- 21ae35744a1cfc7703fe3ac13b25ff7a71fa2d59
- dbc2fc03c4edd96611e07317a2c876f412017d2c
- 21ae35744a1cfc7703fe3ac13b25ff7a71fa2d59

Progress: Continue eki_read program by extending iki_read.

IKI/EKI Vocabularies (Objects) may not have spaces.
This means that I can safely print the list of Objects with a space between.
All Objects on a single line in `--object` mode will represent the objects assigned to that particular IKI/EKI variable.

Progress: Continue eki_read program by extending iki_read.

This refactors iki_read in regards to the wraps and replaces.
I have not done any testing of the wraps and the replaces yet.
I also need to consider exactly how I want the multiple parameters to be handled.

I need to think about how I want to handle printing Objects (`--object`) with EKI when there is more than one Object for a single Variable.

Progress: Begin adding eki_read program by extending iki_read.

Setup the most basic functionality.

Currently they are both performing iki_read functionality.

The two programs require a different data structure.
I need to plan on how to handle this.
I may end up using callbacks and possibly a void pointer for data.

Update: Simplify code slightly aad remove redundant `fll_program_print_help_header()` call.

Use the variable for `parameters` to simplify code.
This simplifies the code at the cost of using a variable.

Remove include that is not needed from the c files.

Update the documentation comments to have `Properties: `.

Remove redundant `fll_program_print_help_header()` call.

Cleanup: Use parameters pointer and relocate output.to assignment.

Relocate the `main->program.output.to` assignment to the top of the load settings functions.
This should better allow for printing to be properly used, sooner.

Setup the `parameters` as a pointer to `&main->program.parameters`.
This should help made the code easier to read by reducing the size of the code needed.

Cleanup: Add missing documentation comment and fix structure ordering.

Use alphabetic ordering when the dependencies are not forcing the order.

Cleanup: Build settings structure for iki_write.

Cleanup: Add new line in build settings files.

Update: Add clarifying documentation to some memory allocation functions.

Feature: Add eki_write program.

The eki_write program is now added and complete.

This resolves the progress commits for this, such as 740d5fc88d6e05edf2a7267c422642bd14cc473c.

There are no iki_write runtime tests yet, so this does not add any yet.

Update: The fss_read has missing our out of date information.

Add the android settings like is done for other settings files.

Use the hex digits rather than `f_true` and `f_false`.

The `fss_read_main_setting_load_as` callback appears to be missing.
I need to review the code to confirm/deny this particular behavior.

Progress: Begin adding the eki_write program by extending iki_write.

This is a bit rushed, so I will have additional passes to make.

Update: Improved documentation comments in f_memory functions.

I sometimes forget whether or not which type the "width" should be.
This adds additional documentation to hopefully make it more clear.

Update: Switch iki_write to using f_iki_write().

The old iki_write is using the simple processing functions.
Switch to using the dedicated `f_iki_write()` function.

Switch to using the main cache design.

Cleanup: Fix incorrect documentation comment for fss_read function.

Feature: Add fl_iki_eki_read(), add unit tests, and update existing stand alone builds.

Cleanup: Remove unused header include fo f_abstruse unit tests.

Update: The time specification, making it more flexible.

Improve the time specification to grant better control and flexibility on what it means to those implementing and using it.
Provide suggestions regarding IKI and EKI.
Remember, these are suggestions and are not requirements.

Bugfix: FSS Read unit tests, fix file names, and fix FSS-0008 test files.

I noticed that I had several of the test files misnamed.
Many of the test files should have a prefix of `name_` in from of parts of the file name relating to the name parameter.

I had originally created the test data for FSS-0008, FSS Embedded List Read, tests just using the output data as generated.
I knew that there was a good chance that any mistakes would be treated as valid.
This saved time and allowed me to work towards improvements.
I have identified and fixed several bugs.
This has then revealed that several of the tests have invalid data.
I manually reviewed several of these and confirmed that the newly generated code looks more correct.
There is still an opportunity for an oversight or mistake but I believe this is more progress forward.
My goal is not to spend too much time directly on this with the expectation that I will test and resolve these problems over time before a stable release.
This is more of a matter of time allocation and priorities rather than a technical correctness and accuracy issue.

Bugfix: Incorrect handling of "at" positions in FSS Embedded List Read.

The "at" position needs to be counted during all iterations.

Bugfix: The FSS Read process at should only process if index_at is non-zero.

The FSS Embedded Read recursive logic exposes this problem.

The at flag bit is set when the at parameter is passed.
The at parameter being passed when there are multiple depths does not mean that the specific depth in question should be using the at position.
Add a check that ensures that the current depth needs the at position processed.

Bugfix: Do not treat out of range depth as an error.

The FSS Embedded List Read should not treat out of range depth as an error.
This simply should return no results.

Update: Refresh the stand alone builds.

I ran the commands as written in the commented out parts of the config.h files.
The order of the defines somehow changed.

I must either have done something weird, wrong, or different last time to result in the differences.
To save time, I short circuited some of the process.
This means that there is a chance that I commented out defines that don't need to be commented out.

I've tested and confirmed that these compiles.
I have not checked the before and after sizes or symbols.

Bugfix: Add missing _di_f_print_except_in_dynamic_safely_ to private_f_print_except_in_safely().

Update: Fix IKI write and add EKI write functions for f_iki.

Fix the backslash handling now that I have figured that whole situation out and updated the specifications.

Adding support for the EKI write.

Add more extensive unit tests for both IKI write and EKI write.

I am trying to keep both the IKI write and the IKI write works functions as similar as possible.
The "works" write tests are already big enough anyway.
Implement a separate test for EKI, called `test__f_iki_eki_write__works_for_multiple`, to handle the multiple vocabularies case.
This will be structurally identical to the regular works tests but instead has multiple vocabularies.

Bugfix: IKI and EKI specifications, clarifying backslash escaping.

I made several improvements in my previous commit e9621b09db34cfd9ac6264c77068c34afa5bfb17.
I added documentation regarding the backslashes similar to how the FSS backslashes are handled.
For the IKI and EKI specifications, this is not the case.

Update the specification to clarify this situation.
Update the examples to better describe this.
Fix the examples to be accurate.

Bugfix: The IKI and EKI specifications have mistakes and needs clarifications.

The wording of the specification is now greatly improved.
I noticed that some of the specification is actually incomplete.
I removed the incomplete sentence.

Make sure the FSS-000C specification is updated to add allowances for the EKI specification.

The example in both the IKI and the EKI specifications has several mistakes.
Use the grave character (U+0060) for the code to help avoid needing to escape the single quotes.
The IKI inside of a valid IKI Variable do not need to be escaped.
The example that directly states "is escaped to not be treated as IKI Variable" is incorrectly being documented as a valid IKI syntax (a significant mistake on my part).

Add explicit escaping examples to help make the escape behavior more explicit and clear.
I believe the current escaping logic in the IKI processing code is incorrect and will need to be updated and corrected following this commit.

I remembered this time to make the date based on UTC.
The version date in this commit is based on the current UTC Earth day.

Feature: Add f_iki_write() along with appropriate unit tests.

The `f_iki_write()` function is missing.

Add appropriate unit tests.

I also need to add tests with existing slashes.
I think I noticed a bug in the IKI read functions regarding slashes and I will investigate that before I add such tests here.

I will write the EKI write functions once I have done further review and fixed the likely IKI read bugs that I believe that I have observed.

Feature: Implement EKI at level_0.

This provides the initial eki implementation and unit testing.

I had to choose between making an f_eki compliment of f_iki or appending EKI into f_iki.
I ended up choosing the latter because it is simpler and will require fewer cross-dependencies when using higher levels.
There is enough overlap in functionality to justify this.
These are almost completely identical specifications.

Add additional unit tests to catch more problems and implement these same unit tests in f_iki for consistency purposes.

This includes some code clean up.
The `wrapped` is changed to use `0x0` and `0x1` rather than `F_false` and `F_true`.
These are functionally identical but the code is more consistent when having `0x0`, `0x1`, and `0x2` instead of `F_false`, `F_true`, and `0x2`.

Update: IKI and EKI specifications.

Further clarify the specifications and simplify some of the logic.
The "Before Structure" is confusing in that it has a `\*:*`.

Cleanup: Print new line to test.sh script on install.

I noticed that the "All operations complete." runs into the "Installing individual project '..." line.
The `test.sh` now prints a new line before the "Installing..." message.

Update: Add FSS Embedded List read depth tests and fix test script files.

Add tests for the FSS-0008 standard using depths.
I generated these test expectations.
I will have to slowly review these over time or fix them when I identify one is wrong.
I did do a test by building the same tests on both the 0.6 and 0.7 and found that they both pass.
I either have correct logic or I have consistently bad logic.

This adds a lot of FSS-0008 depth tests, however, the amount of tests needed is a lot more than what I have done here.
I think this large number is a good start.

Add special cases functions for the script tests.
I noticed that the failure code is incorrectly being set (the logic appears reversed).

The conditional argument used to determine which test being run in the test script is wrong.
Create a new variable called `test_set` and use that.
The `standard` variable can then be extracted from the `test_set`.

The test script incorrectly is missing the `-o` for the Object in some cases.

Update: Implement the fss_embedded_read depth logic using recursion.

I only did cursory review of the code and functionality.
I need to do more extended review to make sure there are no mistakes or logic flaws.
I need to write unit tests to identify these cases.

Cleanup: f_fss_item_t documentation.

Feature: Add EKI specification for EKI standard, a slightly updated IKI standard.

Think of EKI as an extended IKI.
This introduces a single change (and its accompanying requirements).

Multiple IKI Vocabularies are now supported.
I have been using IKI in practice for a while now.
A need has risen up where I really want to be able to easily designate multiple IKI Vocabularies for a single IKI Variable.

This new format allows for me to do something more similar to HTML.
I have been using IKI as part of a templating process.
With EKI, unlike IKI, I can now make something both bold and italic.
Whereas with IKI, I would have to create a new type that combines them (like `bold_italic`).

I would then have to create two types if I wanted to be order agnostic, such as `bold_italic` and `italic_bold`.
This would get progressively worse if I added a third or more Vocabularies.

With EKI, I don't add any new IKI Variables and the order does not necessarily matter.

Example: `bold:italic:"My example"` (and `italic:bold:"My example"`).
This would have `bold` and `italic`.
The order should be preserved in case something does care about order.
The order can be ignored if something does not care about order.

Bugfix: Mistakes in the IKI specification.

Explicitly describe the colon `:` (`U+003A`).

The escape sequence is before the colon `:` (`U+003A`) and not the close bracked `]` (`U+005D`).

The example should be using `bold` and not `strong`.

The specification file names are incorrectly named (should be `iki` and not `fss`).

Cleanup: Remove unused variable.

Bugfix: Empty Objects are preserving leading white space when in original mode for Payload.

The functionality already exists.
The test is failing.

Add the missing `fss_read_feature_flag_object_align_d` feature flag to the Payload.

Update the unit test to properly reflect this.

Regression: Make sure FSS Payload Read compiles after recent changes.

This commit 3b8b0cba03096e764194db8bb889cd94a8d97f5b has a mistake.
I ran the `testfile` tests, which does not use the `main` programs for specific types.
The `testfile` tests only uses the `fss_read` program.

I forgot to check and compile the main programs.
Replace the non-existent functions for the Payload main program.

Cleanup: Simplify the naming of the process_normal functions.

The `normal` is now removed from the `process_normal` functions.
The `process_normal` callback is also shortened to just `process`.

This is the follow up to the commit 171ba867137d29242be1083a129e97839ff88b8a.

Cleanup: Re-organize the process_normal files.

I was originally thinking of having `process_X()` and such functions.
I created `process_normal()` functions as the standard functions to use.
I ended up not doing this but the `process_normal` use remained.

This is the first step into cleaning up the structure to a simpler naming system.
All this does is rename the files and anything using the files by name.
Changes to the functions will be in a follow up commit.

Bugfix: The FSS Payload Read is not treating the Payload as raw when printing.

Special handling is needed to process the `payload` section.
The content functions all need to have the `at` position to determine this.
Update the callbacks to allow for this.

The function `fss_read_print_content_empty()` is defined and used but it is used only for the `print_object_end_empty()` callback.
Add a `print_content_empty()` callback to provide this.

These changes allow for removing redundant functions.

Update: FSS Read tests, clean up syntax, and add additional range check.

Make sure the `at` is within range in the `contents` array.

Add missing NULL characters in the "payload" section of the runtime test expect files.

Bugfix: Empty Objects are preserving leading white space when in original mode.

This (unfortunately) adds more logic to processing the case when `--original` is used and the Object is empty.

This makes me wonder if I have to implement the opener range.
I was not happy about adding the `close` for memory and space reasons.
Adding this would introduce more inefficiencies.

I may end up having to add support for processing different types of structures if I want to support the simple Object and Content without the `open` and `close` positions as well as with those positions.
The focus in this commit is only on fixing the printing and does not introduce any of the behavior that I described here.

Update: The bootstrap example script now handles building using fake.

The bootstrap example script is generally for using bootstrap scripts.

I have ended up using this for regular building because it is simple and already written.
The FLL 0.7 development now has build settings for some programs that do not build using the bootstrap without additional parameters.

Add support for the bootstrap script to use `fake` directly if it exists in the PATH for these particular programs.

Cleanup: Fix position of high ports to be consistent.

Feature: Fake settings specification updates and enable simple golang support.

The Featureless Make is intended to not be language specific since its inception.
I did not know how the languages were to work, so I mostly built this to guarantee C/C++ support.

I found that the `golang` supports some command line based compilation.
This adds support for `golang` in the most basic way.
This support is not well tested.
An `example_go` project is added.
I have only tested the basic build and I have not done anything advanced.

This relaxes some of the requirements.
The `bash` is changed to `shell` to encourage more types of scripts.
The `custom` is added and used as a fallback if `build_language_path` is not used.

I found that there needs to be some additional settings in the `settings` specification.
This updates the specification and adds:
  - build_compiler_arguments
  - build_compiler_arguments_shared
  - build_compiler_arguments_static
  - build_compiler_arguments_library
  - build_compiler_arguments_library_shared
  - build_compiler_arguments_library_static
  - build_compiler_arguments_object
  - build_compiler_arguments_object_shared
  - build_compiler_arguments_object_static
  - build_compiler_arguments_program
  - build_compiler_arguments_program_shared
  - build_compiler_arguments_program_static
  - build_language_path

This also fixes some mistakes in the language of the specification.

Feature: The firewall program should have better IPv4 vs IPv6 support.

Add two parameters to explicitly chose between IPv4 and IPv6 (`-4` and `-6`, respectively).
The default behavior is to display both.
This default `firewall show` will now therefore show both IPv4 and IPv6.

Add `(IPv4)` and `(IPv6)` to the output from the `firewall show` command.

When the firewall rules set the tool to either IPv4 or IPv6 but the command line is designating that either IPv4 or IPv6 is specifically enabled or not, then do operate on the tools that are not enabled.
Therefore if the firewall rules have an IPv6 tool (as is the case in the example/default settings for `icmpv6`) and something like `firewall start -4` is used then those IPv6 ruls are ignored.

Update: Add missing fll_program function for short option, fix some parameters, and fix ordering of a function.

The `fll_program_print_help_option_short()` function is missing, should be defined, and now is defined.

The `description` parameters for these functions should have the `const` qualifier.

The `fll_program_print_help_option_standard()` implementation is not in the correct alphabetical position.

Cleanup: Minor clarification in console function comment.

Update: Relocate firewall rules to under the /etc/network/firewall/.

This should help isolate all of the firewall rules from other network related tasks.

Update: Refresh firewall iptables rules and relax some of the defaults.

Relax some of the defaults so that there will be less immediate failure.
Provide a lot of the previous `DROP` statements for easy re-assignment by just uncommenting.

Add some specific wrapping tools around IPv6 related rules.

Update: Improve robustness of the fll_control_group_prepare() function.

Add additional existence checks before attempting to create a directory within the cgroup path.

Bugfix: Get the FSS Embedded List Read working as expected based on runtime tests.

A good portion of clean ups and design changes to address special cases or anything overlooked.
The runtime tests now pass as expected.

This does not address the currently incomplete depth processing of the FSS Embedded List Read.

There are still some situations that need to be fixed.

Bugfix: Bad handling of comments due to not re-assigning line start and fix mispelling in tests.

The `valud` should be `valid`.

Update: The stand alone builds to handle the added use of f_utf_buffer_decrement().

Bugfix: Incorrect parameter added to macro_fl_fss_data_embedded_list_t_initialize_1().

Bugfix: The delimited FSS lists are not properly setting the stop point.

This uses existing variables and shuffles the data around rather than defining a new variable.

Update: Recent changes to the FSS implementations did not account for the unit tests.

Feature: Add support for building under Android.

This is a forward port of the changes from the 0.6 branch without any testing.

This is not well tested or well supported.
This does have limited testing under the Termux project environment using CLang.

Add a new configuration option to build and run the project in an Android environment.

The test system had problems with text relocations but then required PIE.
This disables the relro in some spots (libraries) while enabling it in others (programs/executables).

Disable a lot of the functions that are not available or supported.

I have observed several warnings about `DT_FLAGS_1=0x41` being unsupported flag.
That is not a very helpful warning.
I have no idea what `0x41` is.
This causes a problem where the output of programs displays these warnings.
This can break programs that require I/O formatting and processing.

This has been tested to build using `bootstrap.sh` and then using `fake`.
Example build and install process:
# mkdir ~/software
# cd fll-0.6.X/
# ./bootstrap.sh build -m monolithic -m thread -m clang -m android && ./install.sh ~/software
# cd ../fake-0.6.X/
# ./bootstrap.sh build -m monolithic -m thread -m clang -m android -w ~/software && ./install.sh ~/software
# export LD_LIBRARY_PATH=~/software/libraries/shared
# export PATH=~/software/programs/shared
# cd ../byte_dump-0.6.X/
# fake -m monolithic -m thread -m clang -m android -w ~/software && ./install.sh ~/software

Example execution of `byte_dump` of `bash` program (this is a large dump).
# byte_dump -wt 7 $(type -p bash)

Bugfix: Incorrect disabled defines and missing disable wrapping defines.

The `_di_f_fss_complete_e_` is required by multiple programs.

The `private_fl_fss_basic_write_object_trim()` is called by `private_fl_fss_basic_write()`.
This must now expose multiple types.

Bugfix: Replace index() with strchr().

The `index()` function is deprecated.
Use the `strchr()` function instead.

Update: Simplify and centralize reporting for FSS read errors.

Use a single function to handle the common cases.

This is an improvement upon commit a9b37a3f8fd99e45feff22779e8d375314cbb925.

Update: Improve error reporting resulting from unsupported file formats.

The file is either an unsupported format or has syntax errors.
Provide a more human-friendly error message rather than the default catch-all error with a status code.

Update: Implement Object alignment and trim expanding in FSS Read programs and restructure the program flags.

The program flags for the standard-specific functionality vs the program arguments were previously stored in the same bit space.
This breaks the two parts into the main program flags and the "feature" flags.

Implement support for new functionality where the Object structure can be optionally preserved.

Implement support for new functionality where the tabbing of the Object can be preserved, even when trimmed.
This is a step towards a "pretty print" mode that is more or less an "original print" mode.
The tabbing structure is now well preserved for standards like FSS Extended List (FSS-0003).

The Object alignment can determined from the Object close.
Use the `closes` structure to identify how the Object end is tabbed.
Then use that tabbing for the Object.
When trimming is enabled, still apply that tabbing.
This is done only for standards where such behavior makes sense.

The original print is now better preserved.
Printing an Object can now print the before and after Object characters (usually white space).
The trimming and original print may be used together to produce the results where the is no white space before or after the Object but everything else from the original source is preserved.
This combination of trim and original essentially ensure that the old behavior can be still produced.

I would further note that the processing of the FSS Embedded List (FSS-0008) Objects is not recursively performed.
No trimming or anything like that is applied at this time.
Only the selected depth is recursed into such that the Object and Content are processed.
I made this decision to keep the design as simple as possible.
Should I get the motivation and the time, then I may at some point in the future decided to recursively process and format all of the embedded structures.

I happened to notice duplicate and unused flags.
These are now removed.

Update the runtime tests accordingly.

Add new runtime tests to test the updated behavior.
I used the 0.6 and 0.7 to test these and I compared the results.
There is a discrepancy in some of 0.6 and 0.7 tests.
I will have to follow this commit with additional test fixes as necessary pending further review.

Update: The FSS Lists (FSS-0002, FSS-0003, FSS-0008, etc..) to match recent specification changes and reduce redundancy.

Update the Object read functions to be in compliance with the latest specification changes.
Review and update the code, fixing any observed problems and perform some clean ups.

I noticed that several of the list functions for Object read are almost identical.
Move this logic into into a shared private function to reduce repeated code.

The runtime tests are also updated.

I still need to review the Content read functions.
I probably may be able to also find similar, if not identical, code for the list write functions as well.
I will review the code and create a private function similar to what is done here if deemed possible and reasonable.

Cleanup: Fix bad grammar in function documentation comments.

Cleanup: The testfile for the FSS Read programs.