Progress: continue cleaning up comment documentation, fixing discovered problems

In particular, the fl_socket (which needs to be reviewed for being moved into f_socket) needed to be documented and had some issues to resolve.

Bugfix: individual bootstrap example does not handle errors properly

Double-Ampersand before a for loop does not work well in bash.
Instead, return result to detect error before attempting to operate for loop.

Progress: remove fl_file, more comment documentation cleanup and fixes

The fl_file project has been empty for some time, fully remove it.

Continue the work on updating the comment documentation.
Fix any observed problems.

Begin using the "Errors from .." style to simplify comment documentation maintainability.

Update the bootstrap-example.sh script, adding support for building the fake project as an example.

Cleanup: add .txt extension to documentation

This will make it convenient as well as consistent as the other documentation that also uses the .txt extension.

Update: allow multiple modes to be specified in the package.sh script

Update: documentation cleanups, fix observed problems, retun F_data_not without error bit

Organize the return codes.
Fix any probles in the commend documentation that I happened to notice.
This is not complete, there will be follow up commits to address more cleanups.

I noticed that there were some public directory functions incorrectly have 'private_' in their name.

The conversion functions should no longer consider no data an error.
Just report that there was nothing to do.

Update: documentation, also use fss-0002

Fix the documentation to clarify that the --work paramter is, in fact, more different than --prefix parameter.
Update the tree examples to show both the build directory tree and work directory tree.

Switch to using the fss-0002 format for all of the documentation files and specification files.

Update: main readme documentation.

This documentation is in an FSS format.
The other documentation files will likely be converted to the same FSS format in the near future.

Bugfix: build directory should be created if needed and not pre-required in all cases

Don't optionally required the build directory.
Always create it when needed, so do not require it.

Update: implement --process parameter

Looks like I forgot to implement this.
The --process parameter is a process name that is prepended to stage file names for the purpose of granting the caller additional flexibility.

Update: add Featureless Make documentation and specifications

This is a good starting point for the documentation.
I may or may not add more at a later time.

Cleanup: fix ordering of path_language

Cleanup: remove project_level setting

Remove this stale code.
This was mostly removed already in previous commits from the settings.
This was replaced by the path_headers setting.

Bugfix: mispelling in search_exclusive

Update: bootstrap dependency functionality, fix missing dependencies, also ensure level and monolithic

It seems I wrote a dependency generator to make my life easier and then I went and forgot about it.
Update this to work with the more recent changes to the build settings structure.

While I am at it, generate all of the dependencies and save the generated dependencies.

This exposed a typoe in the dependencies file, now fixed.

Might as well make sure the level and monolithic dependencies are generated as well.

Update: add documentation note about the bootstrap-example.sh script

Cleanup: rename generate.sh to bootstrap.sh

The generate.sh is a bootstrap for each individual project.
Officially calling it the bootstrap just makes sense.

Cleanup: rename bootstrap.sh to boostrap-example.sh

Cleanup: rename generate to bootstrap

The generate script is now officially a bootstrap script.

Update: add new documentation, improve existing documentation

Cleanup: rename work_directory to work

This makes the parameter consistent with the generate.sh script.

Update: rename readme to readme.bootstrap

Cleanup: ordering of function names and add spaces before function instantiation open brace

Update: support copying documents, licenses, and specifications per project and do some cleanups

Individual projects, specifically programs (level_3), may have custom documentation, licenses, and specifications.
(With custom licenses being least likely because this project in its entirety is under lgpl.)

Add support to all projects just for good practice.

Cleanup ordering of function names and add spaces before function instantiation open brace.

Update: Featureless Make needs to handle the -d/--define parameter

Rename the parameter from defines to define, because it acts on only a single parameter at a time.
The -d must be specified multiple times to get multiple defines.

When -d/--define is specified, the defines provided by the settings file get ignored.

Continue to pass the defines from the console parameters to the process scripts.

Update: add missing handling of defines_all, defines_shared, and defines_static

Bugfix: shared library link names are incorrect

The standard link names are:
  libfake.so -> libfake.so.0
  libfake.so.0 -> libfake.so.0.5.0

Instead, I had:
  libfake.so.0 -> libfake.so.0.5
  libfake.so.0.5 -> libfake.so.0.5.0

While I am at it, make these links reflect the version_target setting.
If target is major, then standard link names above are followed.
If target is minor, then:
  libfake.so -> libfake.so.0.5
  libfake.so.0.5 -> libfake.so.0.5.0
If target is micro, then:
  libfake.so -> libfake.so.0.5.0

Cleanup: add build_language setting

This defaults to C, so there is no issue if it is not defined.
Still, it should be provided as the default in the FLL project.

Cleanup: remove unnecessary S from function names

The building only builds a single program and a single library.
The building of objects builds multiple objects, so the S remains for that function.

Feature: add version_target setting to Featureless Make and FLL generate script

I noticed that I had a different linker version string between Featureless Make and the FLL generate script.
After reviewing and fixing, I decided to make this a customizable option now called version_target.
The default, traditional behavior, is to use only the major version.

A major version target would link like "-Wl,-soname,libfake.so.0".
A minor version target would link like "-Wl,-soname,libfake.so.0.5".
A micro version target would link like "-Wl,-soname,libfake.so.0.5.0".

Update: change settings structure to follow the Featureless Make structure

The existing design is based on the bootstrap scripts.
The bootstrap script is now updated to the new design so these scripts can now be updated to the new design.

Update: readme

Update: redesign to follow the Featureless Make design

Use the setting names specified by Featureless Make, which are a bit more generalized than the current generate.sh design.

This does not fully follow all of the Featureless Make functions.
Only what is necessary (or already implemented) to bootstrap the entire FLL project is done.

Cleanup: remove redundant adding of library_flags setting

This should have been removed when I moved the code into fake_build_arguments_standard_add().

Update: implement the bootstrap.sh

Bugfix: incorrect is_library boolean during build process

These are set incorrectly, resulting in using program_flags for library and library_flags for program.

Bugfix: don't produce extra errors on certain build errors

Cleanup: switch to simpler color context strategy

Use a simpler color context strategy.
This helps avoid the need to alter the recursive function output.

Cleanup: typo in directory

Bugfix: do not consider a non-existent build directory an error during clean operation

The clean only cares about deleting all of the files in the build directory.
If that directory does not exist, then there is no issue.
When in verbose mode, print a message about the directory not existing.

Bugfix: filename without extension not terminated and compiled objects need subdirectories

When generating the filename without the file extension, terminate the string.

When library sources are specified using subdirectory paths, object files should have the same subdirectory structure.
This only applies to object files because they are compiled using the same naming structure as the sources.
The rest of the compiled code is compiled into a new structure, which is generally a single library or program.

Bugfix: invalid memory access and only process if not empty

If the path_headers is not defined, an invalid memory read was triggered.
This happens because I was only assigning path_headers variable when path_heades setting was defined but I was still attempting to copy that path regardless.

Make sure to not bother attempting any copy or compile build operations if that setting has not properties (such as build_sources_program being empty).

Cleanup: remove no longer used scripts

Progress: featureless make

Finish writing static compiling.

Simplify some of the code, moving repeated code into functions.

Get rid of process build path, it is no longer to be used.

Cleanup: remove unnecessary -lfake in flags_program

The recent fixes made this unnecessary.

Progress: featureless make

This gets the shared library and shared program compiling working.
The fake program can compile the fake binary and that fake binary can do the same.
This is great progress.

Bugfix: do not embed libraries into program

The generate.sh script design seems to be adding the library sources into the program.
This effectively makes the linked library.
This is a bad compiling and linking design and a waste of space.

Instead, add a link option to the project name so that the library gets linked to by the program.

Progress: Featureless Make

Remove no-longer used or planned to be used defines.

Switch to fl_string_dynamic_terminate_after().

Add color context to certain verbose messages.
(The recursive remove needs to replaced due to nftw() being too limited.)

Complete the compile shared library function.

Bugfix: correctly calculate terminating null for fl_string_dynamic_terminate_after()

Bugfix: memory leak in f_execute_*_environment() functions, handle no-slash case, fix memcpy()

I failed to clear memory on some return on error cases.

Using "sizeof(f_string_length) *" in memcpy is nonsense here, its a char, which is size 1!

When there is no '/' in the path, strrchr() return 0.
In this situation, just consider the entire path the file name.

Update: add f_path_extension_separator

Progress: featureless make

Handle the script sources differently than the bash sources.
The bash sources, a scrript, is for generated/processed (and the how is yet to be defined).
The more general scripts are meant for already prepared scripts not modified by this program (unless modified by some pre-process or post-process script).
The more general scripts does not care what the file is, it just gets copied over into the build scripts program path.

Add build_script yes/no setting to conditional include the general scripts when building.

Slightly rework the logic when processing the build operation functions.
Add the planned functions as stubs, to be completed in a future commit.

Progress: featureless make

Add stage files where stages are recorded to allow very basic build resuming.

Prepare the code for doing the build.

Update: f_file, add f_file_touch() and f_file_touch_at(), F_search error

Minor updates to f_file project.

Add the f_file_touch() and f_file_touch_at() functions.

Add the status code F_search (used by f_file_touch() and f_file_touch_at()).

Progress: featureless make

Fix a mistake in the naming conflict for with the language enum and language defines.

Implement a more generic build copy function.
Improve file copying support.
Add verbose copy messages.
Copy the C and C++ header files.
Rename fake_build_settings to fake_build_setting to properly follow this projects naming convention.
Add missing dependency for fl_directory.

Language-specific support setting "build_language" is implemented and provides a way to specific which language to use.
This will default to C.

Update: ensure string parameter tests exist and add f_file_name_base() and f_file_name_directory() functions

I seem to have forgotten that f_string is a char * and should be checked to not be NULL.
I think I removed these during a cleanup process, so add them back.

The basename() and dirname() functions need to be suppoted.
They require extra effort because as per the POSIX standard, parameters are modified.
This is undesirable so protect the parameters when calling.

Cleanup: make f_string_eol and f_string_placeholder a string instead of a char

In the back of my mind I keep reading f_string_eol as a string.
It is not.
Instead, it is a character.

To prevent this potential confusion, just make it a string and require the use of f_string_eol[0].
Make the same kind of change to f_string_placeholder as well.

Progress: featureless make

Move the print functions to their own private files (private-print.c and private-print.h).

Have the build operation create the build directory skeleton.
Have the build operation copy the settings files over, if specified in the build settings.

Update the code to be in sync with recent FLL changes.

Update: pipe and fifo, replace f_directory_mode with f_mode, f_file_copy()

Stick to only using fifo terminology in file types.

Replace f_directory_mode with f_mode, a global type to be shared between f_file, f_directory, and anything else.

Update f_file_copy() to use f_mode instead of mode_t.
This allows the caller to just send the mode.
The copy function already stats the file and processes it per file type, so it can make the decision on which mode to use.
This alleviates the need for the caller to also perform a file type stat check.

Update: todo documentation, directory copy and clone functions, update comment documentation

Update the todo.txt documentation.

There needs to be directory copy and clone functions for copy the contents of a source directory and not the directory itself.
To that end, add new *_contents() copy functions.

The comment documentation for clone was never updated and is incorrect.

Progress: add more directory and file related functions, other changes

This was started with the intention of providing all of the *_at() functions.
However, the POSIX spec seems to fall short in many areas making this more difficult than this should be.
I partially rolled back some of the planned changes and this changeset is the result.

I have observed that the function return documentation needs to be updated, but this will be done at a later time.
There will need to be some intensive testing later on but for now I am committing and moving forward.

Progress: featureless make

Get umask at start (done at start to limit the non-atomic nature of the poorly defined POSIX umask()).

Begin setting up for directory copy operations.

f_file_create() no longer accepts de-reference parameter.

Update: file and directory improvements, finish writing directory copy

Organize directory header structure, adding directory_type.h.
Add additional directory structures.
Directory copy needs to report what fails, so provide a structure for reporting each failure.
(There needs to be a verbose function for printing success/failure.)

Remove de-reference from numerous file functions.
POSIX denies certain operations of symlinks.
During copy operations, do not apply mode to symlink as it would now apply mode changes to the de-referenced link.
Allow block size to use default block size if set to 0 (convenience).
Add missing return statement to file copy (without it socket file types would incorrectly report F_unsupported).
Add link read functions so that symlink information may be obtained so that it can then be copied.
Add comments about poorly written umask() as per POSIX standard (at least according to manpages).

Other minor fixes and cleanups.

Feature: add push and pop directory functions

These functions should help make appending interactive or user-data for directory path building easier.

Cleanup: remove unused header

Update: minor improvements, finish f_file_copy(), add fifo file type

Finish implementing the f_file_copy(), adding support for all file types (except unknown).

The documentation for block, character, and FIFO is unclear to me at this time and my attempts to copy using mknod(2) is an educated guess.
Attempt to prevent file type from being passed via the mode_t when doing a copy (currently untested).

Add the appropriate file create functions to implement the copy operations.
Have the copy file copy only the directory itself and not the contents (to copy contents, the fl_directory_copy() function should be used).

The added fifo type is pretty much the same as pipe.
Mixing fifo with pipe terminology ended up being confusing so I opted to create redundant FIFO types to simplify the readability.

Use the word "regular" for a regular file instead of "file".
Using "regular" is a less confusing than using "file" (i.e. Regular File Type vs File File Type).

Cleanup: Replace F_file_open_not with F_file_closed, add additional status codes for consistencies

Socket was not fully converted into basic status codes (not having connect).
I can see future work in sockets whee I may actually add connect codes back, but I won't know until I spend dedicate time on it.

Add additional status codes that should probably exist for consistency purposes.

With F_file_open_not removed, split behavior into two checks:
- F_file for file descriptor errors.
- F_file_closed for file not open errors.

Cleanup: update all status codes in line with recent refactor and fix issues

This primarily puts all of the status code handling in alphabetic order.
The length sizes are updated accordingly.
Be consistent with S at the end of things, whereas S is not the traditional grammatical use but instead implies a set of.
Use the base F_* disable defines instead of using new ones for each level when they are specific to the F_* status codes.
Add additional comment documentation.

Any issues observed resulting from the refactor were also fixed during this change.

Refactor: use capital F, FL, and FLL for status codes to avoid potential conflicts

By only using the first part, the annoyance of all uppercase can be avoided.
This then allows shortening the names and removing words like "_error".
Also restructure where the "_not" are placed (placing them immediately after what they apply to).

This will be followed up by a restructuring commit.

Update: get the level_3 / programs working after major file / directory changes

This required making some fixes in the files related code.
This puts the UTF-8 file (utf_file) project notably behind an additional work is necessary to get that working correctly as well as having it be consistent with f_file.

I've decided that when written pointer is 0, then the caller is requesting to not get back the written size.
I am very likely going to do similar behavior with null pointers in other uses, which will help further simplify the design.

Other minor changes.
Of particular note is moving flags into the f_file structure.
This was effectively how the pre-file redesign worked, but it uses flags now instead of the "r", "rw", "a", etc.. string modes used by fopen.
Make sure an append flag is available.

Progress: continue redesign of file and directoy structure

This gets the code in a state where I can focus on updating all of the programs (level_3 files).
The UTF-8 related types have @todo and @fixme as I intend to come back later and finish them.

Progress: major redesigns with file and directory handling, this changeset is incomplete

In the process of writing the directory copy, I realized I needed to improve the file and directory management.
This triggered me to rethink how I was handling files and directories to some extend.

If memory serves me correctly, the POSIX 2008 was either too new or non-existent when I first wrote some of this.
Updating to use the newer POSIX functionality and changes seems worth this major change.

Add additional file functionality.
Lots of re-organization and redesign.

I still haven't finished this and would rather commit now, with incomplete code randomly throughout, than risk losing any changes.
In particular, the fl_utf_file is where I need to resume.
I need to then update all of the level 3 programs to use the new file/directory handling code.
After that I need to finish writing the directory copy, which should include investigating and implementing file copy operations for more than regular files and symbolic links.
I also need to remember to investigate copying hard links as a hard link instead of as a duplicate file.

Update: add additional file functions, fix bug with file stat in f_directory

Add additional f_file functions, move commonly shared code into private f_file files.

The f_directory functions were incorrectly using sizeof().

Progress: featureless make

Add and validate modes from the build settings files.
This provides some data integrity support.
If a mode is not defined in the modes property of the build settings, then that mode is not valid and the build process is stopped.

Bugfix: incorrect return status resulted in mistaken status handling

Progress: featureless make

Snatch apart the settings strings instead of mashing them together.
Process the environment build setting to enable selecting additional environment variable to expose to the process scripts.

Cleanup: fix build issues relating to build settings

Get the individual builds back in working order in regards to build configuration.

Update: add path expode using normal order

Oops.

For reasons unknown to me, I seem to have written the path explode in reverse order.
The path is intended to be processed from left to right.

Rename the old functions appending _reverse to their name.

Progress: featureless make

Update: numerous changes, most notably path and vfork to fork changes

Replace vfork() calls with fork().
- I have determined that vfork() is not safe.
- When calling clearenv() inside a vfork() child process, the parent process' environment ends up getting cleared as well!
- The child can alter the parents memory according to manpages, so stop using vfork() entirely.

Add path processing functions and related defines.

Enable path processing to allow for execvpe()-like behavior can be implemented.
- The execvpe() function is not used because it is not POSIX.
- Manually process the PATH environment to determine what to execute, even when PATH enviornment gets cleared.

Some consistency improvements in defines, such as f_console_max_size to f_console_length_size.

Fix mistake in memcpy usage, dynamic strings use char * for their string so passing & is incorrect.

The f_file_exists() is using access().
- This is misleading and incorect.
- Use stat() to determine if file exists because it doesn't require access to the file (aside from directory access) to check existence.
- Add a new function f_file_access() as the old implementation of f_file_exists().

The fll_execute programs now support additional functions for clearing environment variables.
- This effectively sandboxes the environment variables before calling the program.

Progress: featureless make

In particular, defines file to skeleton build.

Cleanup: remove f_string_eos, use 0 instead

I originally created f_string_eos, so that it could be potentially changed.
In the case of basic strings, using 0 is simpler, more consistent, and safer.

Update: add environment functions, add static strings, and other changes

Add environment project and associated functions for managing environment variables.
Add execute functions for setting environment variables.
- More work is needed to search the PATH to perform fll_execute_program_environment when PATH is not to be defined.

Provide stub define build settings files for each project.

Miscellaneous minor fixes/tweaks.

Progress: Featureless Make

Implement skeleton operation.
Simplify parameters and enforce a more standard structure on 'build'.
The "make" operation with its "fakefile"s can be used for more flexible project structures (at least once it is written).

Update: additional file functions, relocate function locations, add path separator length define

Progress: Featureless Make

Update: add directory functions, file functions, and status codes

Update: add path.h headerr

Update: finish the @todo in errno handling of recent directory additions

Progress: further work in Featureless Make, implement cleanup operation

Update: new directory related functions, file function updates, status code updates, directory level restructuring

Numerous updates to get the directory functionality better hashed out.
Some of the directory functionality is experimentally added.

Progress: continue work on fake (Featureless Make)

Update: add boostrap.sh stub and add readme.txt document

Feature: add f_utf_string_static as a non-allocated alternative to f_utf_string_dynamic

The is the UTF-8 string equivalent of the f_string_static type.

Feature: Add string assure functions to assure a given string exists at the beginning or the end

This is particularly useful for assuring that a "/" exists and the end of generated path strings.

Revert "Refactor: f_print_string_dynamic to f_print_string_static"

This reverts commit f225f4059d0e082a7bfae29e042a2120ac4bda33.

It occurred to me that this would make the function names more inconsistent.
This could get very confusing so just stick with "dynamic" in all the names.
"dynamic" is the original term and "static" in isolation is a reserved word.

The type names will remain as both f_string_static and f_string_dynamic.
That inconsistency is desirable due to the explicit meaning communicated by their names.

Refactor: f_print_string_dynamic to f_print_string_static

Refactor: all constant dynamic strings can be safely changed to static string

This is just a mass regex change.
There may need to be function renaming and re-ordering at a later time.

Feature: add f_string_static as a non-allocated alternative to f_string_dynamic

That is not to say that a dynamically allocated buffer cannot be placed in its string part.
Instead, it communicates that this is not never be allocated or deallocated directly.

This is implemented in such a way that f_string_dynamic is a sub-type of f_string_static.
This should allow for easy type conversions.

Progress: pass coloor modes and verbosity to build pre-process and build post-process scripts