Progress: featureless make.

Implement file move functions.
- There will need to be future changes to allow for moving across filesystems.
- This move across filesystems may need to be an fll_file_move() so that it can either do a directory clone or a file clone.

Fix a typo 'perforrm', which should instead be 'perform'.

Add 'F_mount' status code.

Implement the move section operation.

Progress: featureless make.

Fix mistakes where I forgot the '!' in the parameter check comparisons.
Fix mistakes where I used 'i' when I needed to use 'j'.

Finish implementing clone.
Finish implementing copy.

Progress: featureless make.

Seems I completely forgot some basic section operations:
- copy
- move

This prepares foo implementing a copy, a clone, and a move.

It seems that there is no directory_move or file_move function, so these need to be implemented.

Update: recursive functions, fix 'const const', don't error on max recurse depth.

Rewrite the fl_directory_* recursive functions, simplifying their design.
Add a max recursion depth.
I have a toleration limit on the number of arguments in a function and this just reached a limit.
Given that many of the parameters can be logically grouped and are also are also passed to other functions, implement a new structure.
While this simply changes where the complexity/problems happen, this does alleviate the number of arguments concerns.

Fix an accidental 'const const' declaration.

Don't error on max recurse depth.
This should just stop recursing for that directory and not generated an error.

Progress: featureless make.

Implement recursive change owner, change groups, and change modes functions.
These are implemented in the fll_file project.

Then utilize these for the recursive owners, groups, and modes section operations.

Fix specification where I forgot to rename "archiver" to "indexer".
In documentation it is "indexer" and not "index" for the indexer program whereas "index" is a section operation name.
Fix documentation where I forgot to rename "archive" to "index".

A bug in fl_directory_list() was discovered where the parameter check for path is incorrect.

Cleanup: add missing dependencies to featueless make bootstrap.sh script.

Cleanup: rename linker/archiver to indexer in featureless make and tweak bootstrap.sh.

The linker program 'ar' creates an archive which is essentially an index.
By switching the words from linker and archiver to indexer, I believe that I can avoid terminology conflicts.
This avoids conflicting the 'linker' in terms of 'ar' and the 'linker' in terms of 'ln'.
This avoids conflicting the 'archiver' in terms of 'ar' and the 'archiver' in terms of 'bzip2'.

Use "return" instead of "exit" in bootstrap.sh.

Progress: featureless make.

The fake_execute() should return the "return code" for optional processing by caller.

Implement the reserved parameter IKI vocabulary name "return".

Remove the arguments.used checks inside of fake_make_operate_process(), the validation process already handles this.

Fix names for fake_make_parameter_variable_* defines.

Relocate some define/parameter documentation from specification to documentation and update the specification accordingly.

Cleanup: fix wording of documentation.

Update: featureless make fakefile build section operation should allow a custom file name.

The documentation mentions this to some extent.
Actually implement this and update the documentation.

Cleanup: featureless make example bzip2 build data settings files.

The shortcomings have been addressed.
Simplify the example build data settings files by removing unnecessary settings.
This should further emphasize how simply and easy the featureless make build operation can potentially be.

Add simple documentation to the bzip2 example build data setting files.

Feature: featureless make should support custom source paths in data/build/settings.

The standard path is used by the featureless linux library.
If any other project, such as bzip2, has its own directory structure provide a way to more likely support that when using the build operation.

This is not intended to handle all possible cases.
This is only intended to handle simple cases such as with bzip2.

For more complex builds the fakefile and the make operation should instead be used.

This adds a path_standard setting that is a yes/no boolean for designating if/when to follow the standard source path structure or not.
When this is 'yes', then the standard sources path such as 'sources/c/' is used or when -S/--sources is supplied then the path would be 'XXX/c/' when using "-S xxx/" as an example.
When this is 'no', then the sources path specified by a new setting 'path_sources' is used but when -S/--sources is supplied then the path would be 'XXX/' when using "-S xxx/" as an example.

The result of this change moves the "sources/" directory from required to optional.
This directory is no longer checked for during the check required directories process.

The bootstrap.sh script is exclusively intended to be used for compiling the featureless linux library.
Therefore, the 'path_standard' and 'path_sources' are unimplemented within that script (beyond being defined in the variable list).

Bugfix: featureless make should not attempt to link to non-existent library.

When the no library sources are specified then the library is not built.
The problem is that the code is still trying to link against this library that was not built when compiling the static program.

Update: featureless make should not autp-prepend "-D".

Having this does simplify the configuration.
The downside is that it limits the flexibility and requires compiler-specific code to be added and potentially added.

Removing the auto-prepend "-D" will reduce the amount of language or compiler specific code in featureless make.
If another C compiler exists but uses something other than "-D" for defines, then only the settings file need be updated.

Bugfix: fake settings parameter is ignored.

The default value is always being used.
Change the behavior to use the loaded settings that was processed based off of the parameter -s/--settings instead.

Update: Add some example build settings for featureless make for bzip2.

The bzip2 project has a relatively simple and small makefile and does not get updated often.
This makes bzip2 an ideal example of how to build a build settings file.

There are a few shortcomings that I believe I need to address after creating these in the fake project.
These have been documented in the example settings until I can get around to change them.

I would also like to create fakefile examples for bzip2 as well.

Progress: featureless make.

Finish writing if conditions for number operations like >, <=, etc...

There still needs to be work where numbers such as 1.2 or arbitrarily large numbers are supported.
This only provides support for integers, positive or negative, that have a max value of uint64_t, which is generally ~2^64.

Progress: featureless make.

Continue work on implementing the section operation "if" conditions.

Update: add/update functions and refactor f_file_mode to f_file_mode_t and related.

Add functions f_environment_exists(), f_file_group_read(), and f_file_owner_read().

Update function f_file_mode_to_mode(), implementing it.

Refactor f_file_mode to f_file_mode_t and related.
This appears to have been missed in a previous refactor.

Refactor: Append '_t' to all types and related macros.

After using uint8_t and similar, I have decided to adopt the '_t' notation for types.
This helps further reduce the possibility of naming conflicts.
With this change a function, for example, for file mode could be 'f_file_mode' whereas a type for file mode would be 'f_file_mode_t'.

This further allows me to change the design of the *int*_t types used as an array.
Such as renaming 'f_uint8_tss' to 'f_uint8ss_t'.

Progress: featureless make.

Continue work on the if operation section if conditions.
Looks like I needed some functionality in f_file, currently incomplete.

Progress: featureless make.

Begin working on "if" operation logic.

Make sure the return states are handled by adding a "success" boolean.

Uncomment the code where I was confused by the logic.
What seems to have caused the confusion was that the "if" condition should have been an "else if" condition.
With this change, the logic makes more sense because it is no longer checking against a modified status variable.

Update: add file type name strings and lengths.

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