parser: changed class to be a function operator

removed set input function, now handled by constructor
changed token function to operator() function
renamed users instance from "parser" to "parse"
parser: changed handling of operand state

changed to not call get number if not operand state (causing '-' to be
parsed as operator) instead of checking in get number function (if
operand state, '-' should be interpreted as sign and not operator)

removed operand state member since now only checked in main function;
changed boolean operand state to enum class state; removed default
state; and added operand state argument to tester class parse call (so
numbers get parsed) to make explicit

removed check for status in get commands function of translator so token
gets passed to let translate (when not a command) to generate
appropriate error when necessary; and added 'any' data type to get token
call so operand state enabled for first token (which could be
incorrectly a number, which will be reported by let)

changed 'unrecognized character' to 'unknown token' since this status is
now returned for number characters when operator state

updated parser test 3 (number tests) affected by these changes with
'-2147483647' test (previously parsed as unary negate operator and
positive integer constant - not intention - because default was operator
state); and added two tests for one beyond both negative and positive
maximum integers (will be double constants)

updated parser test 5 affected by change to 'unknown token' status
parser: changed state enumeration to number

changed the state enumeration to number enumeration with yes and no
enumerator since this is really what this argument is telling parser
(to allow numbers or not)

changes made to get token function of translator:
- added data type not equal to string for setting parser number argument
  since numeric constants are not allowed when looking for a string
- removed check to set the token length to one upon error when there
  was number error when not looking for a number or looking for a string
  (these won't occur so no need to check)
- simplified check when returned and expected expression error to
  checking if data type is not blank and not none and unknown token
  error was returned
- removed local state/number variable (only used for parse argument)
parser: removed data type from errors

removed setting of token data type since returned status alone can be
used to determine a numeric constant error when status is not unknown
token

changed method how translator detects parser error type from checking
for 'parser' error along with data type (double for numeric, none for
non-numeric) to just checking for unknown token (if not then numeric
constant error)

changed translator get token function to return status returned from
parser (unknown token or numeric constant error) instead of generic
'parser' error status

removed check for parser error from translator get operand function for
references since get token function only returns parser errors

moved unary operator check in translator process internal function
routine to before error check so that when a unary operator is present
(also an error), it needs gets passed further down where an updated
error is determined

removed no longer used 'parser' error status
parser: changed error mechanism to exceptions

removed token error type enumerator (use default for unset type)
changed error token types in table entries to default token type
added length to token constructor, changed to use initializer syntax
removed set error functions and error status member from parser class
added error exception structure containing status, column and length
changed all set error calls to c++ exception throws of error structure
removed setting of invalid two word command (won't occur)
changed translator get token to catch parser error exceptions
changed tester parse input to catch parser error exceptions
removed error status and tab arguments from tester print token
changed argument to just error structure reference of tester print error
table: removed data type words section

there were no data type words in the table and this section is not
necessary anyway since any data type word tokens (in other words,
internal functions with no arguments) can go in the plain word section
of the table
parser: removed use of token from exception throws

with plan to not create (allocate) token until valid token found, use of
token values (specifically column, but length also but was always one)
was replaced in throw statements to use current or updated position

removed mechanism for specifying alternate column in error (no longer
necessary since number tokens not parsed if numbers not allowed); also
removed from tester print error function

for numbers, position not updated until number found to be valid
parser: changed get identifier to create new token

modified get identifier function to create new token and return a token
pointer (shared pointer) only when a valid token is found else a default
token pointer is returned; and cleaned up this function a bit

modified function operator function to create a new token when end of
input is reached and changed call to get identifier function (the other
get functions will be updated similarly)

added two more token constructors to support creating tokens
removed id member from token (was used for leak detection code)
added another new token function to table to support creating tokens
parser: changed get number to create new token

modified get number function to create new token and return a token
pointer (shared pointer) only when a valid token is found else a default
token pointer is returned; parts of handling creation of double constant
token moved to new token double constant constructor

changed call to get number function in function operator function
added integer and double constant token constructors
put double constructor in source using standard numerical limits
removed get command function definition (function was deleted long ago)
parser: changed get string to create new token

modified get string function to create new token and return a token
pointer (shared pointer) only when a valid token is found else a default
token pointer is returned; changed building of string from setting
characters to appending characters

changed call to get string function in function operator function
added string constant token constructor
removed set string character token function
parser: changed get operator to create new token

modified get operator function to create new token and return a token
pointer (shared pointer) only when a valid token is found else a default
token pointer is returned; and cleaned up flow of this function

changed call to get operator function in function operator function
removed member token initialization and token member
parser: changed to return a standard unique pointer

changed the parser functions to return a standard unique point instead
of a shared pointer as there is no reason for the pointer to be shared
within the parser as they go out of scope at the end of each function

added an alias for a unique token pointer
changed table new token function to return a unique token pointer
simplified the handling of REM code in the get identifier routine
parser: corrected reporting of errors in numbers

there was an error condition that was not detected properly, which was
reported as "expected sign or digits for exponent in floating point
constant" but an exponent sign was present, so a new "expected digits
for exponent in floating point constant" error was added and the get
number function was modified to detect and throw this new error

changed the "expected digits in mantissa of floating point constant"
error was to point to both the '.' and 'E' in the incorrect ".E"

changed translator to request a reference token for the first token
added reference argument (default none) to translator get token
  (prevent number tokens when reference is not none)
changed translator get operand to pass reference flag to get token
  (which now reports appropriate error, so upon error just return status)

changed the "expected command" error to say "expected command or
item for assignment" (status enumerator also changed)

cleaned up the let translate error handling

updated parser test 3 (number tests) for changes in error messages
updated translator tests 1, 3 (assignments) and 14 for error changes
added few more tests to translator test 14 (parser) to test new error
updated several translator tests for expected command error change
parser: use standard functions to parse numbers

modified the get number function to use standard library functions to
parse number and convert them; the input string is temporarily put into
a standard input string stream and read from it (the entire parser will
be changed to this) and as characters of the number are parsed, they are
moved from the input stream into a local standard string that will be
passed (moved) to the token constructors when the token is created

modified the token constructors for creating integer and double constant
tokens to take a standard string, though for now it is converted to a
c-style string to initialize the QString member variable
parser: use standard functions to parse strings

modified the get string function to use standard library functions to
parse string constants; the input string is temporarily put into a
standard input string stream and read form it, and as characters of the
string are parsed, they are moved from the input stream into a local
standard string that is passed (moved) to the token constructor

modified the token constructor for creating a string constant token to
take a standard string, though for now it is converted to a c-style
string to initialize the QString member variable
parser: use standard functions to parse operators

modified the get operator function to use standard library functions to
parse operators; the input string is temporarily put into a standard
input string stream and read from it

modified the table search function for a single string to take a
standard string and use the standard equal function to compare strings
using the no case compare lambda function (which was moved from the
tester source file to the main header file, and the call from the get
identifier function was modified to pass a standard string)

modified the token constructor for codes to take a standard string
modified the table new token function to take a standard string
(modified callers to pass a standard string)
parser: use standard functions to parse identifiers

modified the get identifier function to use standard library functions
to parse identifiers; the input string is temporarily put into a
standard input string stream and read from it

the scan word function was renamed to get word and it too was modified
with a temporary standard input string stream, to return its values in
a new work structure containing string, data type (if present) and
parentheses flag (the later two instead of reference arguments, and
given new work type argument (first or second) where a data type and
parentheses are not allowed for the second word

modified two word table search to take standard strings

corrected a problem with defined functions where only function names
that start with a letter are valid defined function names, otherwise
names starting with 'fn' are regular identifiers; added new identifiers
to parser test #2 (identifier tests) to test invalid 'fn' names (are
valid identifier names)
parser: use standard input string stream

changed input string member to a standard input string stream
removed input position member (use position in input stream)
removed skip white space function (input stream has equivalent)
removed temporary input string stream code
added clear input stream error calls in case read past end of stream
changed constructor to take standard string (updated callers)
modified get string to count characters (in case string at end of line)
Merge branch 'parser' into develop