diff options
Diffstat (limited to 'src/aapl/ChangeLog')
| -rw-r--r-- | src/aapl/ChangeLog | 562 |
1 files changed, 562 insertions, 0 deletions
diff --git a/src/aapl/ChangeLog b/src/aapl/ChangeLog new file mode 100644 index 00000000..483ad825 --- /dev/null +++ b/src/aapl/ChangeLog @@ -0,0 +1,562 @@ +Aapl 2.14 - March 17, 2006 +========================== + -Added a transfer function to the double list. This function should supersede + the use of shallowCopy + abandon. In the by-value list the destination list + is emptied first. + -Added a transfer function to the Avl tree. + -All double lists and Avl trees now implement deep copies in the + operator=(...) functions and copy constructors. Previously only the by-value + versions of these structures would do deep copies. + -Removed the deep and shallow copy functions from the double lists and Avl + trees. These structures should now be consistent accross all variants except + for the fact that the by-value versions delete elements in destructors and + when overwriting and the others simply abandon their elements (which may not + be allocated on the stack). + +Aapl 2.13 - Jan 25, 2006 +======================== + -The vector and binary search table constructors that set an initial amount + of allocation have been removed. They have been replaced with constructors + that insert initial values, which is a more common task and is a more + intuitive use for contructors. + -Removed the String class. Better to use the stl string class. Aapl::String + does not provide any real advantage over the STL version. Aapl::String has + not been heavily tested and does not have very much functionality. + -Removed the "tiny" versions of templates. These templates had functionality + reduced in the interest of reducing compiled binary size. These templates + did not find any real world use, nor were they heavily tested. + -Removed the "simple" versions of vectors. These should be implemented as + template specializations, not new classes. May be brought back as such in + the future. + -Added vinsert and vremove routines for accessing the insert and remove of + the underlying vector of binary search tables. Previously, these were + accessed by prefixing the insert call with the vector base class name, + however this method is somewhat inconvenient, because it either requires all + the template arguments to be given or an additional typedef to be made. + Prefixing the call with the letter v is simpler. + +Aapl 2.12 - May 15, 2005 +======================== + -Documentation updates to trees, lists, compare classes, binary search tables + and various other places. + -Added iterator documentation and example. + -Added proper includes for all examples, which now all compile. + -Table comparisons now properly inherit the CompareT class, enabling table + comparisons to call non-static element compare classes. + -Removed the Deque structure. This structure was never used, incomplete and + poorly tested. In most problems for which it is a candidate (large + collections of objects in sequential ordering that are not required to be in + contiguous memory), a simple replacement can easily be implemented with a + small amount of code. Rather than be allowed to go unused and unmaintained, + it is removed. + -In the AvlTreeEl structures for Maps and Sets, getKey can be const. + -Removed the non-standard malloc include. + +Aapl 2.11 - May 30, 2004 +======================== + -Moved from ints to longs for most integer values to get 64 bit numbers on 64 + bit machines. Fixes alignment problems on 64 bit machines. + -Added AvliBasic, the linked version of the basic tree where the entire + element is the key. + -Updated documentation. + +Aapl 2.10 -- Feb 5, 2004 +======================== + -Fixes for two-stage lookup. Compiles with gcc-3.4 + Details at http://gcc.gnu.org/onlinedocs/gcc/Name-lookup.html#Name%20lookup + -Fixed wrong Vector::Iter::pos() routines. + -FsmGraph code removed from aapl, as an increasing amount of diverse + specialization is required in applications. No longer feels like a general + purpose template. + +Aapl 2.9 -- Dec 8, 2003 +======================= + -Rewrote Deque to look and behave more like the rest of Aapl. Split it into + Deque and DequeSimp. Deque supports complex classes with constructors and + destructors. DequeSimp is for simple classes that can be coppied with + memcpy. Wrote stress tests for both. + -SVector::makeRawSpaceFor fixed to detach from the vector when the current + storage is shared. This affected SBstTable::insert() routines and caused + them to modify shared data, instead of behaving like copy on write as they + should. + -Tiny templates renamed to be consistent with the non-tiny templates. The + tiny versions now only have a T prepended to the name, the second character + is no longer lowercased. This changes Tavl* to TAvl*, TdList* to TDList* and + TsVect* to TSVect*. + -Removed AvlPmap, AvlPset, AvliPmap, and AvliPset. Rationale is that these + are too application specific. They require a pointer as the key (not + anything that dereferences the pointer) and so do not generalize very well. + Due to their lack of generality, they belong in application code. They + allowed a savings in code size when many instantiations were necessary, + however, the savings was only slightly better than TAvlTree. + -Test programs split into stress tests and non stress tests. All stress tests + run indefinitely as long as they don't encounter an error condition, in + which case they terminate by an assertion failure. They can be given a time + limit to run for by specifying the number of seconds on the command line. + -FsmGraph given repetition operators for repeating a machine n times. + -Concatenation operator accepts an optional list of states to draw the epsilon + transition instead of the from graph's final state set. + -Useless shared table header template parameter removed. + +Aapl 2.8.2 -- Aug 18, 2003 +========================== + -AvlSet::Iter and DListVal::Iter data access operators (*, ->) now return the + node in the tree, rather than value. This is to make all iterator behaviour + consistent: return the element. This also allows for O(1) statements like + tree.detach( iter ); + -DList and DListMel and Avl trees that are not sets or maps no longer do a + deep copy in the copy constructor and assignement operator. This is to stay + consistent with the fact that these lists and trees are not responsible for + managing the memory of the elements they contain. + -Table compare split into static and non-static versions. Default is the + static version, which compiles out the 'this' pointer. If an item compare + requires access to class data, the CmpTableNs can be used. + -The user's Fsm class is now required as a template parameter to FsmTrans, + FsmState and FsmGraph. + -All callbacks moved into FsmGraph class to allow the access of user data in + FsmGraph. + -Added callbacks for state creation and destruction to FsmGraph. + -EpsilonOp now takes a list of fsms to draw ops to. Allows the merging in of + several machines using only a single invocation of the NFA to DFA algorithm. + -FsmKeyOps is now expected to be a base class of the derived fsm class (ie a + sibling of FsmGraph). + -In transition lists are encapsulated in a class with an iterator. + -Unused leavingFsm parameter to starOp and concatOp removed. + -Fixed documentation building warnings. + -Documented iterator classes. + +Aapl 2.8.1 -- Jun 11, 2003 +========================== + -All iterator endpoint test functions have been renamed. + Iter::more() -> Iter::lte() + Iter::done() -> Iter::end() + Iter::revMore() -> Iter::gtb() + Iter::revDone() -> Iter::beg() + The rationale is that it is not obvious that more() and done() are direction + specific. It is more clear that lte() (less than end) needs to be changed to + gtb() (greater than beginning) when reversing the direction of a traversal. + -All avl tree element classes have been renamed to make element names + consistent. + AvlNode -> AvlTreeEl + AvliNode -> AvliTreeEl + AvlMapNode -> AvlMapEl + AvliMapNode -> AvliMapEl + AvlSetNode -> AvlSetEl + AvliSetNode -> AvliSetEl + TavlNode -> TavlTreeEl + TavliNode -> TavliTreeEl + TavlMapNode -> TavlMapEl + TavliMapNode -> TavliMapEl + TavlSetNode -> TavlSetEl + TavliSetNode -> TavliSetEl + AvlPmapNode -> AvlPmapEl + AvliPmapNode -> AvliPmapEl + AvlPsetNode -> AvlPsetEl + AvliPsetNode -> AvliPsetEl + FsmSDNode -> StateDictEl + AvlTree::nodeCount -> AvlTree::treeSize + -All binary search table and avl tree classes now inherit from the compare + class. This allows the compare function to be non-static and for it make use + of state that is common to the data structure. + -BstTable(int allocLen) no longer uses Vector::setAsNew and therefore Element + does not require Element() constructor. + +Aapl 2.8.0 -- Jan 5, 2003 +========================= + -Switched to the LGPL. + -Added get() to String class. Returns the data ptr. + -Added operator<<(ostream &, String&). Previously relied on the implicit + cast to char* which did not work all the time. + -Iterators renamed and rewritten. The new style for checking if the iterator + is done is to call more() or done() if moving forwards and revMore() or + revDone() if moving backwards. Iterators now have first() and last() calls + for checking if the iterator is on the first and last element. The next() + and prev() calls now return the next and previous. THEY NO LONGER MOVE THE + ITERATOR FORWARD OR BACKWARDS. Increment() and decrement() are now available + for moving the iterator. + -Various fixes for the intel C++ compiler. + -Shared vector table header renamed from TabHead to STabHead. + -Started Tiny DList, Tiny VectSimp, Tiny SVectSimp, and Tiny AvlTree. These + classes reduce final executable size by reusing core code across + instantiations with different types. They can be used identically to the + non-tiny counterpart if only iterators are used for accesing the structure. + The catch is that the underlying data structures have generic pointers that + are not directly usable without casting. + +Aapl 2.7.0 -- Dec 20, 2002 +========================== + -DoubleList::length -> DoubleList::listLen and added length() function. This + is to keep consistent with vectors and strings. + -Sorting routines now inherit from the compare class and use a non-static + compare routine. This lets the compare have state. This will likely be + extended to all structures that use a compare class. + -Constructor added to string that does sprintf style formatting. + -Routines added to string for setting from a char*, len pair. + -Table class (used by vector) member length changed to tabLen and the + the length() const routine added. This makes SVector a more easy substitute + for Vector. Previously the length member was an int in Vector and a function + call in SVector. Now it is a function in both. + -String::str -> String::data and String::getLen() -> String::length() to make + access of string data consistent with access of table data. + -Binary search tweaked to use a shift in place of a divide. + -FsmGraph code from rlfsm moved back into Aapl and Reglang FSM terminated. + Now that the graph code has been separted from the priority and action code, + the base template is leaner and more generalized. It now fits well in Aapl + as a generic programming construct. Also, rlfsm was not enjoying much + exposure and no sense in letting the fsmgraph code fight for itself. The + relevant fsmgraph changes since the split at 2.5.0 follow: + -Support of arbitrary key types for graph completed. + -Dramatic performance improvements in basic fsm operations. Kleen star, + union, and concatenation do not require a walk of all states and can go very + fast when there is no overlap between the machines. + -Fsm Range transitions implemented. Can now efficiently specify machines that + span very large ranges. + -More efficient partition based fsm minimization implemented. Algorithm is + similar to Hopcroft's minimization algorithm. + -Fsm Graph split into base code that implements FSM operations, NFA-DFA + conversion and minimization and a superclass that implements priority and + action setting. Allows the base code to be easily reused for other + applications that require different state and transition properties. The + superclass is left as user code in Ragel and is not included in Aapl. + -Can now have various classes of named entry points in an fsm graph for + maintaining entry other than the start state. This is useful for making + actions that jump into or call various named locations in the machine. + -Various bugs in fsm graph code fixed. + +Aapl 2.6.0 -- Nov 4, 2002 +========================= + -Added AvlPmap, AvlPset, AvliPmap and AvliPset classes. These are + instantiations of AvlMap and AvlSet with void* types and a small inline + wrapper interface for doing type conversions. If many different maps are + used for storing integers or pointers then these classes can cut down on + code bloat. + -Added AvlTree::remove, which will detach and delete elements from the tree. + -Removed set, unSet and isSet from AvlTree. These functions are redundant and + clutter the interface. + insert/remove/find functionality just for convenience. Prefer to remove them + than to clutter the interface with inconsistently named functions. + -Fixed the return type of BstTable::removeMulti. It should be an int (not + bool) because it returns the number of items removed. + -Added SVector and SVectSimp: implicitly shared copy-on-write vectors. + -Added ResizeCtLin: Identical to ResizeLin, except the step is specified at + compile time using a template argument. + -Removed deepCopy from the classes that by default behave as a deep copy. + Found the duplicate function to make it confusing as to how the structure's + operator= behaves. + -File rename of shrstr to astring, to make it easier to find. + -BsTable renamed to BstTable to stay consistenty named with the other Bst + classes. Also renamed the file from bstable.h to bsttable.h for consistency. + -Compare class routines are now Compare::compare (used to be + Compare::Compare). This is to keep with the lowercase function name + convention. + -Added the insertion of whole elements to BsTable and BstMap (already exists + for BstMap). + -Added the insertion of entire other tables to BsTable, BstMap and BstSet. + -The getKey function for binary search table must now be const as well as the + existing requirement of returning a const object. This was needed for the + insertion of whole elements so the requirement was made for all + insert/remove/find routines in order to stay consistent. + -Removed set, unSet and isSet from BstSet. These functions duplicated the + insert/remove/find functionality just for convenience. Prefer to remove them + than to clutter the interface with inconsistently named functions. + +Aapl 2.5.4 -- Sept 20, 2002 +=========================== + -All of Aapl is now in the Aapl:: namespace, which is disabled by default. It + can be turned on by defining #define AAPL_NAMESPACE. + -Mergesort uses only memcpy to move data around, instead of the inconsistent + use of the = operator. Classes that are sorted have no way of knowing that + they are being moved around in mem. + -Implemented QuickSort, BubbleSort and Insertion Sort. + -QuickSort uses InsertSort when the array being sorted is small. + -MergeSort uses BubbleSort when the array be sorted is small. + -Implemented an implicitly shared string class. + +Aapl 2.5.3 -- Aug 17, 2002 +========================== + -Much work done on the user documentation. + -AvlMap and AvlSet destructors now delete all elements. The idea is that + these classes manage memory on behalf of the user, so cleanup. Also, a deep + copy will cause the existing contents to be deleted. The remaining avl trees + do not assume ownership of element and thus do not delete anything. + +Aapl 2.5.2 -- Aug 14, 2002 +========================== + -Bug fixed in Vector::replace. When overwriting data without overwriting up + to the end of the vector or extending it, the vector would shrink in size. + This is because the tableLength was getting set to the end of the overwrite + region in every case. + -Bug fixed in empty and abandon of Avli* trees. They now clear the list head + and tail pointers. + -shallowCopy, deepCopy and the = operator were added to double list, vector, + and avl tree. The = operator implements the deep copy functionality. + -The Vector class was heavily rewritten. The purpose of the rewrite is to + have a vector that does not require the class that it contains to have a + default constructor. In many cases adding a default constructor violates the + design of a class. A class should not be required to have a default + constructor just because it is going into a vector. To have this feature, + the new vector differs from the old vector in a few ways. If the vector is + instructed to add elements off the end of the vector then undefined + behaviour results. The new vector will not implictly create new items. + Also, new items cannot be added to the list by giving a null data pointer. + Instead insertNew, appendNew, etc. can be used. + -DListVal destructor now deletes all elements. The reasoning is that DListVal + manages elements and so it should clean up after itself. + -remove routines added to double list classes. They are the same as detach + except they also delete elements. + -Default down resize of ResizeRunTime fixed: now is Exponential as is the up + resizing. + +Aapl 2.5.1 -- Aug 9, 2002 +========================= + -Class and function descriptions from doc/*.txt moved to source code in + doxygen format. + -Iterators slimmed down in anticipation of the more coplicated iterator for + avltree. Iterators now provide basic moving forward and backward and looking + at current value. Looking ahead and moving ahead by more than one space is no + longer supported. + -Assignment operator of all iterators now return a reference to this. + -Implemented iterator for avl tree (non Avli* trees). The iterator can be + started on either end and can move forwards or backwards. Does not support + trees larger than 32 element in height (should be sufficient). + +Aapl 2.5.0 -- Jun 22, 2002 +========================== + -Doxygen docs started. + -ExpnResize -> ResizeExpn, ConstResize -> ResizeConst, LinResize -> ResizeLin + Name changes that will keep a lexographically sorted list of classes in good + order. + -StrCmp -> CmpStr, OrdCmp -> CmpOrd, TableCmp -> CmpTable for same reason as + above. + -BstTable fixed so that Resize class is passed to underlying vector. + -Pdp Endianness support removed as it is untested. Don't have a pdp endian + machine on which to test. + -cc file extension changed to cpp for better portability. + + ******** Aapl split out into three libs: Aapl, Autil, Reglang FSM *********** + + Aapl is: A generic programming template library. Aapl is an alternative to + the STL. It currently contains Linked List, Avl Tree, Vector, Binary Search + Table, Double Ended Queue, Merge Sort. + + Autil is: A library of simple utility classes that are easy to come by. + Autil contains paramater parser, byte ordering facilities, character + classes. + + Reglang FSM is: A template library of algorithms and data structures for + compiling state machines from regular languages. + +Aapl 2.4.1 -- May 4, 2002 +========================= + -Fixed automatic dependencies, were not working correctly. + -C++ standards compliant I/O and namespaces. + +Aapl 2.4.0 -- May 3, 2002 +========================= + -Vector now uses malloc, realloc and free so the performance gain of + of using realloc over new, memcpy, delete in resizing can be realized. + -Buffer Renamed to VectSimp. The name buffer is way overused and brings + preconceptions with it. VectSimp now has the same functionality as vector. + It is a 'flavour' of vector. The main difference is that is does not use + copy constructors/destructors. It uses memcpy to put data in and as a result + can go much faster. The idea is that it is used on 'simple data'. + -The type of resizing that vector uses is no longer controlled by including + different files and using different names (ie, VectorC no longer exists). + The old style (last seen in v1.1.2) of using a template parameter has been + resurrected. It was previously removed because it caused very long symbol + names. That problem has been fixed by making the class that goes into that + template parameter not a template. It is a normal class and as such will + cause symbol names to increase a constant amount. The old way was the class + was a template taking type T so that essentially doubled the length of the + symbol. The purpose of this change is to eliminate the many files required + to have all the different resizing types. Any class that inherits from + vector needs to have many flavours in order to support the different + resizing types and that gets ugly. Providing resizing options to the bstable + classes would require 30 files. + -Default step for linear resizing is changed from 10 to 256. + -FsmGraph structure supports Default transitions. Default transitions can be + used in place of newing up a transition for every char in the alphabet in + order to get the 'dot' and 'dot star' fsms. It is incredibly more efficient + and will make large integer alphabets feasible. + -The conversion from FsmGraph to FsmMachine is now moved into a class called + FsmBuild. + -FsmMachine no longer stores transition indices as a linear chunk. Now + stores key, index pairs. This will facilitate using FsmMachine with very + large alphabets because large index tables will not be allocated. when there + is great variation in transition keys. + -FsmMachine stores only offsets, no pointers. + -Aapl assert is removed in favour of using system assert. Can't see a reason + to duplicate system include. + -Lowercased the interface to BsTable. + -Makefiles use automatic dependencies. + -AvlTree interface was lowercased/consolodated. + -Large switches at the top of *common.h files were removed. The defines were + put into the files that include the common files. + -BsTable interface was lowercased/consolodated. + -BstSet replaces VectSet. + -Configure script allows you to specify what objects to build using the + --enable-src option + -AvlTree verification is moved out of the main tree and into the test cases. + +Aapl 2.3.1 -- March 25, 2002 +============================ + -Fixed errors in the event loop with respect to unregistering. + -Added Signal handling to event loop. + -Breaking out of event loop is now much cleaner. + -Added CONTENTS file. + -Removed trivial class File. I think most would rather code this kind + of stuff on their own, or use a more featureful library. + -Removed Data base class. Again, kind of trivial. Better left to the user. + -DList::detach{Front,End} -> DList::detach{First,Last}. This change was + made in order to be more consistent with the iterator convention of + using first, last, sfirst, slast. + -Wrote documentation for double list. + +Aapl 2.3.0 -- March 19, 2002 +============================ + IMPORTANT: This release marks the beginning of a major change in the + naming conventions. Previously, naming conventions had function names + starting with an upper case. The member functions will slowly be changed + to start with a lower case. Some functions names will also be changed + to follow the conventions in doc/conventions.txt. Vector and DList have + already been changed. + + These changes are being made to make aapl more compatible with existing + template libraries and to provide a more consistent interface across + the classes. + + -Vector and double list get iterators. + -Fixed buffer. Restructuring vector broke it. + -Lower cased names in vector. + -Lower cased names in doublelist. + -Vector::Overwrite -> Vector::replace + -Vector::Delete -> Vector::remove + -DList::AddEnd -> DoubleList::append() + -DList::AddFront -> DoubleList::prepend() + -DList::DeleteElements -> DoubleList::empty() + -DList::EmptyList -> DoubleList::abandon() + -Added DListVal, which is the 'by-value-type' double list that does + not require a DListEl class to be defined. + -Began conventions doc. + -Rewrote the connection/selector code. It is now simpler and more generic. + Docs on the way. The code is now in event.{h,cc}. The select loop can + reliably translate asyncronous signals into events in the event loop. + However, code is not yet set up for processing the signal events. The event + loop handles signals using sigsetjmp/siglongjmp and avoides the classic unix + select loop race condition with respect to signals. + +Aapl 2.2.0 -- Feb 25, 2002 +========================== + -Added AvlSet. AvlSet is like AvlMap except you give only a key. It also has + the set interface: Set, UnSet and IsSet that return boolean values and don't + really care to speak about element in a tree. + -Added walkable versions of avl tree. There is a walkable version of all + existing trees. They are AvliTree, AvliMel, AvliMelKey, AvliMap, and AvliSet. + Implemented by having the element inherit from DListEl and the tree inherit + from DList. All operations on the tree remain O(log(N)). Maintaining the list + pointers adds a constant amount of work. Adds 8 bytes to each element (for a + total of 24) and 12 bytes to the tree (for a total of 20). + -Added a few more sections to docs for AvlTree + +Aapl 2.1.0 -- Feb 22, 2002 +========================== + IMPORTANT: VectorC(int) no longer has the same meaning. Previously it set + allocation length with no size. Now it sets size with no allocation so + it is effectively useless as the table cannot grow it's allocation. It + will assert fail. Use VectorC(int, int) instead. See Vector docs. + + -Further split Vector into all possible types of upresizing and down + resizing. Existing Vectors remain unchanged except for constructor of + VectorC. It is now possible to have a vector that up resizes linear and + down exponential or up exponential and no down (constant), etc. Also + added VectorR, which allows for runtime setting of how to resize. + -Implemented a step for the linear vector. Now the following is true: + If the sequence of size requests is linear, the number of resizes is + also linear. + -Wrote docs for Vector. + +Aapl 2.0.0 -- Feb 17, 2002 +========================== + IMPORTANT: The 2.x.x version of Aapl is not backwards compatible with + 1.x.x version. Code that compiles against 1.x.x may not compile against + 2.x.x. The changes mostly amount to two things: + + 1) Making data and function class member naming convetions consistent. All + variables start with a lower case whereas functions, classes, constants + and type names all start with an upper case. + + 2) Shortening the symbols in resulting object code. Aapl classes achieved + great versatility by providing many tempate parameters mostly with + default values. Now this versatility is achieved by splitting the class + up into many different classes, each with thier own 'flavour' of the data + structure. This split is accomplished using preprocessor defines so there + is no code duplication. Classes now have shorter names and only required + template paramaters. This dramatically cuts down on long symbols and + eliminates compiler warnings on platforms that restrict symbol lengths. + + -Made all data member names consistent with general coding style: constant + identifiers start with upper case, variables (members too) start with lower. + -Split up DoubleList into DList and DListMel. Goal is shorter + symbol names by making two specialzed classes instead of one general class. + -Split up AvlTree into 4 classes. Same goal as split of DoubleList. + AvlTree now supports having multiple keys in the same object as well as + multiple tree pointers. This means a single object can be in different + trees that each use different keys. + -General rearranging of code in fsmgraph and changing templates to result + in shorter symbols. Try to keep symbol lengths < 255. + -Split up Vector into 3 classes, one for each table type. + -Split up VectorSet into 3 classes, one for each table type. Also renamed + it to VectSet for conciseness. + -Split up Binary Search table into 6 classes, one for each table type times + regular bst table and bstmap. The bstmap has the template semantics of + the old bstable. BsTable lets you give the whole object you want to put in + the table in the same manner as vector and avltree. + -Both AvlTree and BsTable use GetKey() functions in the element/element types. + Previously they required that the key member be named 'key.' It can now + be named anything, and it must be returned by GetKey. + -Added copy constructor for AvlTree. + -Added Avl test progs for the various flavours. + -Started some real docs. Currently only AvlTree is documented. + +Aapl 1.2.2 -- Feb 2, 2002 +========================= + -Started ChangeLog file. + -Parser Gen is now gone from aapl. It is not generic reusable code. It now + lives in Keller which will be released soon. + +Aapl 1.2.1 -- Jan 29, 2002 +========================== + -Can choose between assertions that dump details of the assertion + failure to the screen then segfault or just segfault using a define. + -Bugfix in avltree insertion. Only showed up when re-using avl element. + The insert routine was not nulling out appropriate pointers when adding + a leaf element. Worked correctly when always newing up element (how avl tree + is mostly used) as nulling out pointers is done by the element constructor. + -File Buffer size up to 1K. Was at 10 bytes for debugging/testing purposes. + -Transition count variables gone from fsm graph. Computing this is silly as + the vectors that implement the out transitions + -Transition priorities routines in FSM Graph no longer operate as a 'delta' + but instead as absolute. + -Function keys are no long a duple, instead just one integer. Using two + integers is overkill and not likely to be used. To acieve the same effect as + a duple, break the bits of the single integer into multiple fields. + -Allow the shifting of the priorities of start transitions to above some + value. Useful before staring machines so that out transitions of a final + state run before the transitions of the start state when going from a final + state back into the machine. + -Allow the clearing of transition functions. + -Cleaned up FsmAttachStates: no longer reusing transitions when replacing, + old trans are deleted and a new one is made. This eliminates the need for + the ResetTransition routine. + -When building machines, use max int and min int as the defaults for highIndex + and lowIndex. + -When building machines, transition 0 is always the error transition, + no longer insert it into the transition list on demand. + -When building machines, compute the global high and low index. Used by ragel. + -Out priorities have a concept of being set vs not being set. + -Concatenation and Star can now behave as if they do not cause leaving the fsm. + Allows the user to turn off picking up of out transitions and out priorities. + +Aapl 1.2 -- Aug 28, 2001 +======================== + -Initial release. |