ChangeLog of Tao Language

+ : added
! : changed
* : fixed
- : removed

Release: tao_0.9.0-1_beta(By Fu Limin):

*  Fixed a bug in dereferencing before assignment in class methods.

Release: tao_0.9.0_beta(By Fu Limin):

! Matrix type is generalized to numeric array supporting arbitrary
  dimensions and different precisions including byte, short, int,
  float and double. Many operations are also provided for numeric 
  array.
+ Some convenient and powerful built-in functions are implemented
  to manipulate numeric arrays, including numarray(), apply(), 
  noapply() and which() etc. Basic mathematical functions are also
  supported for numeric arrays.
+ A feature called transient variable is implemented for convenient
  parameter passing in some situations.
+ Some "magic" functions which may take expressions with transient
  variables as parameters to do some computions on arrays and numeric
  arrays without explicit looping and subindexing. These functions 
  include numarray(), apply() and noapply() for numeric array; 
  iterate() and iterget() for normal array; and which() for both. 
+ Some C++ types are provided for transparent passing Tao types
  to C++ modules, so that only two C++ header files( "taoCpptype.h" & 
  "taoPlugin.h" ) are required to develop C++ modules loadable by Tao 
  without linking to any additional libraries.
! The base class for TaoPlugin is changed from TaoBase to TcBase,
  so that the developing of Tao plugins only requires another header
  file "taoCpptype.h".
+ Basic string operations such as substring, insert, replace and
  erase by subindexing. And a few functions are added such as 
  number(), pack() and unpack().
+ Added string regular expression matching for alternate and grouping
  such as /(\d|\w)(@1:\D|\c)/.
+ Substring substitution by regular expressions.
! Embedding expression in regular expressions is changed.
+ More convenient subindexing is supported for array and hash.
+ Local variables.
+ yield statement to use routine as generator.
+ Many operators such composite assignment(+=,-=,*=,/=,etc.), 
  type comparision operators(=?,!?), right operators( .#,.@,.%,etc.)
+ eval(): evaluate a block of codes represented as a string.
+ Loop control: for(e1,e2,e3), logic control: e1 ? e1:e2; 
+ Other functions such as repeat(), about(), import(), load(), time(),
  astime() and asctime() etc.
! Many changes including keywords: sub->routine, continue->skip.
  commenting symbols are also changed.
* Some bugs.

Release: tao_0.8.5_beta(By Fu Limin):

+  A new technique is implemented for dynamic loading of C/C++ modules.
+  New classes are added to re-organizing the structure of interpreter,
  including classes for arithmetic computation and class for garbage
  recycling etc.
+  Namespace features and dynamic creation of classes and subroutines.
+  More internal functions are implemented, including var.type(),compile(),
  array.replace(),array.cat(),hash.keys() and hash.values() etc.
+  File IO object type is added.
+  Constant, shared, external variables are supported.
!  Recursive function is re-implemented.
*  A bug is fixed in arithmetic computation.
*  A bug is fixed in matrix subindexing.
*  A bug is fixed in print cyclic structure.
*  A bug is fixed in array.erase().

============================================
2005-01-08: Changing of name: Yuan >>> Tao
============================================

Release: yuan_0.7.8_beta(By Fu Limin):

+ Numeric data types such matrix, complex number and matrix.
+ Different ways of declaring and initializing matrix.
+ Flexible matrix slicing and sub-indexing.
+ Matrix and complex arithmetic computation such as addition,
  substraction and multiplication etc.
+ Matrix algorithms: LU decomposition and inverse.
+ Multi-assignment such as: [a,b]=[c,d]; or [a,b]=func();
! Arithmetic computations (in general).
! Array manipulation (sub-indexing and assignment).
* A bug in hash declaration by enumeration.
* A bug in printing array variables.

Release: yuan_0.7.5_beta(By Fu Limin):

1. Some parts is modified to handle compiling and running time 
  errors.

2. A simple XML parser using an interface similar to the SAX 
  (Simple API for XML) is implemented and embeded into the Yuan 
  interpreter. This interface can be used in Yuan script directly.

3. Small changes: (a) now Yuan script module can be imported with 
  keyword "import"; (b) loop control "break" and "continue" is 
  implemented; (c) shared variables can be declared with keyword
  "share"; (d) system call can be invoked by "system()".

Release: yuan_0.7.0_beta(By Fu Limin):

1. A new reference counting based garbage collector is implemented 
  based on an algorithm similar to what D.F. Bacon and V.T. Rajan 
  proposed for Synchronous Cycle Collection.

2. A number of bugs are fixed, including bugs in regular expression
  matching.

3. Sample source codes are included.

Release: yuan_0.6.8_devel(By Fu Limin):

1. Part of internal structure of the interpreter is changed
  to allow more flexible ways of variable declaration and 
  assignment.

2. Now class constructors can take parameters, and the
  parameters can be passed to the parent classes in a
  similar way as in C++.

3. Standard Input is enabled.

Release: yuan_0.6.5_devel(By Fu Limin):

1. New way of object construction from Yuan class is implemented.
  It is more efficient in time and memory.

2. A kind of Garbage Collection feature called Local Garbage 
  Recycling is implemented.

3. Re-implementation for passing parameters. Now the 
  parameters are passed into subroutines by references.
   
4. Re-implementation for accessing class data members 
  from method members. Accessing by references.

5. Correction of the algoritm for string regular expression 
  pattern matching.

Release: yuan_0.6.0_devel(By Fu Limin, Sep.08, 2004):

1. A new Strategy for arithmetic, string and other computations
  is implemented. It is more flexible but a little slower than
  before.

2. All data types representation is changed to references of objects.

3. Operations are mainly based on references. Except in assignment
  where when two references for numerics or two references for
  strings meet, the value is copied.

4. More operations for arrays such "append", "insert" and "erase" 
  etc. are implemented.



Release: yuan_0.5.5_devel(By Fu Limin, Aug.26, 2004):

1. Some improvements in airithmetic and string computations.

2. More functionalities(but still basic) for string regular 
  expression matching(Aug.6-10).

3. Dynamic loading of C/C++ library in Linux is enabled(Aug.6-10).

4. Dynamic loading of C/C++ library in Windows is enabled(Aug.21-24).



Release: yuan_0.5.0_devel(By Fu Limin, Aug.03, 2004):

1. Basic Arithmetic computations.

2. Basic String operations.

3. Basic array and hash data types.

4. Reentrant functions.

5. Basic class inheritance.

6. Basic file IO.



From the beginning of May 2004, Fu Limin started to design and 
implement Tao Language, which is initially named as Yuan Language.