reorganizing files

1 files changed, 0 insertions, 2219 deletions

diff --git a/powwow.doc b/powwow.doc
deleted file mode 100644
index 0404328..0000000
--- a/powwow.doc
+++ /dev/null
@@ -1,2219 +0,0 @@
-			     P O W W O W
-
-			doc for version 1.2.21
-		     last modified Oct 09, 2007
-
-INTRODUCTION
-
-	powwow is a client program, which replaces telnet for the lazy
-	mudder who wants some (only some?) extra features. 
-	It is primarily designed for DikuMUDs, but nothing prevents its use
-	for other types of muds.  powwow is based on another client, cancan,
-	and cancan was originally inspired by tintin (yet another client)
-	by Peter Unold (pjunold@daimi.aau.dk), but is entirely re-written.
-	powwow also implements the MUME remote editing protocol, which
-	enables you to edit texts on the mud using your own favourite
-	editor, several texts at once if you have a windowing terminal.
-
-STARTING POWWOW
-
-	Powwow maintains definition files where aliases, actions and
-	mud addresses are saved. Powwow is then called by:
-
-	$ powwow definition-file
-	
-	(the $ above stands for your prompt, do NOT type it)
-
-	If the definition file doesn't exist (as the first time you
-	use powwow) you are asked for a host name and port number.
-	This will then be stored in the file. The file will be updated
-	every time you type '#save' or when powwow terminates.
-	The file is in plain text, so you can edit it if you want.
-	It makes sense to have one file for each mud you play, or for
-	each set of definitions you use in the same mud.
-
-	If the environment variable POWWOWDIR exists, that directory
-	is first searched for definition files and new files are
-	created there rather than in the current directory, unless
-	definition-file contains a slash ("/").
-	
-	The file 'Config.demo' is a demonstrative definition file provided
-	together with powwow to help you building your own configuration.
-	Look at it: there are many useful examples and non-trivial code
-	to fully use powwow.
-
-	You may also start powwow with:
-
-	$ powwow netaddress portnumber
-
-	but nothing will then be saved.
-
-	In alternative you can simply type:
-
-	$ powwow
-
-	and you will enter test-mode: you will be able to use internal commands
-	but you will need to start a session manually
-	(#connect main <address> <port>) if you want to connect to a MUD.
-
-	To solve the problem met in MUME, where you may have to try many
-	different servers to connect to the game, a fourth syntax has been 
-	added:
-
-	$ powwow definition-file netaddress portnumber
-
-	With this syntax powwow reads settings from definition file,
-	but overwrites the old address with the newly specified one.
-
-	Note: If you have several sessions (different invokations)
-	with the same definition file active simultaneously, the
-	settings changed in one session can be overwritten by a change
-	in another session.
-
-QUITTING POWWOW
-
-	At any time, you can type #quit to exit from powwow. Be
-	careful, as #quit brutally closes the connection to the mud,
-	without renting your character. Normally, you want to log out
-	gracefully from the mud before doing that. If you wish to cut
-	your link manually, you can also press the break key on your
-	system twice (usually Control-C or DEL) (You must hit it twice
-	because hitting only once is used to stop command parsing -
-	see the bottom of this file).
-
-POWWOW TEST MODE
-
-	There are various ways to enter powwow test mode:
-
-	1) typing `powwow' from you command shell
-	   (You will have to load your definition file manually if you need it,
-	    using the following command: #load <save-file> )
-
-	2) starting powwow with a definition file that does not contain
-	   a '#host' line or contains a '#host' alone, without any address
-
-	3) starting powwow opening one or more MUD connections,
-	   then closing them all. (You'll need to have #option quit
-	   disabled or powwow will exit when closing the last connection)
-	   
-	Remember that to connect to a MUD from test mode you must use:
-	#connect main <address> <port>
-
-COMMAND CHAINING
-
-	Powwow allows you to type several commands on one line
-	separated by the ; character. If you want to use a semicolon
-	literally, prefix it by a backslash (\). (Backslashes must of
-	course be escaped too if used literally.)
-
-	Examples:
-	> n;get coins;s			rapidly rescue some money
-	> say No beer? \;)		semicolon must be escaped
-
-	In addition, you must also surround every list of commands by braces:
-	'{' and '}'. The only exception (as you can see from the example above)
-	is when you type multiple commands from keyboard: in that case,
-	and only in that, braces are not needed.
-	Also, if you want to use a { or } literally, prefix it with a backslash
-	as you do with semicolons.
-
-	Another use of semicolons is to send a <new-line> character to the MUD
-	you are connected to. Infact powwow sends a <new-line> every time it
-	meets a null command (0 chars) followed by a semicolon.
-
-	Examples:
-	>				press <return> only: send a <new-line>
-	> ;				press ; and then <return>: same effect
-	> ;;				send two <new-line>
-	> ;;;				three <new-line> ...
-
-	Of course multiple <new-line> are considered as multiple commands,
-	so you usually have to surrond them with braces. If directly typed
-	from keyboard, the braces are optional.
-	
-	> {}				do nothing
-	> {;}				send a <new-line>
-	> {;;}				send two <new-line>
-	> {;;;}				and so on...
-	
-	The verbatim mode disables this special meaning of semicolons and
-	braces, and the #quote command lets you switch between verbatim and
-	normal mode.
-
-COMMAND CONTINUATION
-
-	Long lines can be continued by ending each intermediate line with a 
-	backslash (\).  This way long and complicated aliases can be written 
-	a somewhat readable format.  For example:
-
-	#al drau={#send ("get tail "+$hcon);#send ("get fur "+$hcon);#send ("get vial "+$hcon);#send ("get tarragon "+$hcon);put tail kit;put fur kit;put vial kit;put tarragon kit}
-
-	Could be written (somewhat) more legibly as:
-
-	#al drau={\
-		#send ("get tail "+$hcon);\
-		#send ("get fur "+$hcon);\
-		#send ("get vial "+$hcon);\
-		#send ("get tarragon "+$hcon);\
-		put tail kit;\
-		put fur kit;\
-		put vial kit;\
-		put tarragon kit\
-	}
-
-	Note that when powwow saves your aliases (e.g. you leave #file defined)
-	that it will not preserve this formatting, so it is most useful if
-	you use a file that is not saved over on exit.  For example, if
-	you use a single configuration file that calls several smaller 
-	configuration files that are grouped by similar intent, like having
-	an xp counter script, a prompt script, etc.
-
-SPECIAL COMMANDS: ALIASES AND ACTIONS
-
-	Powwow parses all lines beginning with the character '#' as
-	special commands. To send a line that begins with '#' itself, precede
-	it with a backslash. The commands are case-sensitive.
-	Commands can be abbreviated as much as you want.
-	-----------------------------------------------------------
-	Alias definition
-	#alias [name[=[command]]]
-
-	Aliases are abbreviations for longer, frequently used commands.
-	As all powwow commands, they are only recognized at the beginning
-	of a line or directly after a semicolon, an open or closed brace.
-	When an alias is used, the first word following the alias name
-	is placed in the variable $1, the second in $2, etc... up to $9.
-	also, the whole string following alias name is placed in $0.
-
-	Then, before executing <command>, every $n in <command> is replaced 
-	by its contents.
-	
-	Example:
-	#alias summ=cast 'summon' $0	(then "summ thor" is replaced by
-					 "cast 'summon' thor")
-	#alias cs=cast '$1' $2		("cs summon thor" is expanded to
-					 "cast 'summon' thor")
-	#alias summ			(lets you edit the definition of summ)
-	#alias summ=			(removes the alias summ)
-	#alias				(display all defined aliases)
-	#alias ws={wake;stand}		(note that you must use braces)
-
-	As noted above, aliases are saved automatically if you started powwow
-	with a file name as argument.
-	Aliases can contain other aliases, and an alias can also contain itself
-	(be careful, or powwow will enter a long - but not infinite - loop)
-	Aliases are not expanded in verbatim mode.
-
-	Where aliases contain other aliases, one or more '\' can be prepended
-	to $n to delay text substition or to use the symbol $n literally.
-
-	Example:
-	#alias ac=#alias $1=cast '$2' \$0
-		(then "ac sm summon" will give you a new alias
-		 "#alias sm=cast 'summon' $0")
-
-	#alias \==score
-		(this defines = as an alias for 'score', Note that you must
-		 escape the first = to force powwow to consider it literally)
-
-	#alias \`=#history $0
-		(this defines \ as an alias for '#history'. Note that you must
-		 use ` to escape the \ . Just doing \= would escape the = )
-
-	Aliases starting with `#' are allowed and do work,
-	but cannot override any special command.
-	-----------------------------------------------------------
-	Automatic command execution triggered on output
-	#action [[<|=|>|%][+|-]label] [{pattern | (expression)}=[command]]
-
-	When 'pattern' is found in a line from the remote host, the
-	'command' is automatically executed. If the pattern contains $n,
-	powwow matches one word of the remote line and puts it in the
-	variable $n. If the pattern contains &n, powwow matches a string
-	(possibly more than one word) of the shortest possible length
-	from the remote line and puts it in the variable $n.
-
-	As in aliases, $n can be from $1 to $9. NOTE: $0 is a variable as well,
-	but #action automatically places in it the whole line from remote host.
-	As well, &n can be from &1 to &9.
-
-	Warning: powwow does NOT print on screen lines from MUD that are
-	intercepted with an #action. So if you want to print them, you
-	must explicitly use a #print or set the #option +autoprint
-	(the help on #print and #option is below in this text)
-	If you want to intercept a prompt, use #prompt instead of #action.
-	(the help on #prompt is near the end of this file)
-
-	If the first character of the pattern is ^ (caret), the match
-	will only be possible at the beginning of a line.
-	The match is case-sensitive.
-	If 'label' is specified, the action is labeled; otherwise it is
-	numbered.
-	
-	If an <expression surrounded by parentheses> is used insted of pattern,
-	powwow evaluates the expression with the inline calculator (see below)
-	and then uses the result as pattern.
-
-	Examples:
-	#action ^You are hungry=eat bread
-	#action ^You are hungry=	   		(removes the action)
-	#action ^$1 hugs you={#print;kiss $1}
-	#action ^$1 says &2=say $1 said $2      (note you must use $, not &
-						 after the =)
-	#action Jehova={#print;say Who said that? Stone him!}
-
-	Labeled actions:
-	> means define, < means delete, = is edit, + is turn on, - is turn off.
-	Also, >- means define and turn off, while >+ means define and turn on
-	( > alone is the same as >+ )
-
-	#action >fount ^There is a fountain here={#print;drink water}
-							(named action)
-	#action -fount					(turns off action)
-	#action +fount					(turns it back on)
-	#action =fount					(lets you edit it)
-	#action <fount					(removes action)
-
-	#action >-loot is dead! R.I.P.={#print;get all from corpse}
-					(define and turn off the action)
-
-	#action >joke ("^$1 says '&2;)'")= wink $1
-				(you must either use this syntax or escape the
-				 ; to force it to be considered literally)
-
-	#action >argh ^$1 tells you 'hello \`=tell $1 I heard you
-				(as in #alias, \ must be followed by ` when you
-				 need the \ to be followed by a special char
-				 and you do not want this char to be escaped)
-
-	If you have compiled powwow with -DUSE_REGEXP and use % instead of >
-	you define an action that uses an Extended POSIX regexp to match
-	instead of the standard matcher.
-
-	#action %first ^([[:alpha:]]+) ([[:digit:]]+)=#print $2 counted $3.
-							(matches abc 123)
-
-	Note that if the pattern starts with '(', it is evaluated, which means
-	that a regexp that starts with '(' has either to be surrounded by
-	("...") or to be prepended by a backslash.
-	Also note that powwow requires parentheses to be balanced:
-	for example, \(.+|) would be a valid regexp pattern as the backslash
-	gets removed by the unescaping, but powwow will choke on it
-	as the first parenthesis is escaped while the second is not.
-
-	#action %second ("(..+)-\\1")=#print Double $1
-						(matches xyz-xyz)
-	#action %third \(..+\)-\\1=#print Double $1
-						(same as above)
-	For regexp actions, $0 = the line, $1 = the whole match and $2...
-	contain the submatches.
-
-	Actions and aliases can run other powwow commands, including
-	#action and #alias.
-	Example:
-	#alias calc=#! echo '$0' | bc -l
-	#alias hungryon=#action ^You are hungry=eat bread
-
-	As with aliases, additional \'s can be prepended to $n to
-	delay text substitution in actions.
-	Example:
-	#action >reply ^$1 tells you={#print; #alias reply=tell $1 \$0}
-	-----------------------------------------------------------
-
-ACTION GROUPS
-
-	Groups allow related triggers to be enabled and disabled together
-	using a single command, instead of toggling them all on or off 
-	individually.  To put actions in to a group specify the group name
-	after an '@' when the action is defined.  For example:
-
-	#action >+auto-ride@non-pk ZBLAM! A &1 doesn't want you={#print;stand;ride}
-
-	Would create the action auto-ride in the non-pk group.  Then if you
-	wanted to toggle off all non-pk actions, you could do it using:
-
-	#group non-pk off
-
-	And then later to turn them back on, use:
-
-	#group non-pk on
-
-MISSING: #PROMPT
-
-	There is another special command quite similar to #action:
-	#prompt [[<|=|>|%][+|-]label] [{pattern | (expression)}=[command]]
-
-	You will need to use it only if you want to mess with the prompt
-	that your MUD sends, which is often not needed. Also, to use it
-	you need to understand exactly how powwow recognizes prompts,
-	so the description is considered an advanced topic and is placed
-	near the end of this file, in the "ADVANCED TOPIC: #PROMPT" section.
-
-MISSING: SUBSTITUTION AND UNESCAPING
-
-	Also, only intuitive definitions of substitution, delayed substition
-	and escaping/unescaping have been given so far. If you want the real,
-	rigorous thing, read the "ADVANCED TOPIC: SUBSTITUTIONS AND UNESCAPING"
-	section near the end of this file. That section also explains
-	`just in time' substitution, not yet introduced.
-	-----------------------------------------------------------
-	
-SPECIAL COMMANDS: ALL OTHERS
-	
-	This is the rest of #commands recognized by powwow.
-	-----------------------------------------------------------
-	Toggle verbatim mode
-	#quote [on | off]
-
-	In verbatim mode, no alias expansion takes place and
-	semicolons, escapes, braces and `  are sent as typed,
-	unless the command line begins with a #, so you can still issue
-	powwow - specific commands.
-	This is useful if you want to paste a text from an editor into
-	a powwow session.
-	Type #quote to turn on the verbatim mode, and type #quote again
-	to turn it off.
-	-----------------------------------------------------------
-	Show/execute commands in history
-	#history [number]
-
-	#history alone shows you the last commands in history, up to the number
-		of lines in your screen.
-	#history -n shows the last n commands in history, and
-	#history n  executes the n-th command of the history.
-
-	Recursive #history commands (i.e. an #history <n> calling itself or
-	another #history <n>) are allowed only up to levels of 128 recursions.
-	
-	Example:
-	
-	#history 1				(repeat last command)
-	-----------------------------------------------------------
-	Add a text or expression to word completion list (not to history)
-	#add {text | (expression)}
-
-	#add puts the text or result of expression (calculator is used to
-	evaluate the expression) in the word completion list.
-	Useful if used together with #action. 
-	Example:
-
-	#action >reply ^$1 tells you={#print;#add $1}
-			(from now on, you can use TAB to complete that name)
-	-----------------------------------------------------------
-	Put a text or expression into history (and to word completion list)
-	#put {text | (expression)}
-
-	#put puts the text or result of expression (uses calculator) in the
-	history, so that you can use cursor-up key to recall the text as if
-	typed from keyboard.
-	Also, you can execute the text using the #history command.
-	Example:
-
-	#action >safeflee ^You flee head over heels.=
-		{#print;#put #print You have already fled away!}
-
-	(If you type 'flee' from keyboard, you can keep trying to flee using
-	 cursor-up (which gets the last command in history) and <RETURN> key.
-	 When you finally manage to flee, the message above is put in history,
-	 so that further attempts to flee do not lead you again in danger)
-	-----------------------------------------------------------
-	Bind keys to enter commands
-	#bind [edit | name [sequence][=[command]]]
-
-	You can bind most function keys and control keys to enter a command
-	for you when the key is pressed. Also, you can redefine a key already
-	used for an editing function (such as the arrow keys).
-	'name' is the label of the key you want to define; you can just use
-	what is written upon it. When defining a new key binding, you will
-	be asked to press it so powwow can record the control sequence
-	your terminal sends.
-	If you want, you can specify the control sequence directly in the #bind
-	command instead of having to press the key on your keyboard.
-
-	Examples:
-
-	#bind				(lists all user key bindings)
-	#bind edit			(lists all line editing keys)
-	#bind f1=recite scroll		(you'll have to press f1 then)
-	#bind f1=cast 'sanctuary'	(change existing definition)
-	#bind f1			(lets you edit the definition)
-	#bind f1=			(removes the key)
-	#bind f1 [[A=cast 'heal'	(also tell powwow that f1 on your
-					 keyboard sends ESC [ [ A, so you
-					 do not have to press it)
-
-	NOTE: if there is already something on your input line, powwow
-	does not ruin it when you press f1 (or any other #bind), but executes
-	the command you want and then shows you again the input line.
-
-	#bind f5=&prev-line	(&prev-line is one of the reserved commands for
-				 line-editing functions, see bottom
-				 of this file)
-	#bind Up=u		(Up is an editing key, but can be redefined)
-
-	By default, the vt100 numeric keypad is partially used to walk around
-	with:
-		Key	string sent
-		2	s
-		3	d
-		4	w
-		5	exits
-		6	e
-		7	look
-		8	n
-		9	u
-
-	The reserved names that powwow identifies as line-editing functions
-	are at the end of this file, together with the default keys used for
-	them.
-
-	Remember that ALL keys can be redefined...
-	-----------------------------------------------------------
-	Change the keyboard sequence associated to an existing key binding
-	#rebind name [sequence]
-	
-	If you just want to change the control sequence of a binding, but not
-	its name or its effect, you can just tell powwow to 'rebind' it.
-	If #rebind is invoked with only the name of a binding, you are asked
-	to press the key you want to rebind.
-	Of course, you will not be asked to press the key if you specify
-	its control codes in the #rebind command.
-	Examples:
-	
-	#rebind f1 ^[OP		(tell powwow that your f1 key sends ESC O P
-				 and not ESC [ [ A)
-	#rebind f1		(you are asked to press again f1, useful if you
-				 changed terminal in the meanwhile)
-        -----------------------------------------------------------
-	Change the keyboard sequence of all existing key bindings
-	#rebindall
-	#rebindALL
-
-	#rebindall runs #rebind on most key bindings (skips trivial ones like
-	^A, ^B, etc.), asking you to press each corresponding key.
-
-	#rebindALL does the same, but for really every key binding.
-	-----------------------------------------------------------
-	Execute a key as if pressed on keyboard
-	#key name
-
-	If 'name' is the label of one of the key defined with #bind, 
-	(see above) #key executes the corresponding command.
-
-	Example:
-	If you have already typed
-	  #bind f1=cast 'heal'
-
-	At any time, then, you can either:
-	- Press your f1 key on you keyboard
-	- Execute the command "#key f1"
-	and powwow will execute the command "cast 'heal'" for you.
-	
-	Using #key, for example, can be useful from inside an 
-	#alias or #action, since powwow cannot press f1 for you.
-
-	Since 1.1.5, powwow allows #key also for editing functions.
-	If you have already
-	  #bind Up=&prev-line
-	and you execute
-	  #key Up
-	powwow will do what you expect: step to the previous line in history.
-	
-	Warning: powwow does not distinguish at all between a real key pressed
-	on the keyboard and one faked with #key, so commands executed with #key
-	will also be written in the #record file.
-
-	-----------------------------------------------------------
-	Execute an editing function as if pressed on keyboard
-	#keyedit function
-
-	If 'function' is the name of one of the reserved commands
-	for line-editing functions, #keyedit function will run it.
-	
-	For example, if you already have
-	  #bind Up=&prev-line
-	the following are all equivalent:
-	  * pressing the key Up on your keyboard
-	  * executing #key Up
-	  * executing #keyedit &prev-line
-
-	Anyway, if you type #key or #keyedit directly from the keyboard
-	the effect is slightly different, as you have to press ENTER
-	to run them and the function &enter-line (which is executed by ENTER)
-	has a few side effects.
-	-----------------------------------------------------------
-	Clear aliases, actions or what you specify
-	#reset {all | name of a list}
-
-	Argument:	Effect:
-	all		clear everything (apply all lines below)
-	alias		clear all aliases
-	action		clear all actions
-	bind		clear all key bindings and restart with default
-			settings. Note that also editing keys are resetted
-			to default function.
-	at		clear all delayed commands
-	in		(same thing)
-	mark		clear all markers
-	prompt		clear all prompts
-	var		clear all variables
-	-----------------------------------------------------------
-	Mark certain output
-	#mark [pattern[=[attribute]]]
-
-	This command highlights a part of a line in your output in the way you
-	choose (if your terminal supports it).
-	See the section "ATTRIBUTES: COLORS AND OTHER HILIGHTINGS"
-	about the syntax of attributes.
-
-	Wildcards are allowed in the pattern, and syntax is very similar to
-	#action: $ matches a single word, & matches any string.
-
-	Examples:
-	#mark Sizzler=bold		(mark `Sizzler' in bold)
-	#mark Sizzler			(lets you edit the above definition)
-	#mark Sizzler=			(Sizzler is no longer put in bold)
-	#mark				(lists all markers)
-	#mark {&}=inverse		(mark in reverse any string in { }
-					 note that also the { } are highlited)
-	#mark ^You=yellow		(mark `You' in yellow only if it appears
-					 at the beginning of a line)
-	#mark \^=on blue		(mark a literal ^ )
-	-----------------------------------------------------------
-	#module [module name]
-
-	This loads a shared library module by name, if supported by your system.  The
-	name of the module should be included in the documentation that came with the
-	powwow extension, for example to load the perl module you would use:
-
-	#module perl
-
-	Which gives you the perl command that can be used like:
-
-	#perl powwow::exec( "say it is " . scalar(localtime()) )
-
-	The commands added and their syntax varies depending on the module.
-	-----------------------------------------------------------
-	Set/show priority for new actions/marks
-	#nice [{number | (expression)} [command]]
-
-	When #nice is 0 (default) powwow puts new actions at the bottom of the
-	action list (and same thing for marks). If you want to put new
-	actions/marks in another point of the list, just set #nice to the
-	corresponding value:
-
-	If you specify a command after 'number', the new #nice value is used
-	only for that command, then the old value is restored.
-
-	Examples:
-
-	#nice 12 	(tells powwow to put new actions/marks in the 12th
-			(place of the list)
-
-	#nice 4 #mark Grizzly=red on blue  (put the mark in the 4th place of
-					    the list)
-
-	Note that #nice works only for new actions/marks: if an action/mark
-	is already defined, you cannot change its place in the list.
-	-----------------------------------------------------------
-	Input highlighting
-	#hilite [attribute]
-
-	This sets the attribute of your entered text to the given attribute.
-	Just #hilite turns it off.
-	See "ATTRIBUTES: COLORS AND OTHER HILIGHTINGS" below for more syntax.
-	-----------------------------------------------------------
-	Set standard colours
-	#color [attrib]
-
-	(This command exists only if BUG_TELNET is defined, to cope with
-	 deficiencies of NCSA telnet 2.2)
-	Set your standard foreground and background to the colours you specify.
-	#color			returns to the default colors for your screen
-	-----------------------------------------------------------
-	Capture output to file	
-	#capture [[>]filename]
-
-	This captures all output from the main MUD connection and your typed
-	commands to a local disk file. To close the file and end the
-	capturing, type #capture without argument.
-	If the filename starts with a '>', new text will be appended to the 
-	end of the file instead of overwriting it.
-	You can only capture output to one file at a time.
-	Example:
-	> #capture message
-	> look at board
-	> #capture
-	
-	It is possible to capture in the #capture file even text that you have
-	_already_ received: see #setvar buffer.
-	-----------------------------------------------------------
-	Record typed commands to file	
-	#record [filename]
-
-	This records all text typed from keyboard to a local disk file.
-	(output from remote host is not recorded)
-	To close the file and end the recording, type #record without argument.
-	You can only record typed text to one file at a time, but #capture and
-	#record can be active at the same time on different files.
-	Example:
-	> #record walk-home
-	> n;e;e;u;n;w;s
-	> open door
-	> s
-	> close door
-	> sleep
-	> #record
-	-----------------------------------------------------------
-	Capture output to file, with timestamps
-	#movie [filename]
-
-	This is similar to #capture, but adds timestamps to each line
-	received from the main MUD connection or typed from the keyboard,
-	to allow replay at correct speed.
-	The program `powwow-movieplay' for replay is included with powwow sources.
-	Usage: `powwow-movieplay <filename>'
-	To convert a movie to plain ASCII, the program `powwow-movie2ascii'
-	is included too.
-	Usage: `powwow-movie2ascii <infile> <outfile>'.
-
-	It is possible to capture in the #movie file even text that you have
-	_already_ received: see #setvar buffer.
-	-----------------------------------------------------------
-	Execute a shell command
-	#! command
-
-	Executes a command using /bin/sh. Powwow waits until your shell
-	finishes, but you can put jobs in the background with & as usual.
-	Example:
-	> #! who | sort | less
-	> #! nethack
-	> #! xbiff &
-
-	Note that semicolons, escapes and braces need to be escaped if they
-	are to be sent to the shell.
-	If your shell has job control, you can also suspend powwow
-	with ^Z as usual.
-	-----------------------------------------------------------
-	Put a string in the edit buffer automatically
-	#prefix [string]
-
-	Each new line you type will automatically begin with the prefix string.
-	You can of course edit or delete the inserted string as usual. To
-	remove the prefix, just issue a #prefix command without arguments.
-	This is handy when you are talking to someone, for example.
-	> #prefix tell arthur 
-	-----------------------------------------------------------
-	Help
-	#help [keys | math | command]
-
-	Shows a list of powwow's commands. 
-	'#help keys' shows the editing keys.
-	'#help math' show help on inline calculator.
-	You can also have help on specific commands, using for example
-	'#help alias' or in general '#help <command-name>'.
-	A help file is needed and provided for this last feature of #help,
-	and powwow will look for the file "powwow_help" in the directory
-	specified by the environment variable POWWOWHELP. If this variable
-	does not exist, powwow looks in current directory.	
-	-----------------------------------------------------------
-	Command repetition
-	#n command
-
-	This repeats the command n times. Example:
-	> #5 buy bread				(buy five breads)
-
-
-	Alternatively, you can use this syntax to repeat a command n times:
-	#do (expr) command
-
-	In this case, powwow evaluates the expression, and uses the result
-	as counter.
-	Example:
-	> #do (3*8) north			(go north 24 times)
-	-----------------------------------------------------------
-	Iterate a command
-	#while (expression) command
-
-	This syntax repeats a command while expression (evaluated with
-	calculator) keeps true. (see below for help about calculator)
-	As with #alias and #action, the $n and @n in command are
-	replaced by their values. (Even if you can, using @n after the =
-	in #action and #alias is useless, because you have no way to
-	assign them a non-zero value. This is the reason why we did not talk
-	about them in the #alias and #action section)
-
-	Example:
-
-	#while (@0<13) {read @0;#(\@0++)}	  read messages 0-12
-	As you can see, the last @0 is escaped to avoid it to be
-	substituted with its value. (We want to increase the variable!)
-	-----------------------------------------------------------
-	Iterate a command
-	#for ([init];check;[loop]) command
-
-	Directly copied from C language, this command evaluates 'init'
-	with calculator (if specified), then repeats the following cycle:
-		1) evaluate 'check', if result is 0 (false) stop repetition
-		2) execute 'command'
-		3) evaluate 'loop' (if specified)
-		4) restart from 1)
-
-	As with #while, #for performs the parameter substitution in 'command',
-	so the only significative difference between #while and #for is that
-	#for allows you to execute an initialization before the repeat cycle.
-
-	Example:
-
-	#for (@1=32; @1<=47; @1++) read @0	(read messages 32-47)
-	-----------------------------------------------------------
-	Branch execution command
-	#if (expression) command1 [; #else command2]
-
-	Evaluate the expression: if result is 'true' execute command1,
-	otherwise (if there is an #else) execute command2.
-	If expression is false and there is no #else, execute nothing.
-	remember that you must use braces {} if command1 or command2
-	contain more than one instruction.
-
-	Note that nested #if-#else are allowed, and that #if-#else itself
-	is not a multiple command.
-
-	WARNING: using an alias for #if is very dangerous and will cause
-	powwow to make confusion when the full #if-#else syntax is used.
-	-----------------------------------------------------------
-	Automapping control
-	#map [-[number] | walksequence]
-
-	With no argument, "#map" shows the map of the directions you
-	travelled up to now.  "#map -" clears the last number of steps
-	from the map.
-
-	Example:
-	#map		(displays "#current map: e3su" after above walk)
-	#map -1		(leaves the map as "esss")
-	#map -		(clears the whole map and starts fresh)
-	#map nsssue	(add the list of directions to map)
-	-----------------------------------------------------------
-	Retrace steps
-	#retrace [number]
-
-	This command walks you in the reverse direction of the last
-	number of steps.  If number is 0 or left blank, you walk all
-	the way back to where automapping started.
-	-----------------------------------------------------------
-	Explicitly execute a speedwalk
-	#speedwalk [walksequence]
-
-    This command can be used to execute a speedwalk sequence even
-    if you have the speedwalk option disabled.  This is useful if you
-    do not like to have typos evaluated as speedwalk commands but still
-    want to be able to easily execute a speedwalk.
-	-----------------------------------------------------------
-	Connect initialization string
-	#init [=[command]]
-
-	This command sets up the initialization string to send to
-	the host on establishing a connection.
-
-	Example:
-	#init				(shows the string)
-	#init ={#identify;#speedwalk}	(sets the string)
-	#init =				(clears the whole string)
-	-----------------------------------------------------------
-	Identify as an editing client
-	#identify [startedit [endedit]]
-
-	This command sends an identification string to the server, to
-	indicate that the client supports editing functions. It is
-	best attached to an action trigged by a string in the login
-	screen, but can also be entered by hand.
-	This command must be issued for the cooperative editing to work
-	on servers that support it (currently only MUME).
-	The startedit/endedit parameters are commands issued when an editing
-	session starts/ends (for changing your title, emoting etc).
-
-	Example:
-
-	#action >mume ***  MUME=#identify
-	#identify foo bar
-	(where foo and bar are aliases that do something useful)
-	-----------------------------------------------------------
-	Identify as a IAC GA compliant client
-	#request prompt
-
-	This command sends an identification string to the server, to
-	indicate that the client supports (and wants) the special sequence
-	IAC GA at the end of each prompt. This helps the client
-	to automatically detect the prompt, and can be used as alternative
-	to #prompt / #isprompt if all you want with the prompt is detecting
-	it (and not altering it)
-
-	BIG WARNING:
-		this is experimental and not tested!
-
-	Example:
-
-	#action >mume ***  MUME={#print;#identify;#request prompt}
-	#request prompt
-	-----------------------------------------------------------
-	List all editing sessions
-	#edit
-
-	This command shows your active editing sessions, with a brief
-	description and their number.
-	-----------------------------------------------------------
-	Cancel an editing session
-	#cancel [number]
-
-	Without an argument, all editing sessions are cancelled;
-	otherwise, only the given session is cancelled. The corresponding
-	editor processes are brutally killed.
-	-----------------------------------------------------------
-	List/turn various options on/off
-	#option [[+|-|=]option-name]
-	
-	Currently available option names are:
-		exit, history, wrap, compact, debug, echo, info, keyecho,
-		speedwalk, wrap, autoprint, buffer, reprint, sendsize,
-		autoclear
-
-	#option +name		turns an option on
-	#option -name		turns it off
-	#option  name		toggles it
-	#option =name		reports its status
-	
-	-------------
-	#option exit
-	
-	If the `exit' option is on, powwow automatically quits when the last
-	connection is closed. Otherwise, to quit powwow you need to manually
-	type `#quit'
-	-------------
-	#option history
-	
-	With `history' option on, powwow writes into your savefile also
-	all your commands in history
-	-------------
-	#option words
-	
-	With `words' option on, powwow writes into your savefile also
-	your word completion list
-	-------------
-	#option compact
-
-	Normally, powwow does not touch the prompts on screen while you play.
-	In `compact' mode, instead, lines containing only a prompt are deleted
-	when further messages arrive from the remote host.
-
-	WARNING: this command works correctly only if you have #prompts which
-		 correctly run #isprompt. Otherwise it may occasionally erase
-		 some lines from the screen.
-	-------------
-	#option debug
-
-	Normally, powwow does not print on screen the command lines it
-	executes. When `debug' is on, every line executed by powwow is also
-	echoed on screen, so that you can check if your code works correctly
-	(warning: this prints LOTS of lines on your screen)
-	-------------
-	#option echo
-
-	Normally, powwow echoes on your screen each command sent to remote
-	host but not directly typed (example: aliases and actions sending text
-	to the MUD). When `echo' is off, such commands are still sent to host,
-	but not echoed on screen.
-	-------------
-	#option info
-
-	Normally, powwow prints on screen some messages each time you
-	define/edit/delete an #alias, #action, #bind and similar.
-	When `info' is off, those messages are not typed at all.
-	(But errors are still printed on screen)
-	-------------
-	#option keyecho
-
-	Normally, powwow echoes on your screen the commands sent to remote host
-	when you hit a key associated to a #bind. When `keyecho' is off, such
-	commands are still sent to host, but not echoed on screen.
-	-------------
-	#option speedwalk
-
-	With `speedwalk' on, a command consisting of only lowercase
-	n, e, s, w, u, d and numeric digits is considered to be a
-	walk sequence.  The numeric digits specify the number of
-	times to repeat the direction immediately following.
-
-	Example:
-	esssu		(walk east, 3 south, up)
-	e3su		(same as above)
-	-------------
-	#option wrap
-
-	Normally, powwow wraps words that would have been cut by the right
-	margin to the next line. This command lets you turn it off and on.
-	-------------
-	#option autoprint
-
-	If `autoprint' is on, powwow prints lines matched by an #action
-	even without an explicit #print.	
-	-------------
-	#option sendsize
-
-	Usually powwow does not send the window size to the MUD unless asked.
-	If you want to send the window size automatically upon connecting,
-	you may enable this option.
-	-------------
-	#option autoclear
-	
-	Powwow normally erases the input line before executing commands
-	from spawned programs, but that is slow and causes flicker.
-	If autoclear is disabled flicker reduces to minimum,
-	on the other hand spawned programs must then execute #clear
-	before sending anything to screen.
-	-------------
-	#option reprint
-
-	If `reprint' is on (off by default), powwow prints again commands
-	sent to the mud but not yet executed.
-	WARNING: it works only if you use #prompts which correctly run
-		 #isprompt.
-
-	++++ example: ++++
-	*>look
-	south
-	down
-	
-	The High Path
-
-	*>Path Climbing a Hill
-	
-	*>
-	Alas, you cannot go that way.
-	
-	*>
-	++++ becomes: ++++
-	*>look
-	south
-	down
-	
-	The High Path
-	
-	*>(south)
-	Path Climbing a Hill
-	
-	*>(down)
-	Alas, you cannot go that way.
-	
-	*>
-	-----------------------------------------------------------
-	Show current version
-	#ver
-
-	Displays the current version, some compile options and (if
-	your compiler supports it) when powwow was compiled.
-	-----------------------------------------------------------
-	Multiple connections handling commands
-	#connect [session-id [initstr] [host port]]
-				connect a new session / list sessions
-	#snoop session-id	toggle output display for session
-	#zap session-id		disconnect a session
-	##<session-id>		set <session-id> as default session
-	##<session-id> command	execute command on <session-id> session
-
-	No docs here. If multiplaying is allowed on you MUD (and many
-	do NOT allow) you can experiment a little to find how they work.
-	Or you can open two connections to two different MUDs :)
-	-----------------------------------------------------------
-	Spawn an external program
-	#spawn session-id command
-	
-	Creates a new session, connected to a shell command instead of a MUD.
-	Writing to ##<session-id> sends data to the command's standard input,
-	while the command's standard output is executed as if typed
-	from keyboard. Useful if you are a programmer and you want to create
-	very complex filters or robots, for which #actions are too limited.
-	Command's standard output *MUST* terminate with a newline ('\n') in
-	order for powwow to execute it.
-	You can send multiple commands at once terminating each of them
-	by either a semi-colon ';' or a newline '\n', except for the last one
-	which (I repeat) *MUST* terminate with a newline.
-	
-	You can close these sessions with #zap and list them with #connect
-	as usual.
-	
-	Depending on how lazy you are, you can choose two different ways
-	to have spawned programs print to screen:
-	
-	The first is automatic, but slow: with `#option +autoclear'
-	powwow clears the input line before executing every line received
-	from the program. This is of course slow and causes flickering.
-	
-	The second is more complex, but faster and reduces flickering to the
-	minimum: set `#option -autoclear' from the beginning, then have
-	the program execute `#clear' before printing.
-	-----------------------------------------------------------
-	Exit from powwow
-	#quit
-
-	Very little to say here. Just remember that #quit brutally
-	closes all mud connections that are still open, without
-	renting your characters. Quite likely, you want to rent them all
-	before quitting.
-	-----------------------------------------------------------
-	Set definition-file and save settings to it.
-	#save [definition-file]
-
-	Useful after you write large chunks of code.
-	Remember anyway that powwow automatically saves the settings
-	before exiting.
-	
-	#save actually writes settings to a temporary file and overwrites
-	the definition file only if write succeeds. This is to avoid wiping out
-	definition file in case of `disk full' or other errors.
-	-----------------------------------------------------------
-	Set definition-file and load settings from it.
-	#load [definition-file]
-
-	Useful if you want to undo the changes in your settings.
-	
-	NOTE: current settings are completely erased before actually loading
-	from file. In case of errors, powwow reloads the default editing keys.
-
-	If you just want to add the contents of a file to your current settings
-	use #exe <filename instead of #load.
-	-----------------------------------------------------------
-	Set/show/clear definition-file name
-	#file [=[definition-file]]
-
-	As default, the definition-file is the one loaded when you start
-	powwow. Remember that powwow automatically saves your settings to it
-	before exiting. If you want to disable this autosave, use #file =
-	-----------------------------------------------------------
-	Various commands:
-	#net		show amount of data transmitted to and received from
-			the remote host.
-	#cpu		show the CPU time used by powwow.
-			(if powwow does not find the symbol CLOCKS_PER_SEC
-			 defined at compile time, the result may not be in
-			 seconds...)
-	#time		show current time/date. Useful if you want to use #at.
-
-	#beep		ring your terminal's bell (like #print (*7))
-	-----------------------------------------------------------
-	List/delete/define/edit delayed commands
-	#at [label [(time-expression) [command]]]
-	or
-	#in [label [(delay in millisec.) [command]]]
-
-	If you want to tell powwow to execute the command 'kill wolf'
-	2 seconds after you type it, use this command:
-	#in attack (2000) kill wolf
-	Let's explain the command:
-	'attack' is a label, exactly as in #actions, and is used only to have
-	a quick reference to the delayed command; 
-	(2000) means wait 2000 millisec., i.e. 2 seconds;
-	'kill wolf' simply executes kill wolf, as if typed from keyboard.
-
-	Of course, you can use an expression (as complex as you like)
-	instead of the number in parentheses,
-	and the command can also be an alias, internal command or even
-	another #at or #in. (of course you can use multiple commands by
-	placing them in { } )
-
-	If you do not specify the command, powwow assumes the label is already
-	defined, and changes its delay. 
-	A delay less than zero means the delayed label is disabled,
-	but still in powwow's memory, similar to what happems when you
-	turn off an #action.
-	A delay of zero deletes the delayed label.
-
-	If you specify only a label, powwow lists it.
-	If you specify nothing, all delayed labels are listed.
-
-	The #at command is nearly equal to #in, but assumes the expression
-	in ( ) is a time. For example (114520) means 11:45:20 , 
-	and ("114520") is the same.
-	After evaluating the time, powwow converts it into a delay,
-	and places the delayed label in the same list of #in.
-	NOTE: it is not possible to delete a delayed label using #at,
-	since (0) means midnight.
-	One more thing: it is not possible do define disabled labels using #at,
-	because a time < 0 is an error, and a time < current-time is assumed
-	to be refering to the following day.
-	
-	Last note: after executing a delayed command, powwow does not delete
-	it, but simply disables it.
-	-----------------------------------------------------------
-	Disable all delayed commands
-	#stop
-
-	All active delayed commands are set to 'disabled', but are not deleted
-	from memory. Useful to stop infinite loops due to self-reactivating
-	delayed commands.
-	-----------------------------------------------------------
-	Set save file options
-	#option [none]|[words][history]
-	
-	Controls wether command history and completion words shall be saved
-	in the save file.
-
-	Without arguments, #option displays the current settings.
-	To turn off both words and history, use #option none; otherwise
-	use #option followed by words and/or history.
-
-	-----------------------------------------------------------
-	Evaluate expression with calculator, and trash result.
-	# (expression)	  or	#(expression)
-
-	-----------------------------------------------------------
-	Print a text or result of an expression on screen.
-	(does NOT send it to the MUD)
-	#print [< | !][text | (expression)]
-
-	If a string is specified, powwow simply prints it on screen.
-	If an expression is specified, powwow uses the inline calculator
-	to evaluate it, and then prints the result.
-
-	If a #print without arguments is found, powwow prints the value
-	of the variable $0 (this is a special feature of #print, and is not
-	present in #exe, #send, #emulate or #var).
-	This is usually used to print a line from remote host that was
-	intercepted by an #action, in fact #action places the whole line in $0
-
-	If < precedes the text or expression, #print assumes text (or result
-	of expression) to be name of a file, and displays the contents of
-	that file.
-
-	Instead if ! precedes the text or expression, #print assumes text (or
-	result of expression) to be a Bourne shell command, whose output is
-	displayed.
-
-	Example:
-
-	#action >disint ^&1 disintegrates &2=#print $1 DISINTEGRATES $2
-					put the text in upper case
-	#action >disint ^&1 disintegrates &2=#print ($(1)+" DISINTEGRATES "+$(2))
-					same thing, but using calculator
-
-	#print <mytext			display a text on screen
-	#print !("more mytext")		same thing, but uses 'more'
-					as text viewer and alternate syntax
-	#print (@-7)			print value of variable on screen
-	#print <($2)			display the contents of file whose
-					name is in variable $2
-
-	Further feature:
-
-	If < is specified, and you use an expression after it, you can also
-	specify starting and ending line of the file that you want to use,
-	in this way:
-
-	#print <(string-expr;[start];[end])
-
-	Note: if you use a plain text as file name (like in #print <myfile )
-	you cannot specify starting and ending line.
-
-	If starting line is not specified, powwow begins from the first line,
-	if ending line is not specified, powwow stops at the end of the file:
-
-	#print <("myfile";3;42)		print lines from 3 to 42 of myfile
-
-	#print <("myfile";;57)		print lines from start of file to 57
-
-	#print <("myfile";;)		print whole file
-
-	Note that you can use expressions instead of filename, starting line
-	and ending line:
-
-	#print <($5;4;3+@0)		print file whose name is in variable $5
-					from line 4 to line 3+@0
-
-	Of course, you can still use the whole file in the old way:
-	#print <("myfile")	or 	#print <myfile
-
-
-	Further feature (another):
-
-	The starting and ending line can be specified ALSO when you use a !
-	before an expression:
-
-	#print !(string-expr;[start];[end])
-
-	In this case, powwow executes the Bourne shell command contained in
-	the string, and prints ONLY lines from <start> to <end> of its output.
-
-	Also here, you can use expressions instead of Bourne shell command,
-	start and end, and powwow still begins from first line if <start>
-	is not specified and/or stops at the end of the output if <end>
-	is not specified.
-
-	Both these special features are supported ALSO in #send, #exe,
-	#emulate and #var.
-	-----------------------------------------------------------
-	Send text or result of an expression to MUD
-	#send [< | !]{text | (expression)}
-
-	The simplest use of #send is to evaluate an expression and to send
-	the result to the MUD. More generally, #send is very similar to #print,
-	with the only difference that the final text is sent to the MUD rather
-	than displayed on screen.
-	The meaning of < and ! is the same, and #send does the expected things
-	when they are used.
-
-	Example:
-
-	#send <mytext				stuff a text into the mud
-	#send !awk ' {print "tell arthur " $0} ' file
-						say a file to your friend
-	#send ("say I have been playing for " + %(timer/86400000) + " hours")
-			timer is a variable holding the number of millisec
-			elapsed since last timer reset, and the big number
-			after it converts the elapsed time in hours.
-	-----------------------------------------------------------
-	Execute text or result of an expression
-	#exe [< | !]{text | (expression)}
-
-	Evaluate the expression and get result,
-	then execute result as if typed from keyboard.
-	If < or ! is specified, #exe behaves exactly like #print,
-	but executes the final text as if typed.
-
-	Example:
-	#exe ("sigh")       is the same as typing sigh from keyboard.
-
-	#bind control_s=#exe ("#capture emergency" + %(@-7++))
-			(control_s must be a user defined key)
-			safe capture to file: each time you press control_s,
-			a different file is opened as capture.
-
-	#exe <mytext	read the file mytext and execute all the
-			commands in it, one line at time.
-			Very useful to read a set of #alias for example
-	-----------------------------------------------------------
-	Process a text/expression/file as if received from remote host
-	#emulate [< | !]{text | expression}
-
-	Evaluate expression and get result, then process result as if received
-	from remote host
-	If < or ! is specified, #emulate behaves exactly like #print,
-	but processes the final text as if received from remote host
-	(check for matching #actions, extract prompt, etc.)
-
-	This command is particularly useful to test and debug #actions.
-	Example:
-
-	#emulate The assassin is dead! R.I.P.
-	#emulate <myfile
-	-----------------------------------------------------------
-	Put a text or expression in a variable / delete a variable
-	#var variable[=[[< | !]{text | (expression)}]]
-	
-	Evaluate expression and get result, then put result
-	in the specified variable.
-	If < or ! is specified, #var behaves exactly like #print,
-	but puts the final text into the specified variable.
-	If you specify no right-hand expression, powwow puts the current value
-	of the variable on input line, to allow you edit it.
-	If you specify no right-hand expression, BUT YOU USE the =, powwow
-	deletes the variable and frees memory used by it.
-
-	Note: If you use a numbered variable rather than a named one,
-	instead of a number you can place an expression after the $ or @
-	and before the =
-	Example:
-
-	#var @7=22			(same as #(@7=22) )
-	#var $-4 = hello		(note that you do not need quotes
-					 since you are using a plain text)
-	#var $-4 = ("hello")		(if you use parenthesis, you must also
-					 use quotes)
-	#var $test=    long sentence	(all the spaces but the first following
-					 the = are placed in the variable)
-	#var $(2+4) = <myfile		(put the whole file in $6. Remember
-					 that string variables cannot be longer
-					 than 1024 characters...)
-	#alias calc=#var @-1 = !echo '$0' | bc -l
-			(place result from bc calculator into @-1)
-
-	#var $target			(put current value on input line)
-
-	#var $my_variable=		(delete $my_variable and free memory)
-	-----------------------------------------------------------
-	Write text to a file
-	#write [> | !](expression ; file)
-	
-	Evaluate expression and get result, then write result into file.
-	By default, text is appended at the end of the file.
-
-	If > is specified, #write deletes the contents of the file before
-	actually writing the text.
-
-	If ! is specified, #write assumes second parameter to be
-	a Bourne shell command (instead of a file name) that is executed
-	using the text as its input.
-
-	Example:
-
-	#write ($test; "myfile")	(append contents of $test to myfile)
-
-	#write !("55+12";"bc -l")	(execute 'bc -l' writing text to its
-					 standard input)
-
-	Advanced `#write' usage:
-	
-	If you are using a terminal allowing multiple windows (an X11 graphic
-	terminal for example) it is possible to duplicate/split powwow output
-	to multiple windows using #write. This is more a UNIX topic rather
-	than a powwow-specific one, but that's it. Here is a brief summary:
-	
-	First, compile the `catrw' mini-program i.e. type
-	$ make_it catrw
-	if the above worked, type
-	$ mkfifo fifo
-	This will create a special file named `fifo' in the directory
-	(any other name would do, of course)
-	Then you have to open another window. This depends on the terminal
-	you're using, but for X11 terminals the following works:
-	$ xterm &
-	On the second window, type
-	$ exec catrw fifo
-	(in case this gives you an error, try just `catrw fifo')
-	Now return to the first window and start powwow normally.
-	To send text to the second window from within powwow, type:
-	#write ("some text"; "fifo")
-	You should see `some text' (without the quotes) immediately
-	appear in the second window.
-	
-	Of course you may now want to send text automatically
-	to the second window: just use #write ( <your-text> ; "fifo")
-	from within an #alias, #action or whatever you like.
-	
-	P.S.:
-	for experienced users: if you are using the `bash' shell,
-	you don't need `catrw' as you can use
-	$ exec cat <> fifo
-	instead of the above
-	$ exec catrw fifo
-	-----------------------------------------------------------
-	Set/show internal variables
-	#setvar name[={number|(expr)}]
-
-	Evaluate the expression and get result, then set the internal
-	variable `name' to that value.
-	
-	Known internal variables are:
-
-	buffer	with `buffer' different from zero, powwow saves
-		the most recent text from the MUD in a circular list
-		(which is `buffer' bytes long) and writes it
-		at the beginning of #capture and #movie files when
-		you open them. This is useful if something important
-		happens suddenly and you want to log it somewhere:
-		you can start #capture and/or #movie even _after_ the event
-		has happened and it will still get written to the file.
-
-		if `buffer' is zero (default), powwow starts logging
-		text from the MUD only at the moment you activate
-		#capture or #movie.
-	
-		To discard the text stored in memory by `buffer',
-		change its value (for example, set it to zero
-		and then back to a non-zero value).
-
-	lines	the number of lines your terminal has. Powwow usually
-		autodetects it correctly, but on few terminals you may
-		have to set it manually.
-	
-	mem	the maximum length of a text or string, in bytes.
-		The default is 0 (zero) which means no limit.
-		I added it only to prevent bringing down the whole system
-		with things like
-		#while (1) #($foo += $foo + "x")
-		Consider it an emergency setting, as powwow _discards_ text
-		and strings longer than the limit.
-		The failsafe limit set when loading a savefile from an older
-		version is 1Megabyte, which won't give any problem
-		(like increased memory usage) as powwow	allocates memory
-		only when it *has* to.
-		
-	timer	the number of milliseconds since program start.
-		It can be changed to synchronize with an external clock
-		like MUD ticks.
-			
-	Example:
-
-	#setvar timer=0			(reset internal timer to 0)
-	#setvar timer=20000		(make internal timer restart from
-					 20000 milliseconds)
-	#setvar timer			(show timer and let you edit it)
-	
-	#setvar mem=1048576		(max strings length is now 1Megabyte)
-	-----------------------------------------------------------
-	Send raw data to MUD
-	#rawsend {text | (expression)}
-
-	This is mostly a MUD debugging tool, but it can be useful in some cases.
-	Like its cousin #send, #rawsend evaluates the expression (or unescapes
-	the text) and sends the result to the MUD. The difference is that
-	#rawsend does NOT add a final newline, nor does IAC escaping to protect
-	ASCII 255 characters. On the other hand, #rawsend can handle ASCII 0
-	characters, while plain #send can't.
-	-----------------------------------------------------------
-	Send raw data to screen
-	#rawprint {text | (expression)}
-
-	Like its cousin #print, #rawprint evaluates the expression (or
-	unescapes the text) and sends the result to the screen. The difference
-	is that #rawprint does NOT add a final newline. On the other hand,
-	#rawprint can handle ASCII 0 characters, while plain #print can't.
-	-----------------------------------------------------------
-
-INLINE CALCULATOR:
-
-	The inline calculator is used to evaluate expressions inside
-	#(), #print (), #exe (), #send (), #if (), #while(), #for (), #do (),
-	expressions in pattern of #actions and in other commands allowing ()
-
-	The inline calculator recognizes the following objects:
-
-	numbers (only integers are supported)
-	  decimal numbers:
-	    simply write them.
-
-	  hexadecimal numbers:
-	    use '#' as prefix: #F is 15, #a0 is 160, and so on.
-
-	  numbers in any other base:
-	    use base# as prefix: 2#101 means 101 in base 2 (that gives 5)
-	    7#14 gives 11, etc...
-
-	  if you use negative non-decimal numbers, you must put '-'
-	  before the base: - 2#101 is -5, 2#-101 causes an error.
-
-	  it is possible to chain more than one '#':
-	    3#12#100 = (3#12)#100 = 5#100 = 25
-
-	  both base and argument must be numbers, not variables:
-	    things like 7#@count or @count#7 are not allowed, you will
-	    have to use an #exe for that.
-
-	quoted-strings (i.e.: strings in " ")
-
-	  NOTE:
-	  since version 0.6d, powwow performs unescaping on quoted strings
-	  when they are evaluated. For example "\"" is the string that contains
-	  the character " only.
-
-	timer (number of milliseconds since last timer reset)
-
-	map   (string containing the last 999 steps you walked,
-		as the #map command)
-
-	variables:
-	  @n with n within -50 and 9, are numeric-variables
-	  $n with n within -50 and 9, are string-variables
-
-	  Since version 0.8, also named variables are supported:
-
-	  @any_name1
-	  $any_name2
-
-	    The name following @ or $ can contain any of these chars:
-	      uppercase or lowercase letters ('A'...'Z' and 'a'...'z')
-	      underscore ('_')
-	      numbers ('0'...'9')
-	    Anyway, the first char of the name must NOT be a number.
-
-	    Remember that powwow is case sensitive:
-	      $test and $Test are NOT the same variable
-
-	    Named variables are created the first time you use them
-	      and can be deleted only using the #var command
-	    
-	    A special named variable is $prompt, which contains
-	      the current prompt. It cannot be deleted.
-	    Another special variable is $last_line, which contains
-	      the last non-empty line received from the MUD. Again,
-	      it cannot be deleted.
-
-	  Difference between the various kind of variables:
-
-	    Numbered variables with negative counter (@-50..@-1 and $-50..$-1)
-	    and named variables are global:
-	      They can be accessed at any time, but cannot be used for the
-	      substitution performed by #alias, #action, #while and #for.
-
-	    Instead, numbered variables with positive counter (@0..@9 and
-	    $0..$9) are local:
-	      A new set is created (and initialized to zero) every time powwow
-	      executes an #alias, #action, #while or #for, and the old set
-	      is made invisible. After the #alias (or #action, #while, #for)
-	      is executed, the old set is restored.
-	      Note that also @0..@9 can be used for parameter substitution,
-	      and not only $0..$9.
-	      
-	  Variable names as expressions:
-	  
-	    The symbols $ and @ are implemented as normal operators,
-	    which means that variable names can be arbitrary expressions.
-	    For example,
-	      $(1-3)		is the numbered variable $-2
-	      @("foo"+"bar")	is the named variable @foobar
-	      $$1		is the variable whose name is in $1
-	      
-	operators between numbers:
-	  ++ --  +  -
-	   *  /  %
-	   +  -
-	  << >>
-	   < <=  > >= == !=
-	   &  |  ^
-	  && || ^^
-	   = *= /= %= += -= <<= >>= &= ^= |= &&= ^^= ||=
-	   ,
-	   (  )
-	(% and %= always return non-negative values)
-	(no help on these operators, see a C-language manual)
-	(note: unlike C, operators &&, ^^ and || always eval both arguments)
-
-	random number generator:
-
-	  rand positive-number	(return a random number between 0 and n-1)
-
-	operators between strings:
-	   + chain two strings
-	   = assign a string to a string-variable
-	  += append a string to a string-variable
-	   - compare two strings: result -1 if s1<s2, +1 if s1>s2, 
-	      0 if s1==s2
-	   < <=  > >= == != compare two strings
-	  .? number of chars in a string
-	  :? number of words in a string
-	   ? position of first occurrence of second string in the first
-	   * convert first char of a string into its ASCII code or vice versa
-	   % convert string into its numeric value or vice versa
-	
-	operators between a string and a number:
-		 (string is first argument)
-	  : n-th word of a string
-	  . n-th char of a string
-	  :< :> <: >: .< .> <. >. return part of a string, in this way:
-	     : before > or < means 'mark the n-th word from the left'
-	     . before > or < means 'mark the n-th char from the left'
-	     :  after > or < means 'mark the n-th word from the right'
-	     .  after > or < means 'mark the n-th char from the right'
-	     > means: return from marked word/char to end
-	     < means: return from start to marked word/char
-	     
-	     so we get:
-	     :< n     first n words
-	     :> n     from the n-th word (include) to the end
-	     <: n     from the begin to the n-th word (included)
-	     >: n     last n words
-	     
-	     and similarly for .< .> <. >.
-	     
-	  *  repeat a string n times: "ab" * 3 gives "ababab"
-	  *= usual shortcut: `$x *= n' is the same as `$x = $x * n'
-	
-	functions for low-level color handling: 
-
-	  noattr      (string containing the escape sequence to reset terminal
-		      colors and attributes -- bold, underline, inverse)
-
-	  attr "quoted-string"
-		      (return the escape sequence needed to turn on
-		       the attributes and colors in the string.
-		       Syntax of the string is the same as #mark, #hilite, etc)
-
-
-	Examples:
-
-	#print ($5="Hello, world")	(assign "Hello, world" to $5
-					 and print it)
-	#print ("This is a test">:3)	(print from the 3rd word from the right
-					 till the end of the string)
-	  Result: "is a test" is printed on screen
-
-	#action >+exp ^You have scored $1 exp={#print;#print ("You gained " + 
-		( $1 - @-5) + " exp. points since last score"); #(@-5 = $1)}
-
-		(when you type 'info' in MUME, one of the lines you get is:
-		 You have scored xxx exp. points ... 
-		 The #action above intercepts this line, prints it, prints the
-		 difference between your current score and the contents of
-		 variable @-5, then copies your current score in @-5)
-
-	#print ($5 = (attr "bold green") + "Hello, world!" + noattr)
-
-		(same as first example, but with colors/attributes.
-		 Rememeber to print noattr at the end of every colored line,
-		 or everything appearing on the screen after your line
-		 will be colored as well)
-	-----------------------------------------------------------
-
-HOW INLINE CALCULATOR IS IMPLEMENTED
-
-	Info and hints to get the most out of calculator and/or hack it.
-	
-	The structure `op_list[]' defined in xeval.c contains definitions for
-	all the implemented operators, one for each line. Have a look at it
-	to find things like:
-
-	precedence (first number in each line)
-	associativity (LEFT or RIGHT)
-	    LEFT  means that 1+2+3 actually is (1+2)+3
-	    RIGHT means that 1+2+3 actually is 1+(2+3)
-	    (replace numbers and operators with what you are actually using)
-	if it is unary, i.e. needs ONE argument
-	    PRE_UNARY means that the operator comes before its argument,
-	    POST_UNARY is the opposite
-	or binary i.e. needs TWO arguments
-	
-	Note that stuff like `attr', `rand', `@' and `$' are actually
-	implemented as PRE_UNARY operators (named variables are treated as an
-	exception to this), thus `$(1+5)' and `attr ("bold"+" "+"inverse")'
-	are fully allowed. Also note that using `$(5)' is a good way to avoid
-	the parameter substitution performed by aliases, #action, #for, #while
-	and use instead the actual variables.
-	
-	`timer', `map', `noattr' are implemented as read-only values:
-	the calculator simply substitutes them with their value
-	
-	Remember that there is a , (comma) operator:
-	Instead of `#(foo);#(bar)' you can use `#(foo, bar)'
-	Using comma operator is easier for both you and powwow, since it uses
-	a single command instead of two.
-	-----------------------------------------------------------
-
-ATTRIBUTES: COLORS AND OTHER HILIGHTINGS
-
-	Some commands use attributes to specify the visual appearance of text.
-	The following attributes are available:
-		bold, blink, underline, inverse
-					-- the obvious effects
-		reverse			-- same as inverse
-		[color] [on color]	-- foreground and/or background
-	    Colors are:
-		black, red, green, yellow, blue, magenta, cyan, white and
-		BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, none
-		('none' means to use default and is implemented as a color)
-
-	Examples: The following are all valid attributes:
-		none			-- no attribute, use default
-		green			-- only foreground
-		on white		-- only background
-		yellow on cyan		-- foreground and background
-		inverse bold		-- 
-		blink red on blue	-- you can use multiple attributes,
-					   but you must put 'bold' 'inverse'
-					   and/or 'underline' BEFORE colors
-
-	Observe that bold, blink, underline and reverse work with all terminals
-	that support these attributes, but colors only on terminals that
-	support	ANSI color escape sequences.
-
-	Capitalized colors (BLACK..WHITE) are non-ANSI high intensity colors,
-	and will not work on all terminals (They work on the 'aixterm' terminal
-	emulator under AIX, but they may work on other terminals as well.
-	Let me know if you find other terminals that support them).
-
-	Notes for IBM PC and compatibles with VGA or SVGA cards in text mode:
-	    -- yellow is actually brown
-	    -- bold is usually represented as high intensity
-	    -- blink can be represented either with actual blink or
-	       high intensity background - depends from card configuration
-	       (it is possible to reprogram it - I can send details if asked)
-	-----------------------------------------------------------
-
-HISTORY
-
-	Powwow keeps in memory the last 127 lines you typed from keyboard.
-	If you want to recall one of them (to correct a mistake for example)
-	you just need to press your arrow-up key or control-p to scroll through
-	the whole history, one step at time (see COMMAND LINE EDITING below
-	in the text for details about editing keys).
-
-	Another way to find a certain line in the history is to type the first
-	few chars of it, and then press M-TAB to tell powwow to complete the
-	line for you. If you hit M-TAB repeatedly, powwow will cycle
-	through all the possible completions.
-
-	Also, you can use the '#put' command to add a line to history
-	as if you typed it (see above for help on #put).
-	-----------------------------------------------------------
-
-WORD COMPLETION LIST
-
-	Powwow also remembers the last 512 words you typed from keyboard.
-	This list of words is named `word completion list'. If you have already
-	typed a long or difficult word, you can type the first few chars of it
-	and then press TAB key to ask powwow to complete it for you.
-	Again, if you hit TAB repeatedly powwow will cycle through
-	all the possible completions.
-
-	Powwow can also complete the name of any built-in command even if
-	not present in the word completion list.
-
-	Also, you can use the '#add' command to add a word to word completion
-	list (see above for help on #add).
-	-----------------------------------------------------------
-
-COMMAND LINE EDITING
-
-	The default key bindings for line editing follow quite closely Emacs:
-	These are all the keys, together with the reserved names that identify
-	their function (they can be listed typing '#bind edit'):
-
-	Key:	Function name:	Description:
-
-	^A	&begin-of-line	beginning of line
-	^E	&end-of-line	end of line
-	^B	&prev-char	backward one character
-	^F	&next-char	forward one character
-	^P	&prev-line	use previous line in history (step backward)
-	^N	&next-line	use next line in history (step forward)
-	^D	&del-char-right	delete character under cursor
-	BS	&del-char-left	delete character left of cursor
-	^K	&kill-to-eol	kill to end of line
-	^T	&transpose	transpose previous character with next
-				(if at the end of the line, the two last)
-	^L	&redraw-line	redraw your command line.
-				This is useful if something garbles your input
-				line.
-	^Q	&clear-line	clear input line.
-	^W	&to-history	put current line in history and clear input
-				line. This is useful when you are typing a long
-				line and need to send another urgent command
-				first.
-	^Z	&suspend	suspend powwow in the background
-	Tab	&complete-word	complete the word being typed to the last
-				matching word in the history (or added with an
-				#add command; see above).
-				Hit multiple times to browse the possible
-				completions.
-				This is similar to the GNU Emacs M-/ command.
-	M-Tab	&complete-line	complete the line being typed to the last
-				matching line in the history.
-				Hit multiple times to browse the possible
-				completions.
-	M-f	&next-word	forward one word
-	M-k	&redraw-line-noprompt
-				redraw command line, discarding prompt 
-	M-b	&prev-word	backward one word
-	M-d	&del-word-right	delete word right of cursor
-	M-BS	&del-word-left	delete word left of cursor
-	M-l	&downcase-word	turn word to lowercase
-	M-t	&transpose-words transpose previous word with next
-	M-u	&upcase-word	turn word to uppercase
-	Ret	&enter-line	the most obvious: execute the typed line
-	LF      &enter-line     same thing, but for ^J key (some terminals
-				send this when you hit return)
-	(none)  &insert-string 	insert on command line the specified chars
-
-	M-x means pressing the META or Alt key at the same time as x,
-	or pressing and releasing the escape key, then typing x. The former
-	way doesn't work on all terminals.
-
-	^x  means pressing the Control key at the same time as x.
-
-	If your terminal has arrow keys, they can be used to move the
-	cursor and step around in history. In addition, you can define your
-	own key bindings for sending quick commands (see the #bind command).
-	If you have a vt100-compatible terminal, the numeric keypad is
-	predefined for movement (keys 2, 3, 4, 5, 6, 7, 8 and 9).
-
-	Remember that ALL keys can be redefined...
-
-
-	A brief note about &insert-string:
-
-	By default no key is bound to this function, and it works somewhat
-	differently than other editing functions.
-
-	For example, say you don't have `{' and `}' on you keyboard
-	(it happens on all italian keyboards -- like mine -- and other ones).
-	Obviously, typing { or } gets quite difficult. A solution is:
-	
-	#bind F11=&insert-string \173
-	#bind F12=&insert-string \175
-	
-	where \173 and \175 are typed normally: a backslash and three digits.
-	Once you defined these two bindings, hitting F11 will be exactly like
-	typing { and hitting F12 will be exactly like typing } .
-	
-	Another possible use is to enter strange characters or strings:
-	
-	#bind F10=&insert-string Ro\353ntgen
-	does exactly what you expect: insert "Roëntgen" on the input line
-	( ë is the ASCII char (octal)353 or (decimal)234 )
-	as if you typed it (of course you could also type the first few chars
-	of the name then hit TAB if that name is already in the word completion
-	list...).
-	-----------------------------------------------------------
-
-SECURITY
-
-	When you define an #action that automatically sends something back to
-	the MUD you are connected to, you must be VERY careful since you may
-	allow other players to force you to execute commands.
-	Let's explain better: Suppose you define the following #action:
-
-	#action >+autogroup ^&1 starts following you.={#print;group $1}
-
-	Even though this may look harmless, such an action is potentially
-	lethal, for the following reason:
-	If you receive a text from the MUD containing something like
-
-	Cauldron ;remove all;drop all;kill dragon starts following you.
-	(for example it may be an emote, many MUDs allow it)
-
-	powwow will realize that the line matches with the action you defined
-	(remember that &n can match text of every length, even if containing
-	spaces or ; ) and will execute this:
-
-	{#print;group Cauldron ;remove all;drop all;kill dragon}
-
-	The consequences of such a command can be easily imagined...
-	There are two strategies to avoid such embarassing situations:
-	1) Use #send and calculator. In fact this is NOT dangerous:
-
-	   #action >+autogroup ^&1 starts following you.=
-		{#print;#send ("group "+$(1))}
-
-	   (in the worst case you will send some semicolon-separated commands
-	   to the MUD, but I saw no MUDs accepting multiple commands as clients
-	   do...):
-
-	2) Try to use $n instead of &n, so that semicolons and spaces
-	   are skipped.
-
-	   #action >+autogroup ^$1 starts following you.=
-		{#print;group $1}
-
-	   WARNING:
-	   versions older than 0.7a were bugged and they did NOT skip
-	   semicolons (but they skipped spaces), so also using $n was
-	   dangerous!
-
-	   If you really need to use a &n, check you are not losing security,
-	   and if you cannot write safe code, use calculator as in point 1).
-	   Note that this is NOT dangerous too:
-
-	   #action >+autogroup ^&1 starts following you.=group $1
-
-	   since if someone tries to force you as explained above
-	   it will not work, because #action allows only ONE command to follow
-	   the pattern and you did not place braces around "group $1",
-	   so only the first command (in this case "group <name>")
-	   will be executed.
-
-	In every case, remember the best strategy is: check what you are doing,
-	and do not lose control. If you are not sure a command is safe, better
-	not to use it.
-	-----------------------------------------------------------
-
-LIMITS
-
-	Powwow has the following limitations:
-
-	Numeric variables are defined as 'long', that means 32-bit integers
-	  on most systems.
-	  
-	String variables, text lines and commands by default have no length
-	  limits. If you want, you _can_ set a max limit with `#setvar mem'.
-	  Powwow discards text and strings longer than such a limit.
-
-	  Exceptions: the labels/patterns of #aliases, #actions, #prompts,
-	  #marks, #in/#at etc. cannot be longer than 4095 chars.
-	  The same limit (4095 chars) applies for the input line.
-	  (the number can be changed by modifying the symbol BUFSIZE)
-	  
-	Unnamed ('numbered') variables must have indexes from -50 to 9.
-	  (the 50 can be changed modifying the symbol NUMVAR, the 9 cannot
-	   be increased due to hardcoded limits)
-
-	Inline calculator can hold up to 100 suspended operations, due to
-	  parentheses and/or inverted priority of operators.
-	  (the number can be changed by modifying the symbol MAX_STACK)
-
-	The depth of nested/recursive aliases, actions, prompts, #while and
-	#for commands is limited to 100 nested calls.
-	  (the number can be changed by modifying the symbol MAX_STACK)
-
-	The number of loops of a #while or #for is limited to 10000.
-	  (the number can be changed by modifying the symbol MAX_LOOP)
-	  
-	Automap can be at most 999 steps.
-	  (the number can be changed by modifying the symbol MAX_MAPLEN)
-	
-	History can contain at most 127 lines.
-	  (the number can be changed by modifying the symbol MAX_HIST)
-	  #history commands can execute other #history commands, up to
-	  MAX_HIST levels of recursion.
-	  
-        Word completion list can contain at most 512 words.
-	  (the number can be changed by modifying the symbol MAX_WORDS)
-
-        Up to 32 MUD (or spawned) connections can be open simultaneously.
-	  (the number can be changed by modifying the symbol MAX_FDSCAN)
-
-	For all other resources, the only limit is the available memory.
-	-----------------------------------------------------------
-
-THE BREAK KEY
-
-	It is usually Control-C or DEL (it depends from the terminal you use).
-
-	Powwow cannot redefine it, but you need to hit it twice in a row
-	to actually stop powwow.
-	This is because hitting it only once is used to stop command parsing:
-	if you enter a long loop using internal commands
-	(for example: #while (1) drop 1 coin)
-	you can simply press your break key and powwow will immediatly exit
-	from the loop with this message: `#interrupted. Press again to quit.'
-
-	If you press the break key again, you will exit powwow.
-	Otherwise, if you first type something, then you press break key once
-	more, you will get again: `#interrupted. Press again to quit.'
-	-----------------------------------------------------------
-	
-ADVANCED TOPIC: SUBSTITUTIONS AND UNESCAPING
-
-	WARNING:
-	this is a bit complicated and not recommended for beginners,
-	as the explanation given at the beginning about $n and \'s might
-	suffice	in many cases. So you might skip this paragraph if you want.
-	
-	Still reading? Ok, this is it:
-	
-	We described in the beginning that adding \'s to $n delays text
-	substitution in aliases and actions. Actually, every time powwow
-	is asked to execute a command, it can make one or more of the
-	following operations on the command itself before executing it:
-
-	Step (a) : `PARAMETER SUBSTITUTION' or simply `substitution'
-
-	(a1) place in $1..$9 the correct words
-
-	(a2) replace every occurrence of $1..$9 with the contents of the
-	     corresponding variable. Also replace every occurrence of @1..@9
-	     with the contents of the corresponding variable.
-	     Note that if one or more \ are preceding a $n or @n,
-	     it will be NOT substituted.
-
-	Step (b) : `JUST IN TIME SUBSTITUTION' or `jit' in short
-
-	(b1) replace every occurence of #{expression} with the value of the
-	     expression. Also replace every occurrence of ${name} and @{name}
-	     with the contents of the corresponding variable. Again,
-	     if one or more \ are preceding a #{expr}, ${name} or @{name},
-	     it will NOT be substituted. This substitution works also
-	     for numbered variables ${number} and @{number}.
-
-	Step (c) : `UNESCAPING'
-	
-	(c1) Remove ONE \ from every list of consecutive escapes,
-	     unless they are followed by one or more ` (i.e. reverse-escaped)
-	     For example, \\\$1 is replaced with \\$1
-
-	(c2) Remove ONE ` from every list of consecutive escapes immediately
-	     followed by a list of consecutive `
-	     For example, @``` is not modified,
-		while \\` is replaced with \\
-		and   \\``` is replaced with \\``
-	
-	The steps actually executed vary from command to command,
-	but are always ran in order:
-	if both present, (a) always precedes (b)
-	if both present, (a) always precedes (c)
-	if both present, (b) always precedes (c).
-
-	-----------------------------------------------------------
-
-	When each step is performed/not performed:
-	
-	Step (a) (substitution) is performed when executing one of the
-	  following:
-	  aliases, actions, prompts, #for or #while
-	
-	Step (b) (jit) is performed when executing _any_ command that allows
-	  a single instruction, and is executed on that instruction before
-	  running it. The list is:
-	  #alias, #action, #prompt, #at, #bind, #connect, #do, #for, #identify,
-	  #if-#else, #in, #init, #nice, #while.
-
-	  Also performed on normal (not yet implemented for regexp) patterns
-	  of #actions before matching them. On regexp patterns, step (c)
-	  is made instead.
-
-	Step (c) (unescaping) is performed any time that step (a)
-	  and/or step (b) are performed.
-
-	  In addition, unescaping is also performed on text
-	  (not on expressions) following all #commands that allow plain text:
-	  #add, #emulate, #exe, #mark, #print, #put, #send, #var
-	
-	  on labels of all #commands that allow labels:
-	  #alias, #action, #prompt, #at, #in
-	
-	  and last, on text that is not a #command nor an alias
-	  before sending it to the MUD, unless the last operation on the
-	  text was _already_ an unescaping.
-	
-	Examples:
-	
-	#alias fb=cast 'fireball' ${target}
-	#var $target=troll
-	fb				(effect: cast 'fireball' troll)
-	#var $target=dragon
-	fb				(effect: cast 'fireball' dragon)
-	
-	#action >chase ^${target} leaves $1={#print; #alias f=$1}
-					(whenever `dragon' leaves the room,
-					 the alias 'f' is set to follow it)
-
-	#action >chase2 ^\${target} leaves $1={#print; #alias f=$1}
-					(the text `${target}' will be matched
-					 literally)
-	WARNINGS:
-	
-	Step (b) is NOT automatically performed on text typed from the keyboard
-	  so for example `#print ${target}' just prints literally `${target}'
-	  and not the contents of the variable.
-	  If you need step (b) on text you type, you can do something like:
-	  #alias /=$0
-	  and then prepend all commands with `/ ' :
-	  / #print ${target}
-	
-	Step (b) is not yet implemented for regexp actions/prompt due to
-	  internal difficulties. As a workaround, step (c) (unescaping)
-	  is instead performed on regexp patterns.
-
-	Since powwow 1.1.3, unescaping is performed also on the text coming
-	  from substition and jit. This causes subtle incompatibilities with
-	  previous versions in case $n contains any \ or \` .
-	  I tried to avoid this incompatibility, but it is really complicated
-	  to do since I want the text coming from substitution to be subject
-	  to jit as well. So you (and me) will have to live with it :-(
-	-----------------------------------------------------------
-
-ADVANCED TOPIC: SPECIAL COMMAND #PROMPT
-
-	Automatic command execution triggered on prompts
-	#prompt [[<|=|>|%][+|-]label] [{pattern | (expression)}=[command]]
-	
-	WARNING:
-	this is quite a complicated topic too. You will only need to read this
-	paragraph if you want to mess with prompts in strange ways, as powwow
-	usually handles prompts correctly.
-	
-	Second warning:
-	#prompt works only on the main MUD connection.
-	
-	O.K, since you are still reading, let's get a bit technical about
-	powwow internals:
-	
-	(WARNING: this changed since powwow 1.1.7:)
-
-	Unless you use #actions, powwow sends immediately to the screen
-	whatever text it receives from the MUD. It sends to screen both
-	newline-ended lines (we'll name these `full lines')
-	and lines not ended with a newline (`incomplete lines').
-	Now, there are two problems:
-	1) there's no way to know whether an incomplete line is actually
-	   finished or there is a continuation we still have to receive.
-	2) powwow cannot know if the line, or an initial part of it,
-	   is a prompt.
-	
-	When powwow receives a line (either full or incomplete),
-	its beginning part may be a prompt, so it matches #prompts on the line.
-	If the beginning part is _actually_ a prompt, #prompt should
-	execute #isprompt on it, to let powwow recognize the prompt as such.
-
-	To be exact #isprompt must also specify how long the initial prompt is,
-	so that powwow can split it from the rest of the line.
-	For this reason, #isprompt is invoked with a numerical argument:
-	#isprompt <number>
-	or
-	#isprompt (expression)
-	
-	a)If the number (or the result of the expression) is positive
-	  and equals to (n), #isprompt declares that the initial prompt
-	  is (n) characters long.
-	b)If the number is negative and equals to (-n), #isprompt declares
-	  that the initial prompt is the same length as the parameter $n.
-	c)If the number is 0 (or is missing), #isprompt declares
-	  the whole line as a prompt.
-
-	Also, if a #prompt does not run #isprompt, it is interpreted as
-	'this text is not a prompt'
-
-	Putting #isprompt in a #prompt inhibits further attempts to match
-	that part of the line against both #prompts and #actions
-	(so should be used only on a complete prompt, not on a part of it)
-	
-	NOTE: Since a prompt may be followed by other text, when using
-	  regexp patterns in #prompt it is important not to end the pattern
-	  with $ (which matches the 'end of line')
-	
-	Examples:
-	
-	On MUME the prompt starts with either `o' or `*' and finishes with `>'
-	So the regexp pattern ^[o\*].*> will match all prompts and nothing else
-	To do the same using normal patterns, one should use two patterns
-	(and two #prompts): ^o&1> and ^*&1>
-	
-	On other MUDs of course the possible prompts will vary, so one must
-	find which pattern (or patterns) will match all the possible prompts.
-	If it also matches strings that are not prompts, care is required
-	_not_ to run #isprompt in such cases.
-	
-	Let's continue with the MUME example: using regexp patterns,
-	a correct #prompt is:
-	
-	#prompt %default ^[o\\*][^>]*>=
-	    {#isprompt -1; #($prompt = "xyz " + attr "bold" + $prompt + noattr)}
-	    
-	Note that the pattern contains _two_ backslashes instead of one,
-	as powwow unescapes regexp patterns.
-	Also, [^>]*> is used instead of .*> to stop matching at the _first_ `>'
-	(regexp by default would match the longest text possible,
-	 stopping at the _last_ `>' in the line)
-
-	The #prompt above correctly matches every MUME prompt,
-	runs #isprompt -1 on it
-	  (which declares that the prompt is as long as $1
-	   since in regexp patterns $1 is the whole match, it is a good choice)
-	then modifies the prompt in a custom way
-	  (puts it in bold then appends it to "xyz ")
-
-	Of course #prompts may do whatever one wants, but with a limitation:
-	they must run #isprompt _before_ modifying the prompt, or unpredictable
-	things could happen.
-	
-	To have the same effect with normal patterns, the following
-	would be needed:
-	
-	#prompt >default1 ^o&1>=
-	    {#isprompt (2+.?$(1)); #($prompt = "xyz " + attr "bold" + $prompt + noattr)}
-
-	#prompt >default2 ^*&1>=
-	    {#isprompt (2+.?$(1)); #($prompt = "xyz " + attr "bold" + $prompt + noattr)}
-
-	The expression after #isprompt meanxs "2 plus the length of $1"
-	which is obviously the correct length, as $1 does not contain
-	`o' (or `*') and `>'.
-	
-	Final note:
-	If the prompt is longer than a whole line, it may be drawn incorrectly
-	and may	interfere with the input line (yep, it's a bug).
-	
-	MUME players who happen to own a Valar+ character will find this
-	useful too:
-	#prompt >default3 ^+&1>={#isprompt (2+.?$(1))}
-	or, to use regexp patterns:
-	#prompt %default ^[o\\*\\+][^>]*>={#isprompt -1}
-	
-	-----------------------------------------------------------