These make up the initial git commit. So far completed is arithmetic
expression compilation, simple lexing, and other simple text processing
functions.
Commit.sh file designed to semi-automate process of committing.
Test commit.
Fixed commit error.
Implemented removing comments from the pulled file in the lexer, and
began implementation of stripping whitespace from individual tokens.
Started implementing a library printf function.
Discard effort to implement printf in assembly, revert to a C
implementation.
Began implementing the floating point printing function. All that is
left to do is printing the actual floating value beyond the decimal
point. Also created an assembly function that takes in a float and
returns an integer value that is simply the bits of the float, so that
the sign, mantissa, and float sections can be shifted out.
Implemented a putchar_cr function that replaces using fputs_cr with a
one character long string, for speed optimizations. In addition,
floating point number printing was fully implemented, including rounding
the fractional part, and yields the same result as glibc's printf.
Implemented a print double function for printf_cr. The only issue
plaguing the print float and print double functions right now are
printing very large integer components. Printing very lengthy fractional
components works perfectly, mostly to do with the rounding of the float
itself. Testing needs to be done for very, very small fractional
components though, like 0.0000000000000000000012. In addition, printing
very large integer components of the floating point values also needs to
be fixed.
Added a special case for double prints such that if the exponent is too
large, the fractional component should be considered 0.
Essentially finished implementing the tokenizer, pending special cases
that may arise. Began implementing the parser. This includes defining
several container classes. The function container class knows only about
the signature and internal code of a function. The class container knows
about function containers, as well as its own name, member variables,
etc. The top level container knows about includes of other files, of
class definitions, and of global variables and functions. Also in this
commit there are changes to the printf_cr function, as well as some more
general text manipulating functions.
Began implementing code for the various containers, and got a start on
the actual parsing code. The ParseContainer is responsible for feeding
tokens to the various other containers whenever they are summoned to do
their specific parsing work. The TopLevelContainer is in charge of
holding includes and global variables, as well as delegating parsing
work to the FunctionContainer for populating global functions, and the
ClassContainer for populating classes, which the ClassContainer is in
charge of member variables of various access priviledges, and for
delegating parsing work to the FunctionContainer for parsing member
functions. Overall, the TopLevelContainer will basically contain an
implicit tree of parsed code, to be "walked" by tracversing the
ClassContainers and FunctionContainers contained therein.
Implemented the skeletons of several more container classes that are
involved in parsing, to split up work and still keep things in a logical
order.
Made changes to the lexer to both be a better lexer and to start to
support the new language that is to be implemented.
Started fixing up and cleaning up the arithmetic expression compilers.
The integer expression compiler now works hopefully perfectly. The RPN
class has been changed slightly so that you can now separately check
either the whole expression for a float, or a single index value for a
float, to make working with integers easier inside floating point
expressions. Began working on implementing subtraction, multiplication,
and division for the floating point expression compiler (addition
currently works).
Completed floating point expression compiler.
Both of the expression compilers, pure integer and mixed floating point,
work exactly as expected, and it is sexy.
Added documentation to several files, and did more test stuff
Apparently .gitignore is not doing its job with ignoring object files,
and I don't know what sort of sorcery would keep extensionless
executables out while still including other extensionless files like
Makefile. In any case, this commit features added documentation to a few
files, mostly in the form of general explanatory text at the top of the
file.
Implemented a fork-exec system to assemble and link the compiled output

In the compCRPNTest.cpp file, specifically. Could and should be applied
to compCRPNTestF.cpp as well, as the two testing files are essentially
identical and probably should be integrated anyway. But in any case.
This is so sexy.
Implemented integer-RPN collapsing function; simplifies RPN expressions.

This new function is a friend of the RPNNotation class, takes in an
RPNNotation instance that contains a converted RPN notation expression,
and simplifies the sections where known integer constants exist,
skipping past variables. The result is that an expression containing
solely integer constants should be collapsed down to one integer. If
there are variables in the expression, they are simply ignored and the
expression is collapsed as much as possible. Note that this function is
completely untested, and the next thing I should do is write a testing
program for this function. Only an integer expression collapsing
function was written, meaning a floating point expression collapsing
function still needs to be written.