
 Scope:
 ------

Originally, variables were created in local scope if not found in
nested scope, ex.:

a=34;

define second() {
  println a;
  println b;
}

define first() {
  a=1;
  b=2;
  second();         
}

first();

The assignments in first() were as follows: a was found in nested
(global) scope and assigned 1, but was not found and therefore created! This
is clearly dangerous and 2 alternatives exist:
  - Never access global variables, always create local ones. To access
    global vars, they would have to be marked specially (e.g. ::a like in
    C++). With our design, even vars local to an If-stmt or WHILE-stmt would
    not be able to access vars in function scope ! This was rejected.
  - Declare local variables. If not declared, variables refer to next found
    variable in nested scope. Will only be created locally, if no nested
    scope contains variable. The above example would have to be written
    thus:

    define first() {
      vars: a, b;  // added
      a=1;
      b=2;
      second();         
    }

    Now vars 'a' and 'b' are declared local.

 Methods:
 --------

A Method is a function with a this-pointer. It is encountered only
inside a class definition. A MethodCall calls a Method. It means that
it is a method- or function-call from within an instance. It first
checks the member methods, afterwards the global functions.  The 2
classes were created (rather than using Function and FunctionCall) for
simplicity reasons.  A flag is set that determines whether we are in a
class. If we are, and a function_def is encountered, we return a
Method, otherwise we return a Function. If we encounter a function
call, we return a MethodCall if the flag is set, otherwise a
FunctionCall. 
The this-pointer of a Method and the correct scope is set when
retrieving the method to be called (RetrieveMethod()).
