ChangeLog.txt - Change log of UKernel.

081304: Benjamin Han <benhdj@cs.cmu.edu> Version 1.92.
061404: Benjamin Han <benhdj@cs.cmu.edu> Version 1.91.
022603: Benjamin Han <benhdj@cs.cmu.edu> Version 1.90.
102102: Benjamin Han <benhdj@cs.cmu.edu> Version 1.89.
102102: Benjamin Han <benhdj@cs.cmu.edu> Version 1.89.
101802: Benjamin Han <benhdj@cs.cmu.edu> Version 1.88.
092802: Benjamin Han <benhdj@cs.cmu.edu> Version 1.87.
092102: Benjamin Han <benhdj@cs.cmu.edu> Version 1.85.
091602: Benjamin Han <benhdj@cs.cmu.edu> Version 1.84.
120601: Benjamin Han <benhdj@cs.cmu.edu> Version 1.83.
092801: Benjamin Han <benhdj@cs.cmu.edu> Version 1.82.
081001: Benjamin Han <benhdj@cs.cmu.edu> Version 1.80.
071701: Benjamin Han <benhdj@cs.cmu.edu> Version 1.79.
071301: Benjamin Han <benhdj@cs.cmu.edu> Version 1.78.
070501: Benjamin Han <benhdj@cs.cmu.edu> Version 1.76.
070101: Benjamin Han <benhdj@cs.cmu.edu> Version 1.75.
062501: Benjamin Han <benhdj@cs.cmu.edu> Version 1.7.
062101: Benjamin Han <benhdj@cs.cmu.edu> Version 1.6.
061501: Benjamin Han <benhdj@cs.cmu.edu> Created.


081304:
Version 1.92:
  1. Changed the toy grammar created in graTstSub.cpp to test the space-adding
     behavior of char-level and non-char-level rules. Incidentally this also
     shows the difference caused by the different modes in the generator (mode
     "fork" vs. mode "plain"). See Appendix D. of the manual for details.
  2. Updated the manual.

061404:
Version 1.91:
  1. Changed the EBlockMain constructor for type 4 equation (eBlock.hpp):
     now it includes an additional argument for grammar - this is to adapt
     for the new new CFG module from Toolbox (see changelog of Toolobox 1.37).
  2. equTst.cpp - necessary changes to use new EBlockMain type 4 constructor.
  3. UShell:isValidFSName() - added missing typecast.
  4. Compiled and run with GCC 3.3.

022603:
Version 1.90:
  1. Added containBlocks() to all types of equation blocks (EBlocks)
     to test if it contains any sub-blocks.
  2. Added EBlockMain::isSingleEqu() to test if the main block is just
     a single equation (instead of a list of sub-blocks).
  3. Added 3 new constraint values: *NOT-NUMBER*, *NOT-INTEGER* and
     *NOT-POSITIVE*.

103002:
  1. Bug fixed in eBlock.hpp: now mIdxSet is correctly updated with
     the newly added operators (=c',=t' and =i').
  2. Added type 5 equations "(lFS lPath) op QFS" (QFS = quoted FS).
     Note op cannot be == (removal assignment) nor < (pop).

102102:
Version 1.89:
  1. Overhaul of lexical lookup functions (lexicon.?pp and eFunc.cpp):
     now all lookup functions should run faster, especially the ones
     with :CHECK argument.
  2. Fixed bugs of =c/=c' and =i/=i' in the cases where RHS is a
     penetrating path: the isomorphism tests should be targeted to the
     individual component in the collection (i.e., each entry in the
     blueprint).
  3. Fixed bugs of =c/=c' and =i/=i': the feature names at the end
     of the LHS path traversal do not matter.
  4. Added new tests in lexTst.cpp and fsTst.cpp, and some misc. code
     cleanup and comments.

101802:
Version 1.88:
  1. Changed the behavior of GET-LEX/GET-LEX-FS with :CHECK keyword argument
     - now they will return the 1st lexical entry after filtering (before
     they only tried to get one single matching entry and then filter it).
     See eFunc.cpp and fStruc.?pp.
  2. FStruc::collectBlueprint() will honor undefined branches now by putting
     boxes in the collected FS/V (via FStruc::collectValue() and 
     FStruc::collectFS()); various operations now take into considerations
     of possible boxes on the RHS.
  3. Added new test program fsBoxTst.cpp.

092802:
Version 1.87:
  1. Changed the behavior of =c (FStruc::constrain() ): it's testing the 
     isomorphism up to the unifiability of values (so =i, i.e., 
     FStruc::isomorphism() are still stricter), and it also filters out in 
     an *OR* FS the branches that do not pass the tests.
  2. Changed the behavior of =t and =i so they now too become filtering 
     operators given an *OR* FS.
  3. Changed the behavior of =i so that it's in line with =c and =t when 
     RHS is empty or undefined.
  4. Added new operators =c', =t' and =i' for non-filtering versions of
     =c, =t, and =i.
  5. Changed the *CASE* block execution to use =t' (FStruc::testNoFilter()) 
     to test each option value instead of =t.
  6. Changed the Lexicon::findLex() to use =t' (FStruc::testNoFilter()).
  7. Changed the behaviors of isDefined(), isNumber(), isInteger(), 
     isPositive(), and added isUndefined() in FStruc(): they now become
     destructive operators - they will filter out the branches in an *OR*
     FS that do not meet the requirement.
  8. Changed the behavior of testing two *NOT* values: they now ALWAYS
     succeed (recall unifying two *NOT* values gives back the union of them);
     so now finally =c and =t are almost identical, except that =t does NOT
     filter out branches in an *OR* FS that do not unify.
  9. Updated the manual (especially the section for operators).

092102:
Version 1.85:
  1. Changed the behavior of type 4 equations - recall type 4 equations are
     equations with extension functions (e.g., GET-LEX and GET-LEX-FS). The
     new behavior is when the execution of the extension function fails, the
     resulting FS is emptied and used in execution of the operator specified
     in that equation - the equation still can succeed, where in the past this
     would fail the entire equation.
  2. Changed the behavior of constraint equations (FStruc::constrain()) so
     the thing gets unified is the thing that's defined; detailed explanation
     is below:

     A trace by Donna reveals that the implementation of =c is inadequate: it's
     currently implemented as: LHS =c RHS returns T iff LHS is defined and LHS=RHS
     (unification). But if LHS is penetrating, the actual FS defined can be
     different from the one unifiable. E.g.,

     X0: (*OR* (A B)
               (C D))
     then (X0 A) =c E returns T since at least in one of the sub-FS A is defined,
     and at least in one of the sub-FS the unification succeeds - BUT these two
     sub-FSs are not the same ones!

     A proper implementation should be: for an LHS penetrating *OR*, LHS =c
     RHS returns T iff at least one 'branch' reached is both defined and unifiable
     with the RHS. AND this applies *recursively*.

     This problem doesn't occur for *MULTIPLE* since it requires "for all" instead
     of "at least one".

     None of the other operators have this problem, after a thorough check.
  3. Modified the behavior of operator =t to be in line with =c (the former one is
     non-destructive and the latter is destructive, otherwise they're supposed to
     behave the same, EXCEPT for one pesky thing: they behave differently when both
     LHS and RHS have *NOT* values). In particular when RHS is undefined it returns 
     T instead of NIL as before.
  4. Updated the manual (sections for lexicons, operator =c and =t; fixed some
     mis-references to figures; cleaned up 6.4 and 6.5 a little).

091602:
Version 1.84:
  1. Added a protected method FStruc::copyDaughter() for implementing Generator
     execution mode modeFork (see ChangeLog.txt in the Generator package).
  2. Fixed various cosmetic printing issues.
  3. Updated the generation examples used in the manual.

120601:
Version 1.83:
  1. Revised grammar modules to use the generic CFG structure in Toolbox -
     the new grammar modules uses a trie (prefix tree) to store RHSs, so
     it's faster and consuming less memory. It also supports prefix search
     and rules removal - it should be much friendlier for parsing now.
  2. Introducing namespace UKernel.
  3. Bugfix: UShell crashed when a kernel command misses LHS or RHS.
  4. Updates of the manual.

093001:
  1. Minor revisions of the manual.
  2. Minor fixes of "make tar".

092801:
Version 1.82:
  1. Full support of "penetrating" paths in all FS operations (penetrating
     paths are paths leading into complex FSs) - both in LHS and RHS.
  2. Major revision of grammar.* to make it possible to do a rule-lookup
     by the rule RHS - grammar API is changed.
  3. Revised the implementation of constraint operator "=c"  - now it has
      the same behavior as that in the 1988 GenKit (which means it's a 
      destructive operator again). The symbol code for the operator is 
      Symbol::OP_CONSTRAIN (Symbol::OP_EQUAL is removed).
  4. Added two new equation operators: a). testing operator "=t" 
     (Symbol::OP_TEST) which is essentially a non-destructive 
     pseudo-unification operator, and b). isomorphism operator "=i"
     (Symbol::OP_ISO) which tests isomorphism between two FSs.
  5. Added C++ operator==() for both Value and FStruc (isomorphism tests).
  6. Added support of printing tracing info while executing equation
     blocks (EBlock::setTracing() etc.).
  7. Bug fixes: correctly compact values and FSs (previous code ignored
     possible embeddings of *OR* under *MULTIPLE* or vice versa); UShell
     now can show help messages on =c, =t and =i.
  8. Augmented testing programs valTst.cpp and fsTst.cpp for all new stuff.
  9. Updated the UKernel manual to reflect the changes; also fixed some
     inconsistent/ambiguous part.

090501:
  1. Fixed a bug in EBlockOr::run(): now it reports 'true' correctly; 
     revised EBlockOr::run() and EBlockEor::run() and they now run more
     efficiently by ensuring that copying FSs only happens when absolutely
     necessary.
  2. Revised FSregisters::copy() (the 1st form) to copy/remove only the
     additional/redundant FSs - faster.

090301:
  1. Revised to compile under g++ version 3.0 with -Wall -pedantic.
  2. Minor revisions to work with the latest Toolbox (tree algorithm class
     name changes).

082001:
  1. Fixed the init ordering problem of the static TokenDict<> inside TokenID<>/
     Symbol: now the static TokenDict<> is in a method - see tokDict.hpp and
     tokID.hpp in Toolbox.
  2. Revised testing programs to compile with less memory.
  3. Revised Makefile so you have to "make bin" or "make ush" to build UShell.

081701:
  1. Changed the string argument in Grammar::Grammar() and Grammar::setStart()
     to a Symbol argument (so the direct manipulations of strings are 
     restricted to symbol.*).
  2. Removed the old documents Operators.txt, Guidlines.txt, TO-DO.txt, 
     and Diff-GenKit.txt. Added a complete manual doc/uKernelManual.ps.  
  3. Made the kernel commands in UShell case-sensitive.
  4. Split build targets in Makefile into 2 sets: the default object-only
     target, and the testing programs target, so now you can build only the
     object files.
  5. Building using optimizations.

081001:
Version 1.80:
  1. Updated to work with Toolbox v1.3.
  2. Changed RHS::lexical flag to RHS::charLevel in grammar.hpp.
  3. Several bug fixes about using operator-- on various data types.
  4. Changed all .cc files to .cpp files, and all .h files to .hpp files;
     also changed the other related files for this.

071701:
Version 1.79:
  1. Complete support of interactions between *OR*, *MULTIPLE*, and atomic FSs.
  2. Revised the behavior of unifying two *OR* values.
  3. Code cleanup and minor bug fixes.
  4. Updated testing programs and documentation.

071301:
Version 1.78:
  1. Again revised the behaviors of interactions between atomic/complex 
     values/FSs to match those in the 1988 GenKit (esp. *MULTIPLE*). Note
     however the interactions between *OR* FSs with the other kinds of 
     FSs (*MULTIPLE* and atomic) have yet been fully implemented.
  2. Removed equation type 5-10 and revised the equation type 4 to be the
     interface to the Extension Functions - a kind of callback mechanism
     to allow easier system extension via adding more types of equations.
  3. Revised the lexicon facility - no more next-lex but much more flexible
     get-lex/get-lex-fs equations (optional arguments are allowed, and
     if wanted all matching entries can be returned in a big *OR* FS).
  4. Updated all documentation.

070501:
Version 1.76:
  1. Correctly model the execution of *OR* equation blocks - a combined *OR*
     FS will be produced if the execution is successful, and the resulting
     FS will have no duplicate daughters. Note however the interactions
     between *OR* FSs with the other kinds of FSs (*MULTIPLE* and atomic)
     have yet been fully implemented.
  2. Documented the interactions between complex (*NOT*, *OR* and *MULTIPLE*)
     and atomic values in Operators.txt.
  3. Added document Guidelines.txt for efficiency suggestions to grammar
     writers.

070101:
Version 1.75:
  1. Finished complete review of value.* code - fixed several bugs and revised
     some definitions of interactions between complex values (will be 
     documented in the next version).
  2. Changed the way to address FSs in the equations. Now when initializing
     equation blocks instead of passing FStruc & you need to pass the index
     of the FS; e.g., for equation (x1 <= x0) the corresponding constructor
     call is EBlockMain(1,lPath,0,rPath,Symbol::OP_ASSIGN) with both lPath 
     and rPath cleared. See equTst.cpp and graTstSub.cpp for more examples.
  3. Fixed a brain-dead bug in dealing with *MULTIPLE* FSs - now the code is 
     recursive.
  4. Following 2 the behavior of *EOR* execution is now truly parallel - 
     the executions of the daugher blocks of an *EOR* block are now independent
     from each other. The revision of *OR* execution hasn't been done since
     it involves introducing *OR* FSs - this will happen in the next version.

062501:
Version 1.7:
  1. Full support of *MULTIPLE* FS (i.e., all FS operations are well-defined
     over *MULTIPLE* FS).
  2. Test programs valTst and fsTst are greatly augmented to add more tests
     for value compactions and *MULTIPLE* FS.
  3. Fixed FS printing problem (missing a pair of parentheses) and it's also
     printing out *MULTIPLE* FS correctly.
  4. Fixed value compaction bug: recursive compaction is now in place.
  5. Other bug fixes: tree.hpp in Toolbox now only allows node updating through
     _TreeIteratorBase<>::update() and _TreeIteratorBase<>::get() (dangerous),
     and the DMap updating is corrected; set 'succ' correctly in
     FStruc::extendPath(), etc. etc.

062101:
Version 1.6:
  1. New equation type 9 and 10 for get-lex-fs with unquoted (FS PATH).
  2. Fixed errors in Lexicon::nextLex(const FStruc&,Symbol&).

061501:
Version 1.5:
  1. Lexicons facility: now you can load in multiple lexicons and use the
     various lexical-lookup equations (get-lex/get-lex-fs/next-lex).
  2. Grammar module is now inside UKernel.
  3. You can use wildcards (%) in the grammar rules (in both lexical and 
     non-lexical rules). Run graTst to see a sample grammar.
  4. You can change the starting NT for a grammar (default: "S").
  5. Grammar is now direction-independent (Grammar::setDir()).
  6. Bug fixes: undefined initialization order of global/static objects
     in multiple translation units, incorrect path extending
     (FStruc::extendPath()), etc.
