These are the built in IPL commands.  Each is explained below with full
syntax information.  Note that although it is possible to create variables or
functions with reserved word names, the built in IPL reserved words will
always override existing identifiers.  So be careful not to conflict.

  @ (variable declaration)
  ========================
  syntax: @ <type> <ident> [ = <value> ]
      or: @ <type> <ident>, <ident> [ = <value> ], ...

     Use the @ character to create new variables in the current block.
Variables created in parent blocks will exist in all child blocks (loops,
ifs, etc) of that block.  When the block that the variable originated in is
completed, the variable is terminated (memory occupied by it is restored).
IPL defalts to initializing the variables contents to 0's (ascii0/null).

     <type> must be one of the built in IPL variable types.  <ident> is the
identifier name for the variable.  It must not conflict with the name of a
variable that may already exist at that point (the compiler will notify you
when duplicate identifiers are declared).  You can specify many identifiers
in one declaration, and (for most types) an initial value for the variable.
The @ keyword is fairly flexible; here are some examples:

 @ int x                      % declares an integer "x"
 @ byte num = 10              % declares a byte "num" and sets it to 10
 @ str filename = "this.txt"  % declares a string "filename" and inits it
 @ int a, b, c = 10           % creates vars a, b and c, and assigns them 10
 @ file myfile                % initializes file handle "myfile"
 @ bool done = false          % declares boolean variable "done" as false

     You can actually use any expression applicible to that type after the =.
In many programming languages, you can only pre-init variables with constants
or built in operations.  In IPL you can use any available routines in your
var declaration.  Also, IPL allows you to declare variables ANYWHERE in your
module.  You are not restricted to define them all at the top of each block,
although it is usually more organized that way.

  proc (procedure/function declaration)
  =====================================
  syntax: proc <ident> [ : <type> ] {...}
      or: proc <ident> "[" <type>[+] <ident> [, ...] "]" [ : <type> ] {...}

     This command creates a procedure or function in the current IPL module
block.  The major difference between a procedure and a function is that a
function returns a value.  The syntax for the proc reserved word seems
complex, but really its simple:

     The first <ident> is the identifier name for the function.  Next comes
the (optional) procedural parameters.  After the parameter type an identifier
is required for that parameter.  Multiple variables of the same type may be
created by separating the identifiers by commas (",").  Multiple types can be
separated with colons (":").

Examples:

 proc Hello {                    % procedure
   outln["Hello world!"]         % writes:  Hello World!
 }

 proc IsSysOp:bool {             % function
   IsSysOp=userNum=1             % returns true if user is the sysop
 }