removed remark token type, it was not being used
updated valgrind memory leak suppression file
changed translator to contain single parser instance

previously the translator created a local parser instance each time
a line was translated, which was changed to create a parser instance
in the constructor and delete it in the destructor
removed temporary strings

temporary strings were added so that copying the copying values of
string variables to the evaluation stack at run time were not necessary
(only temporary strings need to be deleted when no longer needed),
however, this is not necessary because QString utilizes implicit sharing
(strings are only copied when modified)

the translator can't determine the difference between variables and
arrays (not temporary string) and functions (temporary strings) so it
attached strings operands to operators and internal function so that the
encoder could make this determination; but this is no longer necessary
(operands are still attached to parenthesis tokens, which could be either
arrays with integer operands or functions with any type of operands

all the codes with temporary strings as operands were removed along with
operand arrays with temporary strings and associated code arrays with
codes that were removed; the number of strings was removed from the
expression info structure (no longer needed); the string flags was
removed (was never used); and all the affected expected test results
were updated
updated table number of maximum associated codes

since many of the associated codes for temporary strings were removed,
the number of maximum associated codes changed from 4 to 3

also changed the checks for the maximum number of operands and number of
associated codes for an exact match instead of greater than to catch
this in the future (it was originally expected that the maximums would
only increase not also decrease)
implemented improved hold stack with convenience functions

new HoldStack class based on QStack with drop(), to pop the top item
with out returning it, and push() with token and first token to put in
the new item pushed to the stack
implemented improved done stack with convenience function

new DoneStack class based on QStack with push() with RPN item token,
first and last tokens to put in the new item pushed to the stack
corrected parser operand state error problem with '-e'

when in operand state, the parser incorrectly interpreted '-e' as a
incorrectly formed numeric constant instead of an operator token
followed by a identifier (noparen) token; rephrased error message
added expected data type to table expression information

this value will be used for the new translator to determine what the
expected data type of the next operand will be (this is for primary
codes with an associated codes), which is for the last operand of the
code
initial implementation of new translator (simple expressions)

the new translator is able to process simple expressions consisting of
simple operands (constants and identifiers with no parentheses), unary
and binary operators (new functions with same name as old functions are
suffixed with a '2'; the new functions will eventually replace the old)

added additional test expressions to expression test #1 for '-E' issue,
unary operators (including multiple), mixed data types, and data type
error tests

added temporary -n and -ne comment line options, which are the same as
-t and -te except use the new translator routines

corrected minor issue with older expression mode that prevented negative
numeric constants at the beginning of the expression from being detected
correctly
made translator get expression function non-recursive

it was not necessary for the get expression function to be recursive to
process the rest of the expression; the recursive call was replaced with
a loop
corrected processing of error conditions in expression

needed to catch command and operator tokens when an operand was expected
and return correct expected expression error

when checking token after operand, needed to specifically check for an
operator token type; was using isOperator(), which also returns true for
command tokens

when clearing hold stack of higher precedence operators, needed to allow
for tokens that don't have a table entry, both for precedence and is a
unary operator; replaced with precedence() that checks token instead of
the token code directly, and implemented new isUnaryOperator() that
takes a token instead of a token code

added more error tests for expression test #1 (note some of these tests
cause the older less robust translator expression mode to fail)
corrected token memory leaks caused by error conditions

a new sub-code was implemented to indicate when a token with an error
has not been used in the RPN output list (which are deleted when the
output list is cleared when an error is detected) so that the token can
be deleted; this sub-code is used in getOperand() with a command or
operator token, and when the terminating token is not an EOL token (the
check for which needed to be prefixed for whether the token has a table
entry since any token may have terminated the expression)
updated files for version 0.4.0
corrected dependency for generating autoenums.h

one of the dependencies should have been token.cpp, not token.h in
CMakeLists.txt
handle parser errors properly in new translator

for parser errors, the get token function differentiates between
parser errors and number constant errors by considering if getting an
operand and the data type of the error token (set to none for parser
errors, or double for number constant errors)

the parser setOperandState() function was removed and the operand state
now passed in as an argument to the token() function

the loop in the get expression function was rearranged to remove
duplicated code before and at the end of the loop

added several parser error tests to expression test #1
corrected an issue with unary operators

if the token after an operand was a unary operator, if was incorrectly
processed as a binary operator causing the code to malfunction; so a
check was added after getting this token to test if the token is a
unary operator and returning an error if it is

added a test for this to expression test #1
added support for parenthesis to new translator

in getExpression() if the first token is an open parentheses, then
pushes token to hold stack (low precedence blocks popping past it),
recursively calls itself, checks terminating token for close
parentheses, sets first/last operand on hold stack to open/close
parentheses tokens, sets last precedence, sets pending parentheses
token, and continues on to get a binary operator token

added new checkPendingParen(), modified from existing doPendingParen(),
to check if there is a pending parentheses and marks the previous token
if an unnecessary entered by user parentheses are present (or adds a
dummy token if there are multiple unnecessary parentheses), or deletes
(or marks for deletion) the pending parentheses token if necessary (due
to operator precedences), which are implied by the order of the RPN
translation

added calls to checkPendingParen() to processOperator2(), one after
an operator is popped from the hold stack before processing if final
operand and one on the current token before checking if it ends the
expression or processing its first operand; there is a popped argument
to indicate which call that controls how checkPendingParen() checks
the precedences

in the table, the CloseParen code was given the EndExpr flag since it
now ends an expression

removed the "expected operator or end-of-expression" (internally named
NoOpenParen) as this error is not appropriate and should have been
"expected operator or end-of-statement (or some other token like
'THEN')"; updated expression test #2 for this change
changed how token code is checked

the problem was that in order to check a code in a token, the token
type needs to be checked because only token types that have table
entries have a valid code

modified Token::isCode() to make sure token has a table entry, otherwise
it just returns false

modified users where if they know the token is the correct type, then
use Token::code() and compare to the code, otherwise use isCode() to
make sure token is the correct type first
added support for internal functions to new translator

updated getOperand() to support internal functions (paren and noparen)
implemented new getInternalFunction() to get an internal function with
parentheses

added new test to expression test #4 with a no parentheses internal
function