Update: Add f_conversion unit tests.

There are far more permutations than what are handled within this commit.
Focus on only the most basic set of checks to write the unit tests for.

There are problems with mocking fwrite_unlocked() via the wrap strategy used by the linker.
I do not know why this is not working so I commented out the code and moved on.

Several problems are exposed and are solved.
- This exposed the fwrite_unlocked() return results problems.
- Add support for big endian (untested).
- Zero values are not correctly built (see below).

Make sure to count the zero number as a single digit.
Get rid of the "used" count and rely only on the digits.
Do not include the 0 digit when determining the padding.
Change the prefix append function to accommodate 0 and consistently call the prefix append function.

Update documentation comments.

Cleanup: Add newlines before continue statements.

Bugfix: Incorrect return result for fwrite_unlocked().

The return result for fwrite_unlocked() is not negative one.
Zero or some value less that the length is returned.

An error occurs when the return value is smaller than the given string length.

I likely confused write() return results with fwrite_unlocked().

Cleanup: Make failure mock boolean a constant.

Bugfix: Incorrect string is being printed on error message.

Cleanup: Unit test header macros should end in an 'h'.

Cleanup: Use correct project name.

Update: Add f_control_group unit tests.

Progress: Continue working on implementing control and controller programs.

The control program and the controller program will communicate using datagram named sockets.

Cleanup: The documentation.

Update: Code cleanups and return explicit error code when needed to.

There F_parameter (with error bit) is now returned.

Update: Fix incorrect documentation and remove pointless code.

The documentation for some functions do not accurately reflect what the documentation does.
This is likely a copy and paste over sight.

The f_string_dynamic_resize() is adding one to destination->used.
It then updates the used to be that new number minus one.
This is pointless.
Don't bother with the "total" variable at all.
Also use the F_memory_default_allocation_small_d by rather than 1 when resizing.

Update: Use libc functions more in f_color.

The f_string_dynamic_increase_by() guarantees the size is allocated.
The f_string_dynamic_append() doesn't need to be called when the simple memcpy() can be directly called.

Doing this saves the status check and the additional function calls.
This likely increases performance but this performance increase potential has neither been tested nor confirmed.

Update: Add f_console unit tests.

I did not handle all possible permutations for the f_console_parameter_process() tests.
I instead went with a good enough for now approach.

Bugfix: The f_console project after writing unit tests.

Rename has_values to values_total to better communicate the intent of the property.

Expand out the macros across lines.

In f_console_identify() the strnlen() function is not properly handling when the character pointer is NULL, resulting in a segfault.
While this might be considered a bug in strnlen(), just make sure that a NULL pointer is not sent to strnlen().

Miscellaneous code structure cleanups.

Replace allocation macros with actual functions.

Update: Console parameter macro, console structure organization, and add initializer for some integer types.

The integer types don't generally need this but for consistency reasons try to always have the initializer defined.

Cleanup: Add back the two spaces before the "-" in the comments.

When in the comments with the " * " at the start, the behavior of not having the extra space seems fine.
When looking at the documentation and specification FSS files, I find that it is easier to read with the extra spaces.

I have decided to switch back and follow what I am doing in the documentation and specification FSS files.
This makes the style more consistent.

Cleanup: Add period at the end of comments.

Update: Rewrite f_color functions and use f_string_static_t instead of f_string_t for global constant strings.

Switch to using the f_string_static_t so that the size does not have to be constantly tested via an strnlen() or similar call.
The f_string_static_t by default uses 64-bit types for size and used so there may be a performance hit due to this over the normal 32-bit numbers in strnlen().

Originally macros were used to reduce code repition.
This was done long before I decided to make f_string an exception that can be depended on by all level 0 projects.
The dynamic string functions can now be used, significantly simplifying the code.
The macros can be replaced with functions 1 through 5 to allow for only passing the required arguments.
This should reduce the cost of the function call by having fewer arguments when not necessary to have them.

The documentation comments are now present when they were not before.

Change the order of the function parameters to be more consistent with the latest practices.

Update the unit tests.

Update: Use F_number_t_size_positive_d for F_string_t_size_d and update #ifdef structural logic.

Cleanup: Use += operation when possible.

Cleanup: Add additional initializer for f_string_static_t to allow initializing all parts.

Another acceptable practice is to set the used to some value greater than zero and size to zero to better designate that this is a static string and is not dynamically allocated.

Cleanup: remove unnecessary #undef.

Update: Add parameter checking to unit tests and fix ordering.

Cleanup: Fix ordering of comment.

Update: Add parameter checking to unit tests, fix ordering, and other minor changes.

Cleanup: Rename f_account functions in attempt to be easier to read.

I originally tried to group the logic by "name" and "id".
This becomes confusing when there is "group name" and "user name" or "group id" and "user id".
The function name with the structure "f_account_id_group_by_name" is intended to be understood as get id of group by name for account.
However, because account is in front (part of f_account) it could be easily misread as get account id by name with some spurious "group" injected.
This is clearly a bad interpretation but that interpretation is easy to think of.

Drop "user" because "account" and "user" should be synonymous.
Move "group" to the left in all cases to designate that this is about "group" associated with account.
Now f_account_group_id_by_name sounds more like get id of group by name for account.

Update: Add parameter checking to unit tests, fix ordering, and other minor changes.

Update: Add f_color unit tests.

Bugfix: Fix problems exposed by unit testing.

The default f_color_format_t_initialize should still be provided.

Remove redundant context->set.warning assignments.

Change the logic to not require format strings to be defined thereby avoiding potential segfaults.

Avoid using strnlen() and instead use memcpy().
More memory is used when specifying the sizes, but strnlen() calls probably does this to some extent.
Doing this reduces the number of calls to copying ranges of strings.

Update comments to reflect latest practices.

Progress: Begin designing contoller to control socket communication.

This includes some significant structural re-organization of the controller project.

Bugfix: Improve include and wrapping macros.

This should be "payload" and not "basic_list".
Update the documentation comment as well.

Update: Lay out the foundation for proper endianness support.

The endianness support is not currently a direct goal of the 0.4 versions.
The 0.6 versions will deal with networking and will most certainly need proper endianness support.

Ultimate the FLL needs to properly handle endianness.
Provide the initial functionality needed to make this possible.

The BIG_ENDIAN and LITTLE_ENDIAN cannot be directly relied on.
Provide custom _is_F_endian_big and _is_F_endian_little macros where when BIG_ENDIAN is not defined default to little endian.
By using the custom _is_F_endian_big and _is_F_endian_little, allow for the endianness to be explicit set at compile time.
This should make it easy to configure in cases where BIG_ENDIAN and LITTLE_ENDIAN are not defined.

Update: Documentation for FSS-000E Payload and add missing FSS type enum value.

Add additional suggestions and further clarify payload.
Provide suggestions for payload length as well as chunking (part and total).

Bugfix: Mock function is missing parameter name?

How did this even compile?
I'm guessing GCC 11 seems to ignore this when the parameter is not used whereas GCC 8 does not.

This is still improper even if newer a GCC can handle the lack of a name.

Update: Add unit tests for f_account.

Update: Add missing f_account_name_group_by_id(), cleanup comments, and update macro usage.

Bugfix: Unit test files have typos.

There is a spurious single quote in the define LD_LIBRARY_PATH line.

Bugfix: IKI variables are not substituting consistently.

There appears to be a logic flaw where when more than one IKI variables are present, they start overwriting.

I changed the logic to focus more on the content loop.
The arguments array is only incremented for the content row.
When the resulting row is empty and is not quoted, then do not increment the arguments array.

Remove unnecessary NULL insertions.
The only time the NULL needs to be inserted is at the end when done adding all of the characters to the argument buffer.

Always append using the nulless append functions.

Update: Provide more details in the documentation on if/else logic.

With the logic being different from normal conditional logic, I figured that it would be a good idea to add more documentation to further clarify the design.

Traditional logic is:
  A and B or C and D

  Where order of operations would be:
    1) If A and B are TRUE...
    2) If C and D are TRUE...
    3) If (1) or (2) are TRUE...

The logic used by this program would be:
  A and B or C and D

  Where order of operations would be:
    1) If A and B are TRUE...
    2) If (1) or C are TRUE...
    3) If (2) and D are TRUE...

This is a critical difference in behavior.

Bugfix: More cases where if/else is not working as intended.

In the previous commit I accidentally removed the "or" condition.

I also found that I needed to be more thorough with the logic.
The condition result needs to be returned and handled when immediately returning.
This then allows for subsequent conditions to use the condition result.
The condition result gets reset on each pass of the loop.
The block result needs to then retrieve the condition result to ensure the result is preserved across loop passes.

Bugfix: Partially fix "if is regular for xxx" exposes bug in error handling of and/or.

The following:
  if is regular for xxx
    print found.
  else
    print did not find.

Fails when "xxx" does not exist.
It should not fail but should instead trigger the "else" condition.

In this case, if the file does not exist and "fail exit" is setup, the program exists as failure.
This is bad behavior.

I then tried to work around the problem with the following:
  if exists xxx
  and is regular for xxx
    print found.
  else
    print did not find.

This did not work as expected because the "and" condition is executing when it should not be.
This commit focuses resolving this second case.

The problem is that there is an incorrect test for "and" and "or" types at the start of the process function.

I also noticed that the "is" check has the wrong words in the error message (should be "get type of" rather than "get mode of").

The primary problem requires more in-depth changes that I will not get to tonight and is not intended to be solved within this commit.

Cleanup: Clarify how the "if is XX for YY".

Where XX is one or more file modes and YY is one or more files.

I feel that this change improves the wording of the documentation for this functionality.

Regression: The "failure" operation if condition type is not working as intended.

The documentation and specification is out of date and refers to this as "fail".
This is instead the word "failure".
This is also different from the setting "fail" that designates what to do on failure.

With one of the recent re-designs of the process logic, the failure status is no longer being passed.
When the "fail" setting is set to "warn" or "ignore", the status code of F_none is returned.

Change the return status to "F_failure" without the error bit to designate that this is a failure but it is not being treated as an error due to the state of the "fail" setting.
Then process the "F_failure" without the error bit to remember the state that a failure occurred.
This then allows for the "failure" if condition type to get triggered.

The recent if/else logic changes introduced behavior where a failure in the processing of the if/else commands should also trigger the "failure" if condition type.
This failure is not associated with the if condition results.
When an if condition results in either true or false, then this is considered a "success" rather than a "failure".
Generally, syntax failures are what trigger the "failure" state.

Programs that are executed, such as when using the "run" operation, will result in "failure" if a non-zero value is returned by the program.

Bugfix: The "if not defined" is not working as expected.

When the "not" logic was added, I seemed to have failed to adjust the variable for the "not defined" case.

Cleanup: Add missing bold around type name for unsupported error message.

Bugfix: If/else condition logic is incorrect or incomplete.

The if/else logic is not properly traversing.

I believe the original design is to just have if and else be a single set rather than a chain.

At some point I changed this to be chainable (or maybe I am incorrectly thinking that I did).
It made sense to use this if/then chain logic for my unit test files.
The Fake make unit test files are not working as I want them to because if/else chaining is not working.

As a big disclaimer, this does not support nesting.
I continue to refuse to design nesting of the if/else condition logic as I want to keep this as simple as possible.
Which, by the way, this is not simple.

I attempt to cut corners when I did my recent rewrite of the if/else logic.
Redesign this (again) but this time attempt to do this more properly.

The block process state now exclusively uses a special block process state enumeration rather than relying on a synthetic rule type.
The synthetic rule type is now removed.

The goal with this design is to:
1) On syntax error, bail out of the entire if/else chain.
2) On comparison error, continue an if/else chain passes or the end of chain is reached.
3) When any if/else chain passes, all subsequent conditions in the chain are not run.

Replace the "done" condition result with an "error" condition result to more accurately communicate its use.

Isolate the block and block result from the operate processing as much as possible so that all modifications of the variable are done outside of the operate processing.

When the "fail" is set to "exit" the if/else should fail appropriately on syntax error.
When the "fail" is set to "warn" or "ignore", then continue on after skipping the entire chain.

The operate process still needs to check the if/else chain states to determine if it should skip or not.

When an if/else condition terminates unexpectedly due to an end of file (or section) an error is more consistently reported regardless of place in the if/else chain.

This still needs real testing to confirm that all of the possible permutations work as expected.
Unit tests for this will need to be written but this is a long way away from being done.

Update: Implement f_capability unit tests and improve existing unit tests.

Add tests for f_capability functions.
This includes my first go at mocking functions using function wrapping.
It seems that the linker is limited on how it handles function wrapping.
I cannot simply wrap functions pulled in via a library.
To work around this I implemented another Fake build settings file for handling this.
This is not an ideal situation and adds a bit of extra work.

The environment variable settings for LD_LIBRARY_PATH needs to also support the work parameter.

These changes expose a logic flaw in the if/else logic of the Fake program.
That bug is not fixed in this commit, it is simply noted in this commit log.

Bugfix: Fix problems exposed by unit testing and perform cleanups.

f_capability_ambient_set() should not be testing for (!value_flag).

Te flags pointer test should be "flags" and not "*flags".

Explicitly cast capability to void * for cap_free().

Use "value" rather than "code" for "f_capability_value_t".

Expand out CAP_IS_SUPPORTED() and CAP_AMBIENT_SUPPORTED() to explicitly set F_true and F_false.
This is better than relying on the direct result of those macros.

Make sure f_type support "weak" compiler attributes.
Rename the compiler attributes to be more than just for visibility.

Correct the function ordering.

Cleanup: Simplify structure using more basic file names and using separate print files.

These are private files and are not intended to be exposed.
This allows for the names to be more generic.

Break out the print functions into their own separate files.
This will also make the code more multi-lingual friendly in the respect that much of the code that might need to be swapped out exists in a single file.
This is still very far from multi-lingual friendly with many print code still not in the isolated print functions file.

Cleanup: Coding style updates and miscellaneous fixes.

Use fewer macros.

Update documentation in regards to return codes and related functions (much more work is needed here than is currently done).

Reduce nesting where obviously possible.

Fix typos and mistakes in words for documentation, comments, and prints.

Use "(pipe)" for designating the pipe input source.

Correctly identify last file when getting file name string.

Fix naming mistakes in programs where the "_read" is missing.

Add appropriate newlines to get code more up to date with latest practices.

Update comments to start with upper case letter where noticed.

Fix ordering of functions where they were noticed to be out of order.

Feature: Add support for FSS-000E Payload specification.

Provide fss_payload_read and fss_payload_write to handle the special nature of this specification.

This specification is primarily for network communication in which the payload can be a binary.

Update: Add additional status codes.

Cleanup: Remove out of place function declarations.

Update: Have fss-000e Payload be more specific about payload handling.

Because payload may be anything, especially a binary blob, having it always be last as a requirement makes the most sense.
This then allows me to guarantee comments and other lists may not be after or inside.
This allows for the payload to not have to have comments or delimited code to deal with.
The payload will be a complete virgin binary blob until EOF or a designated length is reached.

Bugfix: Valid comment lines are keeping leading white space.

Any line that ends up being a valid comment line may have white space on the left.
For lists, such as FSS Basic List, the leading white space is being printed.
This is not correct at all.

This is easily solved by getting the last new line and add one.

Update the specification to make the expected behavior clear.

Cleanup comment lines and other related code while its convenient.

Feature: Add fss-000e Payload specification.

Update: Only clear socket id when fast closing and update documentation.

Cleanup: Remove stale macro and fix comments.

Update: Finish "is unassigned", add "is surrogate" UTF-8 support, and update "is private use".

Progress: Continue working on the controller program's control functionality.

The f_socket_listen() seems to need its own process or thread.
Give it one.
Make this one as isolated as possible so that it can be forcible exited.
(Because listen() doesn't respect signal handlers.)

Update: Fix bug in socket disconnect, add additional signal functions, and some clean up.

The socket close enumerations are being directly passed to shutdown().
This is not correct because they do not directly map.

Use the size_read and size_write already provided in the socket file.
This allows for the length to be exclusively a write (better practice).

Provide f_signal_wait() and f_signal_wait_until() functions that handle sigwaitinfo() and sigtimedwait() respectively.

Use uint8_t rather than unsigned short.
The fact that there is still a short in use here makes it clear that I have not even glanced at this file in a long long time.

Update: Implement more socket support.

Add additional defines.

Fix implementtion of f_socket_accept().

Add read and write socket functions.

Add additional status codes.

Bugfix: Incorrect mode is being set.

The world/other character is being mixed with the user.
Swap the "on" value for world/other and user.

Always reset the "what" value before starting the condition loop.

Turns out that the previous code does not support the form "u+rw-x".
The following is an alternative way to write this that previously worked "u+rw,u-x".
Make sure both methods are supported by adding an additional check for the "+", "-", and "=".

When adding and removing, the previous opposing bits needs to be reset.
For example "u+rwx-r" should set the "add read" bit and then remove the "add read" bit while setting the "subtract read" bit.

Also absurd forms like the following need to work: "u+rrrrrwx+rwwwxwrwrwrwww" or "u+rwx,g-rwx+wrrr,o+rwx-wwr".

A copy and paste mistake in f_file_mode_to_mode() results in the wrong bits being set for the world bits.

Don't operate on the parameters directly.
Update them only on success.
This ensures a safer design at a cost of slightly more resources being used.

Swap the world and the owner bits for replace to make it more logically consistent in the order of the bits.
Hopefully this will make things slightly less confusing.

Progress: Begin implementing Control support in Controller program.

Numerous structural changes and cleanups.
Things are getting bigger so apply some more organization changes to the project structure.
Start using the pointer constant behavior.

Drafted out Control functionality.
Drafted out Task functionality, which is being considered and will be tested to see if I really want to do (keep) this.

Update: f_file project.

Now that I am moving towards using pointer constants (sch as "int * const"), I can move many of the parameters to the left side.
I believe this sufficiently follows the pattern of having constants on the left and editables on the right even though the data pointed to can be edited.
I feel this allows me to relax the compromise I originally made when following this design paradigm.

Cleanup: Update comments.

Update: Add socket functions and improve existing ones.

It is very clear to me that I had stopped working on the socket code.
Much of the code appears incomplete, including some comments that weren't updated after they were copy and pasted.

This is only preliminary work for only the functionality needed or preceived needed by the Controller program or other existing programs.
There will likely be major work in the future during the 0.7.x development release series.

Update: Add several new status codes and update existing ones.

A new group "_di_F_status_network_" is provided.
This is done in anticipation of a large amount of dedicated network related status codes.
The next minor development release series (0.7.x) is planned to focus heavily on networking.
The networking is highly specialized and will likely have network specific variations of many existing status codes.

Cleanup: Expand filesystem to file system.

Cleanup: Use present tense.

Using past tense is a habit because everything being referred to is generally in the past.
The documentation and comments really should present tense despite this.
There is a lot of code that really needs this done but is not done in this comment.
I just happened to see these and decided to immediately fix them.

Cleanup: Use const for fake_make_get_id_mode() return status.

Update: Improvements to file processing code.

Code cleanups.

Add initializer to F_file_mode_t.

Have file closures set id to -1 even on error due to documented design of the close() function.

Provide path type for process path related file system operation failures.
Some operations do not distinguish file or directory but instead only operate on the path itself.
In these cases, the path type is now available for use.

Add F_file_found_not to standard error printer.
This allows for the standard error printer to still report the problem rather than a code.
Using the file-specific standard error printer is still the recommended approach.

Update: f_path related improvements.

Return F_data_not rather than F_false to provide a more detailed reason as to the return status of f_path_is().

Explicitly check fo F_true when calling f_path_is() because it now returns F_data_not without the error bit.

Add f_path_is_relative().
Pretty much every path that does not begin with a "/" is a relative path.
This function performs a dirt simple check to achieve this.
This function does not perform any checks to see if the path would be a valid path.
Such decisions are filesystem and are otherwise too situation dependent to be reliable detect in a general manner.

Use f_path_separator_s rather than an explicit "/".

Simplify counter using a pre-increment within the if condition check.

Update: Add F_domain, F_family, F_protocol, and F_property statuses.

This includes the *_not status for each.

The domain, family, and protocol are common enough terminology and are used heavily in networking relating processes.

The property is a very common terminology as well.

Feature: Add support for "context" IKI in Fakefiles.

This updates the IKI-0002 specification to support "context".
This allows for color context and ideally any future context to make software more accessible.

Update the existing testfiles to utilize this context.

Update: Testfiles should detect LD_LIBRARY_PATH.

If LD_LIBRARY_PATH is already defined, prepend to it.
Otherwise define it.

Update: Documentation and add "context" to IKI-0002.

Cleanup: Fix space alignment in help print out.

Update: Next micro version (0.5.8).

Progress: Add more unassigned UTF-8 characters.

Cleanup: Append "_e" to all enums, update status types, and update status strings.

A new practice is to have "_e" at the end of all enums.
Update all of the existing enums to follow this practice.

I noticed some fixme comments about moving the status codes to a lower level.
Do this.
Update all code accordingly.

The status code strings are only for special cases, so make this its own project directory (for both Status and FSS Status).
These are f_status_string and fll_fss_status_string.

Cleanup: Move the process and validate functions into their own files.

As for the naming structure, the "make" represents the group and the "operate", "operate_process", etc.. are relevant parts of the function name.

Update: Use 'shell' rather than 'run' in testfile.

I apparently missed this line.
The 'run' operation will attempt to execute based on PATH environment.
The 'shell' operation expects local files, which is what these tests are.

Update: Add tests for f_type_array.

Given the size of the task and my relative inexperience with cmocka, I opted to keep the tests as simple as possible.
This means that my tests are likely not thorough.
These are intended to be good enough for a first pass tests.
After all, I have the entire rest of the FLL projects to write tests for (as well as for the programs).

Cleanup: Remove extra line.

Update: Test file.

Detect when neither shared nor static test files are generated and return an error.

Update: Move main data into the data make structure.

The goal here is to reduce the number arguments passed to functions in a consistent manner.
This has a downside of having another pointer and the costs of dereferencing it for each access.

Rename the "main" property to "id_main" to be clearer as well as to not conflict with the new "main" property that points to the main data.

Remove a stale header that has no associated function implemented.

Update: Add "and" and "or" operations, operation if-then-else logic, and some cleanups.

Add the "and" and "or" operations to make the "if" and "else" operations more complete.
The current design still does not support directly nested multiple operations underneath an "if" or an "else".
Using an "operate" operation is still the only way to do this.
The reason for this is to keep the logic and design simple.
This has a cost of causing complicated design to be even more complicated than they otherwise could be if I allowed "if" and "else" to contain blocks of commands or even be nested.

While I am at it, this cleans up the if-then-else logic.
This needed to be done for some time.
My original design was patched at some point to add unexpected functionality that I had not originally planned but later realized I needed.
The patch was just a good enough for now.
This resulted in the logic being a bit ugly and confusing.

The new logic is a lot better, but there are still some things that might be confusing.
To that end, I decided to only perform simple tests.
I instead intend to write unit tests that will perform all of the possible combinations that I can reasonably come up with.
This should help me find logic flaws in my current design.

This now uses a structure to pass the process state data.
This further simplifies the design to allow for fewer parameters in the relevant functions.

Several of the duplicated print calls are consolidated into a single print function.

I fixed some missing or incomplete documentation.

Update: make the interrupt handler pointer variables constant pointers.

Security: Invalid memory access in interrupt handlers.

When I converted the data_main into a pointer from a value, I failed to remove the references on these variables.
The compiler does not catch these because they are cast to a void *.

Cleanup: Fix spelling.

Bugfix: Signal id should be -1 the id should be passed to signalfd().

A file descriptor should be set to -1 and not 0.
The 0 file descriptor is actually valid.

The signalfd() program accepts an id.
It makes sense to pass this along rather than always forcing -1.

Update: Make the state parameter a constant.

Cleanup: Move remaining operation type processors into their own functions.

In the previous related cleanup I had forgotten to complete several functions that needed to be moved.
They were stubbed out but were not implemented.

Update: Add support for if "not", add support for "parameter".

The "parameter" is already supported under "settings" in a fakefile.
Extend the operations to also support "parameter".
This allows for defining the parameter anywhere within the file and it can be overridden.

There exists several "if" operations that would make sense to have the inverse.
This is now supported via the if "not" operation.
To keep the logic more consistent with the previous design, just extend the existing code to handle "if not" behavior rather than adding new structures.
To achieve this, the pre-processor identifies "not" and then parses that to identify the particular "if" operation that is being negated.
The "if" operation is then change to a new operation type to reflect this.
Anything that already supports an inverse through some means are omitted from this.
This list includes:
- fail (opposite of success).
- success (opposite of fail).
- integer/math comparisons: ==, <>, <, <=, >, >=.

Fix the order of several of the functions that are not alphabetical.

Update the documentation accordingly.

Security: Buffer overflow.

The inner loop is stopping when string[i] is NULL.
Which is correct.

However, this then continues to the outer loop, resulting in ++i.
This results in an buffer overflow.

Check to see if at NULL before continuing, otherwise break.

Perform minor syntax cleanups.

Bugfix: The character 'o' is not properly detected as a mode.

Cleanup: Move several operation type processors into their own functions.

Update: Relocate fake_main_t position in function arguments and make it a constant pointer.

The standard practice is all constants on the left and all updatable variables on the right of a functions parameters.

At some point I switched to passing the structures as a pointer rather than directly.
For these, I made them pointer constants.
That is, the pointer itself is constant but what the pointer is pointing to is not.

This allowed for me to move this type further to the left.
Keeping the main data and the fake data on the left side of the functions is a lot more consistent.