Bugfix: IKI read is not identifying cases with leading characters.

An IKI read string that begins with text that is potentially valid, followed by non-IKI name characters, and finally followed by a valid IKI variable name is not detected.

Example:
  Should=define:"value".

The above didn't resolve, but with this fix should now find the full IKI variable: 'define:"value"'.

Update: add missing documentation for fake fakefile fail setting.

Bugfix: invalid read after buffer.

If arguments.used was not incremented, then the arguments.used represents the correct position.
If it was incremented, then append that value.

The following string triggered the behavior:
  print Return Code is \"parameter:"return""

Progress: featureless make.

Finish implementing the return code processing.

Allow the return failure strategy to be tweaked via the setting 'fail' which can have one of the following:
- exit: exit program on failure.
- warn: do not exit and if in verbose mode, print warning.
- ignore: do nothing.

The reserved parameter variable "return" is populated with the return result value.
For example, you can see the return result by adding the following after a run, shell, or similar operation:
  print Return Code is parameter:"return"

Add some additional warnings when loading settings.

Feature: add f_conversion_number_signed_to_string() and f_conversion_number_unsigned_to_string()

These functions handle converting a number to a string representation of that number.
The base units 2 through 16 are supported.

Progress: featureless make.

Implement the "run" and "shell" operations.

Remove unwanted printed newlines.

Security: memory leaks in execute functions.

Use f_array_length, not f_string_length, for traversing an array.

The variable "i" is being used when it should be "j".

Add numerous missing deallocation calls.

Deallocate immediately instead of after a waitpid().

Avoid redeclaring the "i" variable.

Progress: featureless make.

Wrap up the path change operations.

Cleanup additional print functions that are no longer needed.

Security: memory leak due to using _new instead of _resize

The array may already be initialized, so use the resize macro instead of the new macro.

Update: start counting line at 1.

The fss files may start at 0, but report the starting line at 1 for friendliness with other programs.
I may very well need to update the fss project to consider lines starting at 1 instead of 0 for consistency.

Bugfix: extended content has wrong size.

This is happening because the status variable is being overwritten when allocating.
Use a separate status variable for allocation.

Cleanup: Reduce arguments by accepting the entire fake_data object

Progress: featureless make.

I flip-flopped on how I wanted to handle the print functions and need to update/rewrite them again after this commit.
The end of an operation always prints the section, line number, etc.., so I do not need as many custom print functions as I ended up doing in this commit.

This begins processing the stack path.

The pre-process idea just will not work because the argument length is not known until after expansion.
This throws away the idea of having a pre-process validation on the operation rules, unfortunately.

There are some mistakes in the expand function when handling arguments that need to be fixed.

Bugfix: f_string_range initialize macros need to consider used = 0 case.

Progress: featureless make.

Begin adding the path stack functionality.

Update: directory and path changes, other fixes and changes.

f_directory and f_path overlap.
I believe that f_path is the better choice for getting the current directory/path and related.

Add f_path_change(), f_path_change_at(), f_path_current(), and f_path_real().

Add F_absolute and F_relative status codes.

The define FL_status_string_recurse_length did not include the leading f_ in the derived length.

Minor documentation comment changes.

Progress: featureless make.

Remove the custom color toggler based on verbosity because I changed my mind.

Allow assigning define as a fakefile operation.

Begin stubbing out the operations.
Implement the operations that can easily be implemented.

Documentation updates.

Progress: add preprocess/process validation to featureless make fake operation operations.

Update: the fake documentation and specification.

Cleanup: use 'warn' instead of 'warning'.

Progress: featureless make iki documentation.

Update: specifications in regards to IKI, adding new ones.

Progress: featureless make.

begin validating operations.

begin adding documentation for fakefile.

Fix mistake in documentation files where incomplete/incorrect fss header is specified.

Feature: add f_file_type() and f_file_type_at() functions.

Update: add missing string compare functions.

These should have been implemented for completeness but were not.

Progress: featuerless make.

Enable detection of quotes when processing extended content within the lists inside of the fakefile (except for the settings list).

fss-quoted.h must come before fss-named.h.
Be sure to include level_0/type_array.h.

Fix mistake in f_macro_uintX_tss_new() macros where the f_macro_memory_structures_new() has the wrong arguments.

Use fll_fss_snatch_map_apart() instead of fll_fss_snatch_map_mash_apart() when expanding iki variables.
The arguments need to be separated so they can potentially be passed to an exec() equivalent call as individual arguments.
Any operation that expects a single argument can still implode these strings before executing.

Cleanup: remove extra _.

Update: add f_fss_set_quoted.

An f_fss_set that includes object and content quoted type properties.

Update: the fss snatch and similar functions should also optionally get the index.

The index will be the index where the match was found.
The objects and contents will have the same index.

Update: f_fss_quoted to use the f_uint8_t types.

Cleanup: remove stale test code

This code was used in trying to identify what ended up being an issue with macros.
Remove the commented out test code and fix the tabbing of the pointer assignments.

Feature: provide f_cell, f_cells, and f_cellss types.

The f_cell types are intended to represent a row and column position, just like with a table cell.
This is important for management arrays matrices and the like.

Update: add array types for the 8t, 16t, 32t, 64t, and 128t explicit types.

For both signed and unsigned.

Add missing parameter in resize and adjust macro calls.

Cleanup: fix accidental use of - in header names

As per practice, they should be underscores.

Progress: add support for determining quotes in use, other fixes and cleanups.

While not enthusiastic about this, I believe that I need to report the quote used to the caller.
Make this an optional parameter.

This took some significant consideration.
Not all standards utilize quotes and I also do not want to make FSS object and content types more complex than ranges.
Using a separate variable, while a bit more tedious in having to maintain consistency, is an acceptable approach.

FSS-0000 objects, FSS-0001 objects, and FSS-0001 contents all use the same logic for identifying their types.
Reduce code by using the same function.
Because FSS-0001 contents is an array of contents, move delimit processing outside of the private function.

Replace (used + 1 > size) checks with (used == size) checks to increase performance by avoiding arithmetic operations.
Replace (used <= 0) checks with (used == 0) checks to remove unnecessary checks.
Replace (used != 0) checks with (used) checks to avoid extra processor work.

When incrementing and decrementing buffer, do not report used as an error, instead just return F_data_not.

Shorten pre_allocate_size to size_allocate.

Stop setting F_unterminated_group_stop and F_unterminated_group_eos as warnings.
This was not done consistently.

Rename buffer to destination for FSS write functions.

At some point in the past I was wanting to use while loops more exclusively.
After some some significant time and consideration, I have decided to abandon that idea.
Use for loops where they make more sense over while loops.

Continue work in Featureless Make.

Bugfix: risky macro definition caused counter problems.

Macros should be used sparingly, if at all.
When macros are used, they should be used carefully.

In this case, I was defining a variable "i".
The substituted data also included an "i", which caused a non-obvious problem.

Use a more unique counter variable name "_macro__i" to help avoid these problems in the future.

Revert: keep fss.h

Not having fss.h goes against some of the basic design.
Keep fss.h, but do not provide fss.c.

Cleanup: remove empty fss.c and fss.h, add missing dependency

Removing this exposed a missing dependency to f_file.

Progress: featureless make.

Update appropriate f_utf_ functions.

Implement "define" and "parameter" IKI variables as per IKI-0002.
These variables will be substituted with settings value if found or removed if not found.
This expansion will happen before performing operation.

rename fake_make_load_setting() to fake_make_load_fakefile() to be more explicit.

Minor cleanups.

Feature: add additional string comparison functions.

Comparing a string range to a non-string range can be messy.
Provide new functions to help alleviate this mess.

Update: Unicode related specification adjustments, also perform minor fixes and cleanups.

The Unicode includes some characters that violate some of the expectations of the FSS and IKI standards.

To that end, provide non-strict modes to allow for the FLL based adjustments of these standards.

There are some vertical line like characters that act as punctuation connectors.
Because they connect vertically instead of horizontally, they violate part of the inteded design of FSS and IKI where everything is on a per-line basis.
These Unicode vertical line like punctuation connectors are not to be considered punctuation connectors for the purposes of FSS and IKI processing.

There are some non-printing characters, such as invisible plus.
This is a punctuation character that is also a zero-width character.
For the purposes of FSS and IKI, these characters must not be considered punctuation characters.

Any other zero-width characters are to be considered zero-width and are not to be used for syntax and similar.
(Combining characters are a different beast to be addessed at a later time.)

Further clarify how certain Unicode characters are to be handled, in general.

Unicode dash characters are now being limited in being interpreted as a dash for the purposes of connecting words.
To this end, only the Unicode hpyhens are the allowed dash-like characters (with the ASCII dash being allowed as well for that matter).

Use const where possible.

Fix some wording in some documentation comments.

Update: improve IKI syntax rules.

This is a relaxation on the specification where previously only whitespace was required to exist before a valid variable name.

This allows punctuation to exist before the variable name.
Content such as 'A:"b"' may now be specified where A is the variable name (notice the single-quote before A which would previously prevent A from being recognized as a variable name).

Cleanup: change order of variables.

Bugfix: FSS-0000 and FSS-0001 are handling not explicitly follow standard for quote delimit requirements.

In the case where a quote is provided that could potentially be a valid quote, that quote should only be considered a quote (including for delimited purposes) if a valid whitespace, end of string, or end of line is reached.
The code needs to check after the closing quote to confirm that it is actually a valid closing quote before acting on it.

Update the FSS specification to make this behavior more explicitly clear.

Cleanup: add note to todo

Progress: UTF-8

More UTF-8 improvements.

The Punctuation is complete as far as the "Other" punctuation category is concerned.
(Apparently, there are more groups/sets to do!)

Create a new whitespace functions (is_whitespace_other()) to handle non-whitespace whitespace.
So far, this is only a single character: Ogham space mark ( ).
This Ogham space mark is not a whitespace, it is a graph character that is considered a whitespace.

Add some @todos.

Remove invalid whitespace character().

Add is_digit() vs is_numeric().
The traditional alnum() is referring to alphabet and digit.
With UTF-8 there are non-digit numbers, which can be classified as "numeric".
Therefore, the is_digit() functions are added and intended to be used for the traditional behavior.
The is_numeric() are intended to handle any numeric character.
The is_word() tests are for digits and not for numeric.

Update: UTF-8

Add more punctuation tests (there are still many more to go).

Fix an incomplete if condition in private_f_utf_character_is_whitespace().

Use width and byte_first more.

Progress: more UTF-8 work

Complete more encodings.
From the look of things, most emojis are part of symbols, so no need to check for emojis when already checking for symbols.

Add phonetic.

Progress on emojis will be slow and piecemeal.
Symbols will likely be as bad as emoji.

Bugfix: IKI Read should not always print content on substitution in whole mode.

When printing in whole mode, it is only printing the content, even when --literal is passed.

What should happen is that when --literal is passed, the entire variable should be printed, even when substitution is used.
The substitution will still occur.

Bugfix: f_utf_is_whitespace_modifier() is incomplete.

Remove "@see iscntrl()" which appears all over the place, incorrectly.
Make sure appropriate "@see" uses exist.

Remove unnecessary "== F_true" tests.

Implement is_punctuation and is_symbol discovery for ASCII characters.

Some function declarations are missing.
Some function implementations are missing.
Remove duplicate declaration of f_utf_character_is_word().

There are no whitespace modifiers in ASCII to my knowledge, and isdigit() is clearly from a copy and paste that was never completed.

Add notes about phonetic whitespaces and improve handling.

Update: U+102E0 is essentually a comma and not a number.

Update: finish implementing IKI Read program.

The resulting design made --expand redundant, so it is removed.

Substitution is implemented and works independent of the --name parameter.

Added a new macro to the FLL project called f_macro_memory_structure_macro_increment().
Too often do I have to create those structures, so here is a macro to perform the increment.
I started to update the rest of the project and then decided not to spend time on that right now.
This, therefore, primarily focuses on getting the macro working in IKI.

IKI Read is now considered usable, except for the UTF-8 support.
The UTF-8 support is dependent on updating a ton of UTF-8 codes.
This will be done at a later time.

The IKI Read program will eventually need to be reviewed for mistakes and cleanups.

Cleanup: add todo notes.

Bugfix: when --line is used, lengths passed buffer size aren't handled.

data->line is not a position, do not use it as a position (if (data->line < data->buffer.used) { is doing this).

If the line is exceeds the buffer, return f_data_not and properly handle that return case.
For --total, this means print 0.
For just about everything else, print nothing.

Bugfix: delimit placeholder not being applied in all cases

The final exist should apply any delimits.

When determining the remaining width, make sure that the range or buffer has not yet been exceeded.
Not doing this resulted in an exit with an F_parameter error, further resulting in no delimits being applied.

Progress: Iki Read.

Rename raw mode to whole mode.
I believe the meaning of the word 'whole' is more correct than the word 'raw'.

Implement 'whole' mode.

Progress: IKI Read.

Implement the basics of raw mode.
Raw mode should instead work in conjunction with the content, literal, and object modes so redesign accordingly.

Add some additional documentation to the help section.

Expand and Substitute are mostly ignored thus far and will be implemented at a later time.
The substitution will be copied from the argv as-is, so plan on using static strings instead of dynamic strings.

There will be function argument cleaning to do once I determine how Expand and Substitute will be implemented.
Until then, the arguments are fine as-is.

Progress: IKI Read

Continue work on implementing iki_read.

Cleanup: clarify IKI specification.

Any character, not just printing characters, is supported within the content of IKI.

Bugfix: read overflows the per character scanning

There is a logic mistake where the buffer is incremented too many times before the next loop.
This results in skipping some of the characters in the file and if those skipped characters are part of a vocabulary and content, then it will not be detected.

Cleanup: reserve IKI-0000 and update documentation

The standard IKI-0000 is now to be used to represent anything that follows the IKI standard without explicitly descrribing what its vocabulary is.
All other IKI standards (IKI-0001 and greater) are to be used to represent a specific set of vocabulary terms.

Update: dependencies changes, project level changes, and includes changes.

Review the current dependencies and fix them.
There are some cases where some dependencies are not necessary, such as f_utf.
There are some cases where some dependencies are missing (or newly added).

f_conversion split into f_conversion and fl_conversion.
Update dependencies accordingly.

For simplicity, include the core level_0 project headers, except in a small number of cases.

Add fss header comment in dependencies files.

Add comments in *_array.h headers for level_0 core projects.

Add missing header in f_string.

Replace _di_level_0_parameter_checking_ with _di_level_1_parameter_checking_ where incorrect.

The fl_fss identify functions should instead be in the fll_fss project.

Make sure the IKI projects are in the bootstrap example script.

Remove the fl_console_parameter_to_number_unsigned() and similar functions.
These are just wrappers to another call and is therefore a waste.
Instead, just call the fl_conversion_string_to_number_unsigned() and similar functions.

Bugfix: settings files are stored in 'data/settings/' not 'data/build/settings/'.

Bugfix: The setting is called 'build_sources_setting' and not 'build_sources_settings'.

Bugfix: completely ignore comments in dependencies file

Progress: IKI Read

Begin the process of adding the IKI Read program.

Cleanup: capitalize IKI

Update: todo notes added

Update: print formatting, closing file, and returning

The print formatting for status should be %llu in the event that the entire status (error bits, etc..) is printed.

There were some cases where the file is not being closed.

There were some cases where the program is missing the return statement.

Update: add f_macro_file_clear() and f_macro_file_reset()

Bugfix: conversion needs to properly handle '0x' and similar

Invalid Parameter happens when there is no following number after the x in '0x'.
This is because the start and stop range were not being checked after applying the offset.

Progress: Featureless Make.

Begin working on integrating IKI into Fake.
I took advantage of the current code to do some testing with IKI and left some of the testing code for now.

In addition to IKI, I am thinking that I need to add another project for exploding a string into separate arguments with support for escapable single and double quotes.

Bugfix: iki didn't handle all cases

I forgot to review the delimit cases and when I did I found the implementation a bit sloppy.
I also found some ways to improve the code.

The content slash total should start at 0 and not 1 because it increments it later on.

The fl_ik_read() needs to check the range.

Feature: add fl_iki project.

This provides fl_iki_read, a function for identifying all iki within a given range.
Whereas the f_iki_read function will only identify the first valid iki variable found within the given range.

Update: add missing dependencies, changes to iki

In a previous commit I seem to have forgotten to include the build settings changes.

Fix some minor mistakes in iki.
In particular, I forgot to increment the range->start after identifying where content would begin (which prevented it from working at all).

Add f_iki_variable to store the range for the entire variable.
This will allow for easy removal when substituting (which is one of the design intentions, so I need to cover this use case!).

Progress: Featureless Make and IKI.

Continue work progressing Featureless Make 'make' and the newly implemented 'Iki' standard.

Update: UTF-8 improvements

Move some FSS UTF-8 processing code into UTF-8 as it should be more generic.

Add more UTF-8 functions (or at least the stubs).
Begin adding emoji, which is all over the place.

Staring at so many codes, it will be easy to make a mistake.
After all of the UTF-8 functions are believed to be fully implemented an extensive review needs to happen.

Cleanup: fix comments

Progress: organize headers, simplify fss structures, initial IKI support

Move more headers into the secondary structures to simplify the main header, which will now more often be just for function definitions.

The FSS structures can use a more common base to better allow integration with separate projects that utilize the same basic design.
This is important for IKI project.
Casting to/from fss objects and contents to their respective ranges should now be possible.

Begin adding the IKI support, which is a new FSS standard focused on a simpler/smaller Wiki design.
The goal is not to handle presentation but instead to provide very simple context on certain text blocks based on some vocabulary.
A very common example would be sending a plain text e-mail with a URL in it, the URL could be encapsulated in an IKI vocabulary object to tell both the human and the computer that this is a URL.
For a URL, this is very useful in that no part of the URL need be escaped, except for the closing quote and its respective delimiter.

Example iki URL: url:"http://www.example.com/this does not exist/".
As opposed to http://www.example.com/this%20does%20not%20exist/.
The first case is easier for a human while still remaining simple enough for a machine.

The IKI syntax, at least in its most basic form, is not meant to be a full WIKI formatter.
While this may be accomplished with a sufficiently large enough vocabulary, this seems unnecessary at this time.

The IKI syntax standard itself is yet to be ironed out and ill be updated overtime until I am satisfied.

Bugfix: revert slash improvements in FSS object read

Oops.

When relocating this I completely forgot that an object starting with something other than a double quote or single quote can never be a quoted object.
Therefore only the first slash needs to be delimited.

I need to update the FSS documentation to avoid this oops again.
This will be tacked on to the todo list for when I do my extensive review of the FSS processing code.

Progress: featureless make

Continue current development, saving work to reduce any changes of accidental losses.

Cleanup: improve fss documentation

Progress: update FSS code, including zero-width updates

Update FSS to consider the recent zero-width improvements.

Making the changes reminded me on how I still need to go through and clean the FSS code up.
As noted in previous commits, the changes into supporting UTF really put the code into an unideal and not well tested state.
This needs extensive review and fixes.

To that end, I felt compelled to fix problems and perform cleanups that I observed.
At least to a small extent.

The basic and extended object reads are identical so move the code into a shared private function.

One behavioral change is to better support fail-through practice.
For FSS Extended, the contents are always terminated by a newline.
However, if there is an unterminated quote, then the entire process would previously fail.
This time, do no accept content for that line and continue on to next content.

Update: relocate utf.h code into utf-common.h and improve zero-width support

There is too much in utf.h.
Move the defines and other common things into utf-common.h.

There actually are zero-width ASCII characters (such as bell).
Fix this inaccuracy and handle all of the zero-width ASCII characters.

Newlines, tabs, and otherwise space that prints something, including vertical tabs however odd, are not to be considered zero-width.

Update: add additional f_fss functions and update documentation

Add line counting functions.

Remove unnecessary checks against negative values for unsigned numbers.
(They are theoretically necessary in that if the type was overwritten to a signed type, but for now just ignore that case.)

Finish adding or updating the *_together functions.
Review and update the documentation.

Feature: add F_recurse status code

The recurse status code is intended to be used for situations involving recursive operations.

Progress: featureless make

Continue development in featureless make, implementing support for "make" operation.

This expands the f_string project to support additional structures.
This expands the fll_fss project to utilize these additional structures.

I have reviewed and redesigned some of the fll_fss project functions.
The fll_fss project function redesign is incomplete and not fully tested as of this commit.
(I plan on reviewing and updating the *_together functions.)

The current fakefile is a stub/example for testing and will be updated to a correct default fakefile once the "make" operation is complete.
The plan is to have the fakefile provide an example for building th featureless make project using the fakefile.
This would mean that the featuereless make project can be built by the featureless make project using either the "build" or the "make" operation.

Update: package.sh clean should operate like build

The clean operation should respect the mode parameters in the same way build does.

Bugfix: invalid memory management in fll_fss_snatch_apart() and fll_fss_snatch_mash_apart().

Not sure what I was doing, but the logic is just plain wrong.

Cleanup: use the not status macro instead of the status macro with !

Feature: add fss_named and fss_set structures and re-organize the fss headers

Provide fss_named and fss_set structures (and their respective array structures).
These are useful when using FSS types nested within another set (not to be confused with fss_nest which is for a single type with recursion).

There are just too many things in fss.h.
Break it out into multiple headers that are auto-included.

Feature: add macro initializers for static string and string ranges

Creating defines with present lengths and them using these in static strings, sometimes with ranges, has become more common.
Provide the macros to make this simpler and ever be more usable for creating constant static strings and constant string ranges.

Update: ignore comment lines when processing package dependencies

Bugfix: incorrect invalid parameter check for file write for used to size comparison

The used may equal size, do not trigger an error.
Change un-reallocated dynamic strings to static strings.

Progess: begin working on featureless make 'make' operation

This adds my initial draft of the header.

Update: finish updating comment documentation and fixing any observed issues

This completes my maintenance pass that needed to be done following the significant changes introduced after developing the fake build process.

Update: only print depedencies list in verbose mode

Cleanup: remove stale fll_directory project

This project is no longer used and is empty.

Progress: UTF-8 file write should handle case where expanded character is larger than write max

When the 4-byte wide UTF-8 character is expanded into potentally 4 1-byte wide UTF-8 characters, the available bytes being expanded need to fit in the output buffer.

Update: Improve verbiage in package.sh and output current project being built in bootstrap.sh

The package.sh script should instead say "Packaging Project".

The bootstrap.sh script should output that it is building or cleaning a project and display the current project name and version if available.