Bugfix: Do not de-allocate the additional array

Do not de-allocate this array when some allocation error happens.
The data is defined outside of this function, so leave it to the caller to handle deallocation.
This allows for giving the caller more choices when trying to decided what to do on allocation problem.
For example, some program may want to try to continue anyway even if there is an allocation problem.
It will be tricky, but in such a case one would just have to make do with what is already allocated.

Update: add support for repeated parameters

Thus, something like my_function -s 0 -s 1 would be able to process both -s 0 and -s 1.
Previously, only the last -s option would have been processed.

Bugfix: checking for == on fwrite size results is not an error

The code was checking the total number of bytes written and the total number expected to be written.
If both numbers are the same, then this cannot be an error.

Update: add write append macro

This was missing.

Update: add file write support

The write functions are little more than wrappers to fwrite().

Bugfix: fix positioning output of help system

Update: add fll fss object and content write support

This adds the functions that allow for writing fss objects and contents.

Bugfix: test for eol during object write

If this is not done, then close quotes could end up being placed after a newline character.

Update: add additional error testing macro groups

This adds additional error testing macro groups that are common.

Update: implement fl basic list object and content write support

This adds the fss basic list object and content write functions.

Cleanup: only define location variable when needed

Instead of defining it outside the loop, define it inside the loop and then only in the areas where it is needed.

Update: rewrite basic list object and content read functions

Follow the new approach.
Also, it occured to me that there is no reason to support quoted object names for a basic list.

The reasoning behind this is that the basic list object always terminates on a newline and there cannot be any content on that newline.
If there is no content, then there is no reason to protect the object by wrapping it in quotes as done in basic an extended.
Quote support has been removed and as a result the implementation of the object and content reads are much simpler.

Update: return stop points even when no object/content is found

This makes a things a little more consistent.
If an object was not found, then the code would seek to the end of line or a stop point.
Prior to this patch, after doing the sleep, the appropriate object/content not found is returned when a stop point was reached.
Now, the appropriate no_data or none stop point return value is used in such a case.

Bugfix: fix return state codes for stop point

For objects, if an object was not found and a stop point was reached, return approproate f_no_data codes.
For objects and content, if a stop state was reached during a quoted group, return appropriate f_unterminated_group codes.
For objects and content, if a stop state was reached during a valid pass, return appropriate f_none codes.

Bugfix: don't write comment lines (wrap the # in quotes)

The object write functions should not write comments.
The comments are not valid objects, so if passed a leading #, then be sure to wrap it in quotes.

Update: rewrite fss extended content read function

This was rewritten to follow the same style that the object read uses.
Because content can have multiple "groups", an outer loop had to be added.
For some reason I feel like I am forgetting something or doing something wrong here, but I cannot tell what that is and so I note my concern here.

Update: use f_array_length for an array of locations instead of f_string_length

Cleanup: Use the parameter names for the fl fss write functions

After review, I think this naming scheme makes more sense.

Bugfix: initial slash + quote only needs one additional slash on match at start when writing

If the object or content group begins with any number of slashes followed by a single or double quite, only a single slash is needed to delimit the quote.
This is done because no valid object or content group can start with a slash and expected to be treated as if it were quoted.
That means the quote is meaningless.
The initial slash delimit is necessary in case the object name starts with a single or double quote but it should not be treated as such.
This for an object name of " would be written as \".

Update: add fl fss extended content write support

Cleanup: rename delimit_slash_count to slash_count

I see no reason to prepend delimit_ to the slash count.
Shrinking it makes things a little easier to read.

Bugfix: delimit whitespaces on write

I believe I had a mental lapse on this one.
The previous code was acting like a read operation in certain cases when dealing with whitespace.
When doing a write if a white space exists treat don't ignore it; instead, wrap it in quotes so that object names can contain spaces.
For example " " is a valid object name which is a object whose name is a single space.

Cleanup: update error code header documentation

Bugfix: don't forget to return f_none_on_eos and f_none_on_stop where applicable

Bugfix: remove default from switch to avoid returning f_unknown

While it is good practice to always have a default: in switch, I believe this is a case where it is not.
Do not provide a default switch so that the default return statement is always false.
This prevents having to return f_unknown at the end of the function as it is now possible to get to the end of the function.

Update: add eol return codes

Update: handle eol when doing writes

If the buffer being read from contains an eol, then do not process any further.
This prevents writing newlines without ignoring them entirely.
This returns f_none_on_eol, which does not exist yet.
A commit following this one will add the eol return codes.

Bugfix: add buffer overflow checks

When I added the input parameter to the write functions I forgot to do buffer size checks now that the input size could be different than the buffer size.

Cleanup: remove fss_basic.h include

This is not needed here, so do not include it.

Update: add fss extended object write function

This is identical to the fss basic object write function.

Update: rewrite the basic and extended read functions

This should hopefully fix some slash delimiting weirdness I thought I was seeing.

Update: rework the basic write to accept a string location argument

This should make things more consistent with how the basic read functions work.

Cleanup: Remove () from while comment

The end of a while loop comment will no longer have open close parenthesis.

Thus:
  while (f_true) {
    // ..
  } // while()

Now becomes:
  while (f_true) {
    // ..
  } // while

Cleanup: add space between while(

Fix syntax style to have a space after while and before (.

Cleanup: put space between do{

Fix the syntax style to have a space between do and {.

Cleanup: put a space between switch(

Fix syntax style mistake where switch( did not have a space after switch and before (.

Cleanup: mass change ){ into ) {

I have decided that the syntax style should have a space between ){ from now on.
I did this change in mass via a sed script.
I did not notice any incorrect changes, but there is more to review than I am willing to review.

Bugfix: process quotes at the start of a basic object

This was overlooked.
If the first character is a single quote or a double quote, then it must be delimited.
If the first character is a slash, followed by any number of slashes and then followed by a single or double quote, then all slashes and the quote must be delimited.
Starting slashed that are not followed by a single or double quote must not be delimited.

Update: add write support for fss basic

This adds the write functions for converting a dynamic string that represents an fss basic object into a valid object.
This adds the write functions for converting a dynamic string that represents an fss basic content into a valid content.

Update: use the error code source name instead of a human friendly name for error code translation

The human friendly variant is more convenient, but it is probably better to use the machien name directly on error output.
This should make things script-friendly and also allow for distinguishing something simimarl to f_my_error and fl_my_error.
With f_my_error and fl_my_error, using the previous method, both would report as "my error", when in fact they are different errors.

The down side is that this now requires 1 more step to convert the codes into a human friendly name.

Cleanup: remove useless code

I was considering to use status to return true or false, but later changed my mind.
There was a line of code where I was initialize status, this code is no longer needed.

Bugfix: correct linkage agains fll_execute

The fll_execute used to be fl_execute, when it was changed the projects that depended on it did not get changed.
This updates the build settings to link to the proper library.

Bugfix: use proper parameter data type

f_array_length should be used and was not being used.

Update: rename *error_code projects to *return_code

This should make the applications make a little more sense.
That is, when testing for not-error codes, it makes more sense to say not-error return codes than to say not-error error codes.

Update: add support for identifying errors, warnings, and okays

Add three new parameters: is_okay, is_warning, and is_error.
These should test to see if the error code is in fact an error, a warning, or not an error.

Update: change return codes enum to start at 131

This should makes things sort of compatible with bash shell scripts.
Bash limits its return states to 255, so the fss return codes may still not always function..
This at least allows for some sort of compatibility.

Cleanup: don't use f_console_standard for stuff outside of f_console

This was probably a copy and paste accident where the define names were not properly updated.

Add Package: firewall

This package was missed during the conversion from svn to git.

Update: add support for building settings data

The settings data (which is different from the build settings data) is now supported.
This is data that goes in /etc/ or /share/.

Update: do not provide a default pipe argument afterall

Now that I have learned how to read pipes, this usage parameter that I guessed about is not needed.

Add Package: fss_error_code

This is the handles translating fss-specific error codes to strings.

Add Project: error_code

This is a cli front end for the error code to string translation.
This only translates standard error codes.

Update: process f_unknown

In an ironic twist, the f_unknown error code was no translated into a string.

Update: return the literal error code

The error code was being converted into 0 if the code was f_none.
Stop doing this behavior, all the scripts need to be fll return state aware from this point forward.

Bugfix: set error code to invalid parameter when parameters are missing

Bugfix: include library build directory when compiling

Include the local library path so that the built libraries can be pulled in.

Cleanup: update version numbers to 0.3.x (again)

Looks like there have been even more version numbers that were overlooked.

Update: add fss_error level 2 functions

Provide fss-specific error code to string translation.

Add Project: fl_errors

Add the level 1 errors project that provides error code to string translation for standard error codes.

Cleanup: macros in f_errors should be f_errors and not f_error

Be consistent.

Update: add buffer_too_small and buffer_too_large error codes

This could come in handy and is more generic than string_too_small and string_too_large.

Bugfix: fix logic flaws with file input buffers

The first mistake made was that when adding the fread result to the buffer, the actual size of each read byte needs to be taken into mind.
If the characters were wide characters with a byte size of 2 instead of 1, then the buffer->used counter would increase at a rate of 2x of what was actually in use.

The second mistake made was that the fread max read size was being set to the entire buffer size instead of what was available.
This should have been producing some sort of buffer overflow, but none was reported.
Instead of request a read of (buffer->size - 1), only request a size
equal to that of the available allocated space (buffer->size - buffer->used - 1).

The third mistake made was not performing sanity checking on the buffer->used and buffer->size variables.

Bugfix: add missing return statements

The new hidden/internal functions did not have the final return statement.

Cleanup: change version numbers to 0.3.0

The internal version macros were not updated when the fll projects were mass moved to 0.3.x.

Update: add support for accepting pipe values

Data can now be piped to the fss_*_read functions.
To make this practical, this adds and uses a hidden/internal functions.

Update: add support for reading from fifos

In particular, this is used for reading from piped files, namely stdin.

Add Project: pipe

This adds the level 0 implementation of project pipe.
At this time, all it does is provide a way to tell if the current instance of some program has piped data being passed to it.

Update: add all types of file open modes

This also changes f_file_read_write to not create the file if it does not exist.
To create the file if it does not exist, use f_file_read_write_create.

Update: add f_file_stat_error

Update: add pipe console parameter

The fll standard console arguments now inclide +p, ++pipe.
This pipe command requires a single numeric argument that represents the size of the pipe.
When this is specified, it tells the application to read from pipe in byte chunks of the specified size.
The default pipe size is left up to the application when this is not specified.

Cleanup: remove duplicate string.h include

Update: implement fll_execute_program and fix fll_execute_path

This adds fll_execute_program and changes how fll_execute_path works to function properly.
Prior to this change, fll_execute_path did not set the first argument which would cause the programs argv[0] to not be equivalent to the program name.

This also corrects a few mistakes where level_1 syntax and comments were not changed to level_2.

Update: rework and cleanup serialized project

Simplify the serialize functions by:
- replace f_serialized data type with f_dynamic_string
- remove the serialized strategy and change serialized function names to communicate the strategy.

Fixed a few logic flaws and mistakes with the serialized functions.

Bugfix: fix definition of array_length_printf macros

Use ifndef and not ifdef for _di_f_array_length_printf_ because using #ifdef _di_f_array_length_printf_ is completely wrong.
Use #define and not typedef as these are not data types, but instead are strings.

Bugfix: add support for specifying c and bash files paths

Update: change version number in settings file to 0.3.0

The version number in the settings files is the actual version number of the given project.
Assign this value for all projects to 0.3.0.
All micro releases will have their micro number changed immediately prior to officially releasing a given micro version..

Update: rename/move fl_execute into fll_execute

This is done so that it can utilize some level_1 dependencies, such as fl_serialize.

Update: switch to 0.3.x version

This is now the development release series 0.3.x.
The version number for the source files will now end in an x instead of a number to make project management simpler.

Bugfix: -t -n (somename) should show total of (somename) not all objects

This fixes an oversight or logic flaw where the total count was returned in all cases.
When a specific object name is requested, the total count should be the total number of objects that match the given name.

Bugfix: fix the argc argument for the *_read_main() functions

The commit 8fef4128c71a3010d4facf05f0d801118add5f7a changed the argc argument from f_s_int to f_array_length.
The header files were not updated and thus making the header definitions inconsistent.

Bugfix: build headers first

It is entirely possible that building the headers first is the smarter thing to do.
Afterall, the source files may in fact actually use the headers they provide.

Bugfix: do not report build operation as invalid if the project has already been built

Print a warning instead of the invalid error message.

Update: improve operation parameter problem verbosity

Distinguish between failing because of invalid operation, failing because of multiple operations, and failing because no operation was given.

Update: add *_printf functions

These help make it slightly easier to use the correct data type when doing printfs on length types.

Update: add wide character and wide string format pointers

Update: remove invalid format pointers

long long double, long long float, and long float are not valid C data types let alone valid printf commands.

Update: add signed and unsigned short format pointers

Cleanup: move the location of _di_string_format_pointers_

Bugfix: there is no such thing as signed/unsigned double

Leave the signed and unsigned typedefs for convenience and compatibility purposes, but change the types to valid C data types.

Update: relocate the 'strategy' variable

Why waste space by putting the strategy in every variable.
Sure it can be very convenient and is probably a good object-oriented approach, but favor simplicity in this the variable typedef.
The cost of doing this is making the function call less simple by adding an additional parameter.

Add Project: fl_serialized

Add Project: f_serialized

Update: improve FORCING memory allocation strategy macro handling

Do not alter the function disabling macros.
Allow for forcing secure or insecure on individual blocks of code by removing the function disabling macros.

The following should not be possible:
  int main(){
    normal_allocations();

    #define _f_memory_FORCE_secure_memory_
      secure_allocations();
    #undef _f_memory_FORCE_secure_memory_

    do_stuff();

    normal_deallocations();

    #define _f_memory_FORCE_secure_memory_
      secure_deallocations();
    #undef _f_memory_FORCE_secure_memory_

    return 0;
  }

Update: initialize string locations to {1, 0}

This is done so that the start position is always after the stop position.
In such a case, this means that the range is undefined.
Originally. -1 was used, but that does not work if the position integers are unsigned.
Using {1, 0} allows for assigning an undefined state with unsigned integers.

Also note that the default of {0, 0} means start at 0 and stop at 0, which would return the value at position 0 and no other values after that first value.

Update: add f_array_length_small and f_array_length_large

This adds short and long versions of the f_array_length typedef.
Having this provides additional context granularity so that the size of arrays can be more easily adjusted to suit ones needs at compile time.

Update: replace f_string_length with f_array_length  where appropriate

The f_string_lengths length variable should be an f_array_length (this would otherwise be called f_string_lengths_length)
Replace all code that used the f_string_lengths length variables with f_array_length.

Update: add f_array_length typedef

It makes more sense to define a default array length size variable instead of using things like f_string_length for the lenght variable that represents string lengths.
It is also easier to read than doing something like f_string_length_length.

Add Project: f_paths

This was missed during the import.

Import Commit: mass import build settings

Add Script: generate

This is the generic bootstrap build scripts for the FSS project.