ABOUT LOCAL VARIABLES (The EPIC4 goal)
--------------------------------------
Im just putting down in writing what i think local variables should
be all about.  I intend to make the implementation as close to this
description as possible (obviously).  Feel free to comment on this.


The scope of a local variable:
------------------------------
A local variable is any variable that has a predetermined lifetime, and
a scope that is determined syntactically.  This differs from "timed" 
variables that expire when their lifetime is up -- "timed" variables
are accessable from any syntax scope.

Generally, the client parses ircII code in a recursive fashion, where
each new scope results in a call to parse_line().  Each call represents
one logical code unit.  When that logical code unit is completed, then
any variables that are local to it are unuseful and should be removed.

The tough question of local variables is scoping.  In a true dynamic
scope (much like perl 4), a local variable can be accessed by those
scopes that are desceneded from it call-wise, but not syntax-wise:

	alias foo1
	{
		local x
		foo2
	}

	alias foo2
	{
		eval echo $x		; gets the local x from foo1
	}

This is almost always a problem, because it then becomes impossible to
determine whether any specific variable reference will yeild a local
variable in a scope earlier in the stack, or will yeild the intended
global variable.  There needs to be a way to "stop" the depth searching
of variables, at which point the searching will go back to the globals.

It then appears useful to enumerate a list of "atomic scopes", that is,
scopes that are logically independant of any other scope.  An atomic
scope is loosely defined as any sequence of ircII commands whose precise
execution time and ordering is completely arbitrary and unpredictable.
Usually this is any code whose execution is determined by external events.
As an exmample, the following are the current list of atomic scopes:

	ALIAS bodies		(can be called any time)
	ON bodies		(driven by asynchronous events)
	USERHOST -cmd bodies	(driven by asynchronous events)
	WAIT -cmd bodies	(driven by asynchronous events)
	BIND bodies		(driven by asynchronous events)
	TIMER bodies		(driven by asynchronous events)
	QUEUE bodies		(can be called any time)

The ircII code executed in one of these contexts is therefore "atomic", and
any local variables that are declared in a scope below it are not accessable.
Any local variables defined in one of these contexts is accessable to
all contexts below it, up to but not including the next atomic context.

This allows all the other commands that execute ircII code (IF, WHILE, etc)
to have the ability to declare local variables that are local to THEIR
scope and do not have any effect on any global or local variables in contexts
below them, and such variables will be removed at the end of their context.
But they still retain the ability to access and manipulate local variables
that are in contexts above them, up until the enclosing atomic context.


The declaration of a local variable:
------------------------------------
A local variable is declared with the 'local' command (as seen above).
A local variable is accessable throughout its entire lifetime.  You cannot
access a global variable by the same name as a local variable during the
lifetime of the local variable.

