Procedural elements:
====================

definition of terms:
  <block>     : zero or more values to be evaluated.
  <test>      : one value to be evaluated as branch or loop condition.
  <result>    : one value to be evaluated at the end of the execution of
		the form; the value is returned.
  <lvalue>    : local variable/parameter, global variable, or an indexed
		lvalue.
  <expression>: one value to be evaluated.
  <integer>   : an integer constant
  <string>    : a string constant, or 0.
used EBNF operators:
{ }	iteration
[ ]	option
|	alternative

forms:
  ({#', <body> <result>})
  ({#'? { <test> <result> } [ <result> ] })
  ({#'?! { <test> <result> } [ <result> ] })
  ({#'&& { test } })
  ({#'|| { test } })
  ({#'while <test> <result> <body>})	loop while test evaluates non-zero.
  ({#'do <body> <test> <result>})	loop till test evaluates zero.
  ({#'= { <lvalue> <value> } })		assignment
					other assignment operators work too.
  case_label: <integer> | <string> | #'default
  generalized_case_label: case_label | <integer> #'.. <integer>
  case_label_list: case_label | ({ { generalized_case_label } })
  case_delimiter: #', | #'break
  ({#'switch <expression> { case_label_list <result> case_delimiter } })
	Evaluate expression, then evaluate the result form labeled with
	the value equal to the value evaluated from expression.
	If no matching label exists, the value of #'switch is 0.

lisp similars:
  #',		progn
  #'?		cond
  #'&&		and
  #'||		or
  #'while	do 	/* but lisp has more syntactic candy here */
  #'=		setq

A parameter / local variable 'foo' is referenced as 'foo , a global
variable as ({#'foo}) . In lvalue positions (assignment), you need not
enclose global variable closures in arrays.

Call by reference parameters are given with ({#'&, <lvalue>})

Some special efuns:
#'[		indexing
#'[<		indexing from the end
#'negate	unary -

Unbound lambda closures
=======================

These closures are not bound to any object. They are created with the efun
unbound_lambda() . They cannot contain references to global variables, and
all lfun closures are inserted as is, since there is no native object for
this closure.
You can bind and rebind unbound lambda closures to an object with efun
bind_lambda() You need to bind it before it can be called. Ordinary objects
can obly bind to themselves, binding to other objects causes a privilege
violation().
The point is that previous_object for calls done from inside the closure
will reflect the object doing bind_lambda(), and all object / uid based
security will also refer to this object.


