Eliminated the on-off button. Multiple threads were all checking if the on-off button had been set
to "off", but this caused a problem: the control thread would only set it to "off" after it had seen the
number of failed tests had exceed the configured maximum. In the time between checking if the
maximum had been exceeded and hitting the "off" button, thousands of other tests were already
executed and had dumped their report files. Now, the 'onOff' function checks if the number of failed
tests exceeds the maximum, and if so, returns false right away.

Created an exception handler 'tryTest' to be used to catch exceptions for individual sub-tests in
the 'checkTestCase' function. As a result, exceptions occurring in the check function are now reported
as a failed test in the report for that individual test case. Before the exception would not be
caught until the 'loopOnInput' function which would dump the exception without any in-depth information
about the test case right into the "uncaught.log" file.

The parser test now removes location information and comments from the parsed AST object before
comparing it to the original randomly-generated object. Before, when it had not done this, the
comparison function would evaluate to false for identical AST data structures merely because the
location information was included in the structure returned by the parser. To do this, I had to
introduce the 'delLocation' function. I also introduced the 'Dao.Object.AST.canonicalize' function
into the 'Dao.Object.AST.Intermediate' class.

The act of creating the 'delLocation' function introduced an avalanche of other changes which will
be committed soon.
Added the 'Dao.Object.AST.delLocation' function to the 'Dao.Object.AST.Intermediate' class.
The token and location data types are fundamental data types because they are used to construct the abstract syntax tree and the data types that define the Dao interpreted language. So it is necessary to keep these data types in a separate module so the "Dao.Evaluator", "Dao.Object" and "Dao.Parser" can all make use of them without causing circular dependencies.

Up until now, the old parser had its token and location types were defined here, and in order to coexist with the new parser, the new parser had it's own location and token types defined within the "Dao.NewParser" module.

However now that I am ready to being automated testing, I cannot have two different sets of location and token types. Well, actually I could have had two different sets, but it is no longer worth the trouble to keep the old parser up to date with all the changes made to the data types upon which it depends. The new parser is becoming stable enough, it is clearly better, and I do not intend to go back to the old parser, so I am phasing it out now.

To begin transitioning the code base to make of the permanent use of the new parser, I have deleted all the code in the "Dao.Token" module and moved most of the location and token-related data types from the "Dao.NewParser" module to the "Dao.Token" module.
The new parser is becoming stable enough, it is clearly better, and I do not intend to go back to the old parser, so I am phasing it out now. To begin transitioning the code base to make of the permanent use of the new parser, I have deleted all the code in the "Dao.Token" module and moved most of the location and token-related data types from the "Dao.NewParser" module to the "Dao.Token" module. All of the modules which will make use of the data types in "Dao.NewParser" and the freshly re-written "Dao.Token" modules must have their imports lists updated to reflect these changes. I also had to make a few more changes to portions of the code which had not yet been modified to make use of the new parser. Everything is up-to-date now.

project-files.list
src/Dao/Evaluator.hs
src/Dao/Files.hs
src/Dao/Object/Binary.hs
src/Dao/Object/DeepSeq.hs
src/Dao/Object/NewParser.hs
src/Dao/Object/PPrint.hs
src/Dao/Object/Random.hs
src/Dao/Object/Struct.hs
src/Dao/Parser.hs
src/Dao/Prelude.hs
src/Dao/Random.hs
Modified the dependencies of the target for the automated test program to reflect the recent changes to the code base regarding the use of the new parser in place of the old parser.
Now that I can do automated testing, I can uncover and correct bugs at a very rapid pace. I am still tweaking the "Dao.Object.NewParser", "Dao.Object.Random", "Dao.Object.PPrint", and "Dao.Object.AST" modules simultaneously as an error in any one of these modules can cause a test to fail. I will have to keep on making changes to each of these modules little by little until I can pass a reasonable number of random tests.
Fixed a bug in the lexer where the special lexers for "data", "date", and "time" expressions were
lexing as keywords even if the input string was not on a keyword, for example, "database" was being
lexed as a keyword "data" followed by a consecutive label "base".

I am still unsatisfied with how difficult it is to create regular expressions. I will need to work
on making it a more intuitive and elegant API later. For now I just need to get the parser as bug-free as
possible.
Improved error reporting for failures occurring during lexical analysis. Before, the 'Dao.NewParser.Lexer' instance of 'Control.Monad.fail' did not set the 'Lexer's state in the 'Dao.NewParser.Error' data structure. So when the 'Dao.NewParser.Error' was evaluated to a string by it's instantiation of 'Prelude.show', the location of the failure and the string that caused it were not being reported. This has been fixed.
Added some words to the random word generator that could interfere with lexical analysis if the lexer is not well designed. For example, I have added "times" and "dates" and "database" because these words should not be considered keywords in a parser where keywords are "date", "time", and "data". The addition of these words will make it easier to break bad code.