VARIABLES:

	General discussion of variables, including local, static, and
	global scoping rules. 

	Variable names must start with a letter, but can contain
	numbers, and underscores ( `_' ) after the 1st character. The
	binary and unary arithmetic operators are not allowed in
	variable names. RLaB is case sensitive. The variables `A' and
	`a' are different.  There is no restriction on the length of
	variables names. Variable names that start with a `_' will not
	show up when who(), or what() are executed, although they do
	exist, and can be used like another variable.

	A variable can hold any kind of data. Variables hold scalar
	and matrix numerics as well as scalar and matrix strings,
	lists, built-in functions, and user-functions.

	A variable must be initialized, or used on the left-hand-side
	of an assignment before it can be otherwise used. Trying to
	use an uninitialized variable will result in an `UNDEFINED'
	message.

	Typing `who()' produces a list of the active variables in the
	global workspace.  This list includes everything except
	builtin and user functions. Typing `what()' will produce a
	list of all the active builtin and user functions in the
	global workspace.

	Assignment to a variable destroys the current contents, and
	replaces them with the contents of the right hand side
	expression.  At present builtin functions cannot be
	re-assigned, but user-functions (and any other variable) can
	be re-assigned at any time.

	The storage space that a variable's data occupies can be
	freed for other usage with the clear command (see `help
	clear').

	-------------------------------------------------------------

	There are three scopes that a variable can exist in: local,
	file-static, and global.

	Global variables are visible to all functions and files, at
	all times. Global variable scope is the default in RLaB. This
	means that you can access global variables within functions
	without special declarations or statements.

	Local variables can only exist within functions, and are
	declared with the `local' statement. Since global scope is
	always the default, local declarations must be made for all
	variables that need to be "hidden" from the global
	environment. Local variables are created each time the
	function is called, and are destroyed each time execution
	leaves the function (unless the local variable is returned to
	the calling environment). Local variables are UNDEFINED upon
	creation - the function must initialize each local variable
	before usage.

	File-static variables are visible only to other functions, and
	statements within the file they are declared in. the static
	statement creates variables that will only be seen by other
	statements (including functions) within the same file.
	File-static variables are created once, and are not destroyed
	until the RLaB session is terminated. We will illustrate with
	a simple example:

		//-------- file count.r -----------------------

		static (cnt)
		cnt = 0;

		//
		// Count the number of times something happens
		//

		count = function ( N )
		{
		  cnt = cnt + N;
		  return cnt;
		};

		//--------------------------------------------
	
	In this example the file count.r contains a static variable
	and a user-function. The user function simply maintains a sum
	of the arguments that count() is called with. During a
	particular RLaB session count() will keep track of the sum of
	all the values of N. cnt will not appear in the
	global-symbol-table. Note that any variable can be file-static
	- thus, we can "hide" functions in files by declaring them
	static (remember functions are variables).

	For a more elaborate example study the file misc/plplot.r in
	the original RLaB source distribution. Plplot.r makes
	extensive use of file-static variables.
