Cleanup: fix order of parameters and shorten "seek_to_this".

Update the parameters to follow the practice of constants on the left and pointers on the right.
Shorten "seek_to_this" to "seek_to".

Cleanup: add comments to file.h.

Progress: featureless make.

Implement section operation "operate".
Assure that recursion to an operation already on the operation stack is prevented.

Feature: provide common string related memory increment functions.

There are a lot of string functions.
In this case, it seems worth more to use functions instead of relying on macros, given how common this is.

This does not update most of the existing code that may want to use this.
Future consideration will likely be made in regards to the array of array string types.

There is no intention to expand this process to other types.

Progress: featureless make.

I forgot to finish converting the fake_print_error() and fake_print_error_file() functions to fake_print_message() and fake_print_message_file() for the private-fake.c code.
Fix the messages with fake_print_message_section_operation_path_stack_max().

Update: header includes should be local.

I noticed that I have been, perhaps habitually, using the system include path logic for including headers in the local source.
This is dangerous.
Avoid the possibility of including headers from the system when the headers provided by the project itself should be used.

Progress: featureless make.

Begin adding support for more complicated section operations.
Add break/exit to allow for manually exiting or breaking.

The error/warning systems needed to be rewritten to handle additional situations where "fail" mode is set to "warn" or "ignore" instead of "exit".
Errors may need to be warnings or not printed at all.

I noticed that I have been, perhaps habitually, using the system include path logic for including headers in the local source.
This is dangerous.
Avoid the possibility of including headers from the system that are actually headers provided by the project itself.

Other minor fixes and cleanups.

Progress: featureless make.

Process environment variable names, enabling support for the "define" section operation.
The function isascii() is incorrectly used when isalpha() should be used for identifying a valid first character for an environment variable name.
When calling execution section operations like "run" and "shell" make sure environment variables are passed to the environment.

Fix mistake where "group" is used when "groups" and similar mistakes with other words.

Add more output when in verbose mode on completion of certain operations.
For now, just avoid color output in these cases.

Fix minor mistakes in status variable when calling error handlers.

Actually set the fail type when the fail section operation is specified.
Fix the relating error message when the fail type is invalid.

Bugfix: file change role invalid parameter on < -1.

Having tests for "< -1" resulted in false positives for invalid parameters.

It appears that the uid_t and gid_t types are unsigned.
The value -1 is simply a special case use.

Update: don't tread buffer.used = 0 as error for print functions.

Instead, return F_data_not without error bit to default as not an error while still allowing the caller to consider the situation.

Progress: featureless make.

Remove the 'create' section operation, it is effectively redundant with the 'touch' section operation.
There is still potential for having both because 'touch' section operation has additional actions that could be undesired.
For keeping it simple, I have decided to not support both 'create' and 'touch' at the same time.

Implement 'delete' section operatin and update validation.
Implement 'link' section operation and update validation.

Add 'deletes' section operation that performs a "recursive" delete which allows for deleting non-empty directories.

Bugfix: directory remove is not handling all errors.

The errno ENOTEMPTY is not being handled and is now added.
The errno EOVERFLOW is not used and is now removed.

Update the relevant documentation.

Progress: featureless make.

Implement the compiler and linker section operations.

Rename and move the fake_build_execute() to fake_execute() to be shared among both the build and the make operations.

Progress: implement modes operation with todo for recursion and fix documentation

Recursion will be written at a later date.
Just copy over the mode operation code just like it is done with owners (vs owner) and groups (vs group).

Fix a copy & paste mistake where I forgot to change the wording in the mode documentation.

Progress: get the change file mode functions in an acceptable state.

Finish writing the file change mode and related functions.
Due to significant gaps in development and the notable complexity of the ugo+rwxXst modes, this is implemented in what appears to be good enough for now.
There are likely hidden logic flaws or incomplete/missing logic.

This adds an @fixme to more thoroughly review this and possible fix this at a later date.
For now, this allows moving forward to avoid spending too much time on this one area.

Progress: continue work on mode changes

The functions were renamed and re-organized to be more consistent with the project practices.

This changeset focused on getting the number-only changes done within the time allowed.
This adds a new function for converting the f_file_mode into a mode_t for the libc chmod compatibility.

Progress: featureless make and related

It turns out I need custom functions for processing the mode like the chmod program works.
During the process of writing this I discovered several different ways chmod accepts arguments that I wasn't aware.
As a result I changed my logic repeatedly and this code is in a very much incomplete state.

This is being committed primarily to avoid losing any data (more so than usual).
There will be a lot of clean up when I get back to completing this.

Update: rename f_file_change_owner() to f_file_change_role().

Change owner implies changing the owner.
This is not strictly true, due to how the chown() and similar POSIX functions works.

Instead, these change owner and/or group.
To avoid confusion with thinking this function exclusively changes owner, use a completely different word.
The chosen word is "role".

Update: print the canonical path, if available, but fallback to the provided path if not.

The line number is printed on error, so a person can always look at the source settings to determine what the provided path is.
Providing the generated canonical path makes it clear what the generated path is.

Bugfix: logic errors in fll_path_canonical().

Make sure not to include the '/' when incrementing the size_chunk.
The code starts with '/', so be sure to designate the previous_1 as '/' at the start.

Cleanup: uppercase the first letter in the messages.

Progress: finish implementing UTF-8 *_is_digit().

Cleanup: refresh dependencies.

Update: provide fll_path and fl_environment while providing an alternative to f_path_real.

The realpath() function does not work on non-existent paths.
Provide an alternative, fll_path_canonical(), that works on paths without concern for some paths existence.

The f_environment_path* functions need f_path, so move them to a new fl_environment project.

Cleanup: relocate f_path_explode_* functions to f_environment project.

These path explode functions are in regards to the environment variable PATH.
Having these functions exist in f_environment makes more sense.

Progress: featureless make.

Initial implementation of touch operation.

Feature: add f_directory_touch() and f_directory_touch_at().

This is the same as f_file_touch() and f_file_touch_at(), except that a directory is created if the file does not exist.

Cleanup: fix typo in name.

Progress: UTF-8.

Add functions: *_is_ascii(), *_is_private(), *_is_unassigned().

Rewrite *_is_valid() functions to use the valid UTF-8 ranges.
Have *_is_valid() also check that the ASCII is valid.

Be more consistent with the use of uint8_t over short.
Use const where possible for width.

Progress: wrap up emoji UTF-8.

Cleanup: featureless make skeleton fakefile tweaks.

Add iki-0002 to the header and add "fail exit" is global.

Progress: featureless make.

The return code 0 should not trigger an error (I forgot to explicitly return from the function).

Implement the environment variable handling.
Now that it is implemented, do not manage the custom environment variables via the "define" mapping.
Instead, let the environment variables be the data storage.
This now updates the environment variables and reads from the environment variables as requested.

The parameter values are supposed to load from the build settings if not defined.
When the build settings are loaded, then allow loading from the build settings.

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