
			     Version 0.9
			     -----------

 22.08.96:
 ---------

 Changed bug (feature ?) in classes: if variables are not declared
 using the 'vars' statement in the header of a class, they will not be
 found unless there is a var with the same name in an enclosing scope,
 e.g:

 class X {
   
   methods:
   
     define Foo() {
       l=#(1, 2, 3);
       if(true) {
	 println l.At(0);  // ** problem **
       }
     }
  
 }

 The var 'l' had to be explicitly declared like so:
 
 ...
 vars: l;
 ...

 This 'feature' has now been removed, that is, the variable 'l' will
 be created the first time it is used (in the scope of function
 'Foo'). Note that instance variables sill have to be declared using
 the 'vars' statement !

 29.08.96:
 ---------

 The macro YY_INPUT was redefined to get its input from an instance
 (singleton) of class 'Input'. This instance maintains a stack of
 input sources (such as file input, stdin, streams etc.) and when asked
 for a character, it will itself ask the topmost object to return a
 character, or, if the stack is empty, return EOF. There are currently
 four types of input sources:
 - StdInput: This object reads from stdin and is the first object on
   the stack (put there by Input's ctor).
 - StreamInput: Reads from an input stream (istream).
 - StringInput: Reads from a string.
 - FileInput: Reads from a file.

 This scheme allows for easy change of the input stream for
 (f)lex. Another input stream can be made to default by just calling
 the method 'Push' of Input. This will read from the new stream until
 an EOF is encountered, in which case it will re-establish the previous
 stream by calling the method 'Pop' of Input.

 Different versions of lex implement changing of input streams in
 various ways so that providing an Input object, we can get some
 uniformity. For each lexer, the manner of getting input has to be
 changed to call method 'GetChar' from Input.

 The AIX lexer doesn't know YY_INPUT, we still have to change that !


 03.09.96:
 ---------

 Modified AIX version to use flex and bison rather than lex and yacc.

 Functions can now be parameters to function calls:

 define add(a) {return a*a;}

 define Apply(func, list) {
   for(i=0 to list.Length()-1) { 
     println func(l.At(i));
   }
 }

 l=#(1,2,3,4,5);
 Apply(add, l);


 16.09.96:
 ---------

 Made yyparse recursive. This allows to call yyparse from within an
 active yyparse.
 

 17.09.96:
 ---------

 Added simple debugging tools. Flag -t allows to debug the code. The
 following commands are accepted on the '(debugger)' prompt:

   'n': next statement
   's': step into statement
   'b <functionname or classname::methodname>: breaks in next function
                                             or method with given name
   'c': run until next breakpoint is encountered
   'r': return from current stack frame

 For inspection of values, calling of functions / methods etc., normal
 GOMscript statements can be used at the debugging prompt, e.g.:

   (debugger): println a+ret;
   34
   



 


