&/addworld
&addworld()

addworld()

  [1mFunction[22;0m usage: 

  [1mADDWORLD[22;0m(<[4mname[24m>, <[4mtype[24m>, [<[4mhost[24m>, <[4mport[24m> [, <[4mchar[24m>, <[4mpass[24m> [, <[4mfile[24m> [, 
  <[4mflags[24m> [, <[4msrchost[24m>]]]]])

  Command usage: 

  [1m/ADDWORLD[22;0m [-pxe] [-T<[4mtype[24m>] [-s<[4msrchost[24m>] <[4mname[24m> [<[4mchar[24m> <[4mpass[24m>] <[4mhost[24m> 
  <[4mport[24m> [<[4mfile[24m>]
  [1m/ADDWORLD[22;0m [-T<[4mtype[24m>] [-s<[4msrchost[24m>] <[4mname[24m>
  [1m/ADDWORLD[22;0m [-T<[4mtype[24m>] DEFAULT [<[4mchar[24m> <[4mpass[24m> [<[4mfile[24m>]]
  ____________________________________________________________________________

  Defines a new [1mworld[22;0m or redefines an existing [1mworld[22;0m with the name <[4mname[24m>.  
  <[4mName[24m> may not contain spaces; addtionally, when defining a new world, 
  <[4mname[24m> may not begin with "(".  

  <[4mHost[24m> is a server's internet hostname, IPv4 address, or (if your platform 
  supports it) IPv6 address.  <[4mPort[24m> is the number or name of a TCP port on 
  the host.  If <[4mhost[24m> and <[4mport[24m> are blank, then "connecting" to the world 
  will only create a tf window for the world, it will not open an actual 
  network connection; this is called a "connectionless" socket.  

  There may be a special [1mworld[22;0m named "default" which does not have a <[4mhost[24m> or 
  <[4mport[24m>.  If a normal [1mworld[22;0m is defined without a <[4mcharacter[24m>, <[4mpass[24m>, <[4mtype[24m>, 
  or <[4mmfile[24m>, then that [1mworld[22;0m will use the corresponding field of the 
  "default" [1mworld[22;0m if there is one.  If the "default" [1mworld[22;0m is redefined, 
  [1mworlds[22;0m with omitted fields will use the new default values.  

  In function form, <[4mflags[24m> is a string of 0 or more letters that modify the 
  behavior of the function.  For compatability with older versions of TF, an 
  "f" or "0" in <[4mflags[24m> has the same effect as "p", and an "n" or "1" in 
  <[4mflags[24m> has no effect.  

  If <[4mflags[24m> contains "p" (in function form) or -p is given (in command form), 
  [1m%{proxy_host}[22;0m will be ignored, and all connections to the world will be 
  direct.  By default, worlds use [1m%{proxy_host}[22;0m if it is set.  

  If <[4mflags[24m> contains "x" (in function form) or -x is given (in command form), 
  TF will use the SSL protocol to make connections to this world.  

  If <[4mflags[24m> contains "e" (in function form) or -e is given (in command form), 
  all text sent to the world will be echoed right back as if it were received 
  from the world (in addition to being sent to the server).  This is most 
  useful with connectionless sockets.  

  The optional <[4msrchost[24m> defines the host name or IP address to use for the 
  local (tf) side of the connection.  This is useful if the host has multiple 
  network interfaces and you need to override the default choice of the OS.  

  The optional <[4mtype[24m> is used in hooks and triggers, and for automatic [1mlogin[22;0m 
  and flag setting.  The library pre-defines WORLD and LOGIN hooks for types 
  that match these [1mglob patterns[22;0m: 

  (none)  TinyMud [1mlogin[22;0m format ("connect <[4mchar[24m> <[4mpass[24m>"), the value of [1mlp[22;0m is 
          not changed.  

  tiny, tiny.* 
          TinyMud [1mlogin[22;0m format ("connect <[4mchar[24m> <[4mpass[24m>"), [1mlp[22;0m=off.  

  lp, lp.* 
  diku, diku.* 
  aber, aber.* 
          LP/Diku [1mlogin[22;0m format (sends <[4mchar[24m> and <[4mpass[24m> on separate lines), 
          [1mlp[22;0m=on.  For servers that send unterminated prompts.  

  lpp, lpp.* 
          LP/Diku [1mlogin[22;0m format, [1mlp[22;0m=off.  For muds that use GOAHEAD or EOR 
          [1mprompt protocol[22;0m.  

  telnet, telnet.* 
          Telnet [1mlogin[22;0m format (sends <[4mchar[24m> and <[4mpass[24m> when "login:" and 
          "password:" prompts are received), [1mlp[22;0m=on, [1m/localecho[22;0m on.  For any 
          line-by-line telnet service.  

  You can define your own world types for use in other triggers or hooks.  If 
  you use names that match the [1mglob[22;0m patterns above, the standard library hooks 
  will still work.  For example, if you did: 

    [1m/test[22;0m [1maddworld[22;0m("Cave", "tiny.muck.",     "cave.tcp.com", 2283, <[4mchar[24m>, <[4mpass[24m>)
    [1m/test[22;0m [1maddworld[22;0m("Foo",  "tiny.muck.msp.", "foo.com",      9999, <[4mchar[24m>, <[4mpass[24m>)
    [1m/test[22;0m [1maddworld[22;0m("Cow",  "tiny.moo.",      "cow.com",      8267, <[4mchar[24m>, <[4mpass[24m>)
    [1m/test[22;0m [1maddworld[22;0m("Buzz", "tiny.moo.msp.",  "buzz.org",     8267, <[4mchar[24m>, <[4mpass[24m>)

  then tiny-style [1mautologin[22;0m would still work (using the library hooks), and 
  you could also define your own [1mtriggers[22;0m and [1mhooks[22;0m specific to TinyMUCKs or 
  TinyMOOs (e.g., "[1m/def[22;0m [1m-T[22;0mtiny.muck.*") or to worlds that support MSP 
  regardless of their server type (e.g., "[1m/def[22;0m [1m-T[22;0m*.msp.*"), etc.  Note the 
  trailing period on the world type defintions, which make it easier to write 
  matching triggers.  

  Any <[4mtype[24m> is valid, but is only useful if it is matched by a "[1m-T<[4mtype[24m>[22;0m" 
  option of a [1mhook[22;0m or [1mtrigger[22;0m.  

  If [1maddworld()[22;0m with a password is executed from a file that has permissions 
  making it readable by others, it will produce a warning.  You should change 
  the file permissions to prevent other people from reading your password.  

  See: [1mworlds[22;0m, [1m/connect[22;0m, [1m/fg[22;0m, [1m/unworld[22;0m, [1m/edworld[22;0m, [1m/telnet[22;0m 

&/addtiny
&/addlp
&/addlpp
&/adddiku
&/addtelnet

/add<[4mworldtype[24m>

  The comamnds [1m/addtiny[22;0m, [1m/addlp[22;0m, [1m/addlpp[22;0m, [1m/adddiku[22;0m, and [1m/addtelnet[22;0m take the 
  same arguments as [1m/addworld[22;0m, and also give that world a type.  A world's 
  type determines the format for automatic login and flag settings.  

  See: [1m/addworld[22;0m 

&/alias
&/unalias

/alias

  Usage: 

  [1m/REQUIRE[22;0m alias.tf

  [1m/ALIAS[22;0m [<[4mname[24m> [<[4mcommand[24m>]]
  [1m/UNALIAS[22;0m <[4mname[24m>
  [1m/PURGEALIAS[22;0m
  ____________________________________________________________________________

  With no arguments, [1m/alias[22;0m lists all aliases.  With a <[4mname[24m> argument, [1m/alias[22;0m 
  lists the alias with names that match the glob pattern <[4mname[24m>.  Otherwise, 
  [1m/alias[22;0m defines <[4mname[24m> as an alias for <[4mcommand[24m>.  

  [1m/Unalias[22;0m undefines an alias for <[4mname[24m> that was defined with [1m/alias[22;0m.  

  [1m/Purgealias[22;0m undefines all aliases defined with [1m/alias[22;0m.  Note that 
  [1m/purgealias[22;0m does not take a pattern argument.  

  To use an alias, just type its name followed by any optional arguments.  
  Unlike [1mmacros[22;0m defined with [1m/def[22;0m, you do not type '/' before <[4mname[24m> to 
  execute an alias.  [1mArgument substitution[22;0m in aliases works the same as in 
  [1mmacros[22;0m.  

  As of 3.5 alpha 11, aliases can be called from other aliases or [1mmacros[22;0m.  To 
  send a line of text to the server without alias calls, use [1msend()[22;0m.  If an 
  old alias that used to work now results in "Too many recursions", you need 
  to rewrite the alias to use [1msend()[22;0m.  

  Using [1m/def[22;0m instead of [1m/alias[22;0m is recommended.  

  See: [1m/def[22;0m, [1mmacros[22;0m, [1msubstitution[22;0m, [1mtfrc[22;0m 

&/at

/at

  Usage: 

  [1m/AT[22;0m [-v] [<[4mdate[24m>] <[4mtime[24m> <[4mcommands[24m>
  ____________________________________________________________________________

  <[4mCommands[24m> will be executed at <[4mdate[24m> and <[4mtime[24m>.  <[4mDate[24m> must be of the 
  form "<[4myear[24m>-<[4mmonth[24m>-<[4mday[24m>" or "<[4mmonth[24m>-<[4mday[24m>", where <[4myear[24m> may be 2 or 4 
  digits.  <[4mTime[24m> must be of the form "<[4mhours[24m>:<[4mminutes[24m>" or 
  "<[4mhours[24m>:<[4mminutes[24m>:<[4mseconds[24m>", where <[4mhours[24m> is between 0 and 23, and 
  <[4mseconds[24m> may be specified to the nearest microsecond.  If any part of the 
  date is omitted, it defaults to the nearest value for which <[4mdate[24m> and 
  <[4mtime[24m> are in the future.  For example, if the current time is 16:00, then 
  an argument of "15:00" means 15:00 tomorrow, and "17:00" means 17:00 today.  

  [1mOptions[22;0m: 
  -v      verbose: prints full date and time 

  Examples: 
  [1m/at[22;0m 04-01 00:00:00 [1m/echo[22;0m Happy April Fools Day!
  [1m/def[22;0m lunch_reminder = [1m/at[22;0m 12:00 [1m/echo[22;0m Lunchtime!%%; /lunch_reminder

  See: [1mprocesses[22;0m, [1m/repeat[22;0m, [1m/quote[22;0m 

&/bamf

/bamf

  Usage: 

  [1m/BAMF[22;0m [OFF|ON|OLD]
  ____________________________________________________________________________

  Sets the flag [1m%{bamf}[22;0m.  This flag controls whether TF will cooperate with 
  portals.  A portal allows a mud character to move from one server to another 
  transparently, by simply going through a seemingly normal mud exit.  

  How it works: A "portal" is text sent by a server of the form: 


    #### Please reconnect to <[4mname[24m>@<[4maddr[24m> (<[4mhost[24m>) port <[4mport[24m> #### 

  For example: 


    #### Please reconnect to Islandia@128.100.102.51 (hawkwind.utcs.toronto.edu) port 2323 #### 

  If [1m%{bamf}[22;0m is off, lines in this format have no effect.  If [1m%{bamf}[22;0m is on, 
  Fugue will attempt to use the portal as an UnterMUD portal: it will 
  disconnect from the [1mcurrent[22;0m world, and attempt to connect to the new world; 
  if the [1m%{login}[22;0m flag is also on, TF will try to log in to the new world 
  using the name and password from the [1mcurrent[22;0m world.  If bamf is "old", Fugue 
  will connect to the new world without disconnecting from the [1mcurrent[22;0m world.  
  If [1m%{login}[22;0m is also on, and the new world has been defined with a name and 
  password in an [1m/addworld[22;0m command, Fugue will attempt to log in 
  automatically.  

  The flag [1m%{bamf}[22;0m defaults to 0 (off).  

  See: [1mworlds[22;0m, [1msockets[22;0m, [1m%bamf[22;0m, [1m%login[22;0m 

&/beep

/beep

  Usage: 

  [1m/BEEP[22;0m [<[4mnumber[24m>|ON|OFF]
  ____________________________________________________________________________

  [1m/beep[22;0m causes Fugue to emit <[4mnumber[24m> beeps (ASCII 7).  [1m/beep[22;0m with no 
  arguments will emit three beeps.  [1m/beep[22;0m OFF causes Fugue to ignore further 
  calls to [1m/beep[22;0m until a [1m/beep[22;0m ON is performed.  

  Note that on many terminals, multiple immediate beeps are indistinguishable. 
  You can use [1m/repeat[22;0m to put a delay between beeps: 

    [1m/repeat[22;0m -0.2 5 [1m/beep[22;0m

&/bind

/bind

  Usage: 

  [1m/BIND[22;0m <[4msequence[24m> = <[4mcommand[24m>
  ____________________________________________________________________________

  Creates a [1mmacro[22;0m that will be executed when <[4msequence[24m> is typed at the 
  keyboard.  The <[4msequence[24m> may use ^<[4mkey[24m> notation for a control key, and 
  \<[4mnumber[24m> for an ascii character code in octal, hexadecimal, or decimal.  
  For example, the escape character can be given by any of these forms: ^[, 
  \033, \0x1B, or \27.  

  When the key sequence <[4msequence[24m> is typed at the keyboard, <[4mcommand[24m> is 
  executed.  The command is actually a [1mmacro[22;0m body, so all the substitutions 
  described under "[1mevaluation[22;0m" will be performed.  The most common command 
  used with a key binding is [1m/dokey[22;0m.  

  At [1mstartup[22;0m, TF defines bindings for [1m/dokey[22;0m BSPC, BWORD, DLINE, REFRESH, 
  LNEXT, UP, DOWN, RIGHT, and LEFT based on your terminal settings.  Also, the 
  standard [1mmacro[22;0m library defines a set of (invisible) default bindings, one 
  for each of the [1m/dokey[22;0m functions.  

  If [1m/bind[22;0m fails for any reason, it returns 0.  Otherwise, it returns the 
  number of the new [1mmacro[22;0m (useful in [1m/undefn[22;0m and [1m/edit[22;0m).  

  As of version 3.5, the NUL character (^@) is allowed in keybindings.  

  The command
  [1m/bind[22;0m <[4msequence[24m> = <[4mcommand[24m>
  is equivalent to
  [1m/def[22;0m [1m-b[22;0m"<[4msequence[24m>" = <[4mcommand[24m>. 

  Examples: 

    [1m/bind[22;0m ^Xtw = :jumps to the left%;:steps to the right!
    [1m/bind[22;0m ^[q = [1m/set[22;0m [1mmore[22;0m off
    [1m/bind[22;0m ~ky = [1m/input[22;0m Kyosuke

  See: [1mkeys[22;0m, [1m/dokey[22;0m, [1m/unbind[22;0m, [1m/input[22;0m, [1minterface[22;0m 

&/break

/break

  Usage: 

  [1m/BREAK[22;0m [<[4mn[24m>]
  ____________________________________________________________________________

  During [1mmacro[22;0m evaluation, [1m/BREAK[22;0m unconditionally terminates the nearest 
  enclosing [1m/WHILE[22;0m loop.  If <[4mn[24m> is specified, it will break out of <[4mn[24m> 
  enclosing [1m/WHILE[22;0m loops.  If used outside a [1m/WHILE[22;0m loop, the [1mmacro[22;0m evaluation 
  is terminated.  

  See: [1m/while[22;0m, [1m/return[22;0m, [1m/exit[22;0m, [1mevaluation[22;0m 

&/cat

/cat

  Usage: 

  [1m/CAT[22;0m [%]
  ____________________________________________________________________________

  Concatenates (puts together) all subsequent lines until a line containing a 
  single "." is typed.  If the argument "%" is given, a "%;" sequence is 
  appended to each intermediate line.  The concatenated result is then 
  executed as a single line.  

  The concatenated result is stored in the input [1mhistory[22;0m as a single line, so 
  intermediate lines can not be recalled separately.  

  Example: 

    [1m/cat[22;0m %
    :foo
    :bar
    :baz
    . 

  This produces: 

    :foo%;:bar%;:baz

  If the [1m%{sub}[22;0m flag is set on, this will [1mexpand[22;0m to three lines ":foo", ":bar" 
  and ":baz" and be sent to the [1msocket[22;0m.  

  See: [1m/paste[22;0m, [1m/sub[22;0m, [1mgeneral[22;0m, [1mhistory[22;0m 

&/changes

/changes

  Usage: 

  [1m/CHANGES[22;0m [<[4mversion[24m>]
  ____________________________________________________________________________

  List the changes in a <[4mversion[24m> of TinyFugue; if omitted, <[4mversion[24m> defaults 
  to the current version.  <[4mVersion[24m> can be a full version name (e.g., "3.5 
  beta 1") or just the major and minor numbers (e.g., "3.5").  The information 
  is kept in the file [1m%TFLIBDIR[22;0m/CHANGES.  

  A list of changes in the latest version of tf can be found at 
  [1mhttp://tf.tcp.com/CHANGES[22;0m.  

  See: [1m/version[22;0m 

&completion
&/complete

/complete

  Usage: 

  [1m/COMPLETE[22;0m [<[4mtype[24m>]
  ____________________________________________________________________________

  When a part of a word is typed, and then [1m/complete[22;0m is called (from a 
  [1mkeybinding[22;0m), it will attempt to fill in the rest of the word.  The possible 
  words it chooses from depend on <[4mtype[24m>.  If no <[4mtype[24m> is given, it completes 
  from context: it will choose the type of completion based on earlier parts 
  of the line being typed, plus previous [1minput history[22;0m.  For example, if the 
  line begins with "/connect", it will use worldname completion; if the word 
  begins with "%" or "%{", it will use variable name completion; etc.  

  The following table lists the meanings and the default [1mkeybindings[22;0m for each 
  type.  

      Keys                Type            Meaning
      ----                ----            -------
      ^[^I (ESC TAB)                      complete word depending on context
      ^[^W                worldname       complete tf world name
      ^[$                 macroname       complete tf macro name
      ^[%                 variable        complete tf variable name
      ^[/                 filename        complete file name (unix only)
      ^[;                 user_defined    complete from [1m%{completion_list}[22;0m
      ^[i                 input_history   complete from previously typed words
                          sockname        complete name of open tf socket

  The "ESC TAB" and "ESC ;" bindings will use the [1m%{completion_list}[22;0m [1mvariable[22;0m, 
  in which you can store a list of any words you want to be able to complete.  

  You can also define your own types of completion.  See the 
  [1m%{TFLIBDIR}[22;0m/complete.tf file for more information.  

  See: [1mkeybindings[22;0m, [1minterface[22;0m 

&/connect

/connect

  Usage: 

  [1m/CONNECT[22;0m [-lqxbf] [<[4mworld[24m>]
  [1m/CONNECT[22;0m <[4mhost[24m> <[4mport[24m>
  ____________________________________________________________________________

  In the first form, [1m/connect[22;0m attempts to open a [1msocket[22;0m connected to <[4mworld[24m>.  
  <[4mWorld[24m> must be defined by the [1m/addworld[22;0m command and not already open.  If 
  <[4mworld[24m> is omitted, the first defined world will be used.  If <[4mworld[24m> does 
  not have a host and port, [1m/connect[22;0m will create a "connectionless" [1msocket[22;0m.  
  In the form "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>", it will define a temporary world named 
  "(unnamed<[4mN[24m>)" with the given address, and try to connect to it.  <[4mHost[24m> may 
  be an internet hostname, an [1mIPv4[22;0m address, or (if your platform supports it) 
  an [1mIPv6[22;0m address.  A temporary world will be undefined when it is no longer 
  in use.  

  [1mOptions:[22;0m 
  -l      No [1mautomatic login[22;0m (i.e., don't call the [1mLOGIN[22;0m [1mhook[22;0m).  
  -q      Quiet login (overrides [1m%{quiet}[22;0m flag).  
  -x      Connect using SSL (not necessary if [1mworld[22;0m was defined with the "x" 
          flag).  
  -f      Connect in the foreground 
  -b      Connect in the background 

  The first thing [1m/connect[22;0m does is create a new [1msocket[22;0m.  If the -f option was 
  given, or [1m/connect[22;0m was called from the foreground (e.g., from the command 
  line), the new [1msocket[22;0m is immediately brought into the [1mforeground[22;0m.  If the -b 
  option was given, or [1m/connect[22;0m was called from the background (e.g., from a 
  DISCONNECT [1mhook[22;0m in a [1mbackground[22;0m world), the connection proceeds in the 
  background.  

  If a hostname was given, TF must look it up to find one or more [1mIPv4[22;0m or (if 
  your platform supports it) [1mIPv6[22;0m addresses.  If [1m%{gethostbyname}[22;0m is 
  "nonblocking" (the default), and this process takes more than a fraction of 
  a second, TF will print "Hostname resolution for <[4mworld[24m> in progress" (the 
  PENDING [1mhook[22;0m), and TF will continue running normally while the lookup 
  proceeds.  But if [1m%{gethostbyname}[22;0m is "blocking", TF will freeze until the 
  lookup is finished.  Either way, if the lookup succeeds, TF will try to 
  connect; if it fails, you will be notified.  

  Next, TF tries to open a network connection to the IP address, and prints 
  "Trying to connect to <[4mworld[24m>: <[4maddress[24m> <[4mport[24m>" (the PENDING hook).  On 
  most platforms, if [1m%{connect}[22;0m is "nonblocking" (the default), TF continues 
  running normally while the network connection proceeds.  But if [1m%{connect}[22;0m 
  is "blocking", TF will freeze until the network connection is finished.  If 
  the connection succeeds, a message is printed, but (unlike previous versions 
  of TF) the [1msocket[22;0m is not automatically brought to the [1mforeground[22;0m.  However, 
  if you had run [1m/connect[22;0m in the foreground (e.g.  from the command line), the 
  [1msocket[22;0m would already be in the [1mforeground[22;0m, unless it was nonblocking and had 
  taken a long time and you [1mforegrounded[22;0m another [1msocket[22;0m while you were 
  waiting, in which case you probably wouldn't want to automatically 
  [1mforeground[22;0m the new [1msocket[22;0m.  If you prefer automatic [1mforegrounding[22;0m upon 
  successful connection, you can [1mdefine[22;0m a CONNECT [1mhook[22;0m that calls "[1m/fg[22;0m [1m%{1}[22;0m".  

  Even if [1m%{gethostbyname}[22;0m and/or [1m%{connect}[22;0m are "blocking", they can be 
  interrupted with the SIGINT [1msignal[22;0m (^C).  

  If the connection fails, TF normally prints "Connection to <[4mworld[24m> failed: 
  <[4maddress[24m> <[4mport[24m>: <[4mreason[24m>" (the CONFAIL [1mhook[22;0m).  But, if the failure was in 
  the specific address, and there is more than one address associated with the 
  [1mworld[22;0m's hostname, the message will instead say "Intermediate connection to 
  <[4mworld[24m> failed: ..." (the ICONFAIL [1mhook[22;0m), and TF will try to connect to the 
  next address.  So, a failed [1m/connect[22;0m will always result in a series of zero 
  or more ICONFAIL [1mhooks[22;0m followed by exactly one CONFAIL [1mhook[22;0m.  But an 
  ICONFAIL may also be followed by a successful connection to an alternate 
  address.  

  If the network connection is successful, or the [1msocket[22;0m is "connectionless", 
  these events occur: 

    * If the [1mworld[22;0m was defined with an <[4mmfile[24m>, that file will be loaded 
      (and the LOAD [1mhook[22;0m will be called); 
    * The CONNECT [1mhook[22;0m is called (unless the socket is connectionless or 
      the connection is via a [1mproxy[22;0m).  
    * If [1m%{login}[22;0m is on, and a character and password is defined for the 
      [1mworld[22;0m, the LOGIN [1mhook[22;0m is called (unless the socket is connectionless or 
      the connection is via a [1mproxy[22;0m).  The default LOGIN [1mhooks[22;0m sends the 
      character name and password in a format corresponding to the world type. 
      To automatically login to a world that expects a different login format, 
      define your own LOGIN [1mhook[22;0m.  

  If you have trouble connecting (especially if you use SOCKS), try "[1m/set[22;0m 
  [1mconnect[22;0m=blocking".  

  If your host has multiple network interfaces, the OS will choose one of them 
  for the client end of the connection according to its own rules.  To 
  override the system's choice, set the [1mtfhost[22;0m variable or define the [1mworld[22;0m 
  with a <[4msrchost[24m> parameter to [1maddworld[22;0m.  

  [1m/connect[22;0m returns 0 on error or failure, 1 for immediate success, or 2 if the 
  name lookup or network connection is pending.  

  See: [1mworlds[22;0m, [1msockets[22;0m, [1mproxy[22;0m, [1m/world[22;0m, [1m/addworld[22;0m, [1m/fg[22;0m, [1m/retry[22;0m, [1m%login[22;0m, 
  [1m%gethostbyname[22;0m, [1m%connect[22;0m, [1mhooks[22;0m [1mprocotols[22;0m 

&disconnect
&close
&/dc

/dc

  Usage: 

  [1m/DC[22;0m [<[4mworld[24m>|-ALL]
  ____________________________________________________________________________

  Disconnects from the named world, or the [1mcurrent[22;0m world if no world is given, 
  or all worlds if "-all" is given.  If the flag [1m%{quitdone}[22;0m is on, and [1m/dc[22;0m 
  disconnects the last [1msocket[22;0m, TF will exit.  

  Disconnecting with [1m/dc[22;0m does not invoke the [1mDISCONNECT[22;0m [1mhook[22;0m.  

  See: [1msockets[22;0m, [1m%quitdone[22;0m, [1m/quit[22;0m 

&/def

/def

  Usage: 

  [1m/DEF[22;0m [<[4moptions[24m>] [<[4mname[24m>] [= <[4mbody[24m>]
  ____________________________________________________________________________

  Defines a [1mmacro[22;0m with an optional [1mkeybinding[22;0m, [1mtrigger[22;0m and/or [1mhook[22;0m associated 
  with it.  The [1moptions[22;0m and their meanings are: 

#-msimple
#-mglob
#-mregexp
#/def -m
#-m
  -m<[4mmatching[24m> 
          Determines which matching style should be used for [1m-t[22;0m, [1m-h[22;0m, or [1m-T[22;0m 
          options.  Valid values are "[1msimple[22;0m", "[1mglob[22;0m", and "[1mregexp[22;0m" (see also: 
          [1mpatterns[22;0m).  If omitted, the value of [1m%{matching}[22;0m ("[1mglob[22;0m" by default) 
          is used, unless [1m-P[22;0m is also given, in which case "[1mregexp[22;0m" is used.  

#/def -n
#-n
  -n<[4mshots[24m> 
          The [1mmacro[22;0m is a multi-shot, that is, it will be deleted after it is 
          [1mtrigger[22;0med or [1mhook[22;0med <[4mshots[24m> times.  A value of 0 makes the [1mmacro[22;0m 
          permanent.  Default: 0.  

#/def -E
#-E
  -E<[4mexpression[24m> 
          Before this [1mmacro[22;0m is tested for a [1mtrigger[22;0m ([1m-t[22;0m) or [1mhook[22;0m ([1m-h[22;0m) match, 
          <[4mexpression[24m> is evaluated; if its value is 0, the macro will not be 
          considered a match, so no [1mattributes[22;0m (-a) will be applied, and this 
          macro will not prevent matches of lower [1mpriority[22;0m (-p), and its body 
          will not be executed.  If the value of <[4mexpression[24m> is non-zero, the 
          comparison proceedes as usual.  Note: 
          * [1mpositional parameters[22;0m ([1m%n[22;0m) and [1msubexpression matches[22;0m ([1m%Pn[22;0m) are not 
          available in <[4mexpression[24m>.  
          * Remember that for every macro with a trigger and an -E expression, 
          its <[4mexpression[24m> must be evaluated for every line received.  So, you 
          should keep it simple (e.g., "enable_foo" or "[1m${world_name}[22;0m =~ 
          [1mfg_world[22;0m()").  More complex expressions should be put in the body of 
          the macro.  
          * The body of a high [1mpriority[22;0m [1mmacro[22;0m is not necessarily executed 
          before the -E expression of a lower [1mpriority[22;0m [1mmacro[22;0m is tested, so 
          <[4mexpression[24m> should not rely on values that may be changed by other 
          macros that match the same [1mtrigger[22;0m or [1mhook[22;0m.  
          Default: no [1mexpression[22;0m (i.e., always match if the [1mtrigger[22;0m or [1mhook[22;0m 
          matches).  See: [1mexpressions[22;0m.  

#/def -t
#-t
  -t<[4mpattern[24m> 
          Defines a [1mtrigger[22;0m pattern which will cause the [1mmacro[22;0m to be called 
          when it is matched by a line of text from a socket.  <[4mPattern[24m> may 
          be enclosed in quotes (", ', or `); if so, all occurances of quotes 
          and '\' within the pattern must be preceded with a '\'.  The [1mpattern[22;0m 
          matching style is determined by the [1m-m[22;0m option, or defaults to the 
          value of [1m%{matching}[22;0m.  Default: no [1mtrigger[22;0m.  See: [1mtriggers[22;0m.  

#/def -h
#-h
  -h"<[4mevent[24m>[ <[4mpattern[24m>]" 
          Specifies that the [1mmacro[22;0m will be called automatically whenever 
          <[4mevent[24m> occurs and its arguments match <[4mpattern[24m>.  <[4mEvent[24m> may be a 
          single event name or a list separated by '|'.  If <[4mpattern[24m> is 
          omitted, it will match any arguments, and the quotes may also be 
          omitted.  If quotes are used, then all occurances of quotes and '\' 
          within the option argument must be preceded with a '\'.  The [1mpattern[22;0m 
          matching style is determined by the [1m-m[22;0m option, or defaults to the 
          value of [1m%{matching}[22;0m.  Default: no [1mhook[22;0m.  See: [1mhooks[22;0m.  

#/def -b
#-b
  -b<[4mbind[24m> 
          The [1mmacro[22;0m will be called when the string <[4mbind[24m> is typed at the 
          keyboard.  Default: no binding.  The <[4mbind[24m> string may contain the 
          special codes described under "[1mbind[22;0m".  See: [1mkeys[22;0m.  

#/def -B
#-B
  -B<[4mkeyname[24m> 
          Deprecated.  The [1mmacro[22;0m will be called when the key named <[4mkeyname[24m> 
          (according to the termcap database) is typed at the keyboard.  
          Default: none.  See "[1mkeys[22;0m".  

#/def -p
#-p
  -p<[4mpri[24m> 
          Sets the [1mpriority[22;0m of the [1mmacro[22;0m's [1mtrigger[22;0m or [1mhook[22;0m to <[4mpri[24m>.  As in 
          all [1mnumeric options[22;0m, the argument to -p may be an [1mexpression[22;0m that 
          has a numeric value.  E.g.  "[1m/def[22;0m -pmaxpri ..." will set the macro's 
          priority to the value of the variable maxpri.  The [1mexpression[22;0m is 
          evaluated only once, when the macro is defined.  Default: 1.  See 
          also: [1mfall-thru[22;0m.  See: [1mpriority[22;0m, [1m/def -F[22;0m.  

#/def -c
#-c
  -c<[4mchance[24m> 
          Sets the percent probability of executing the body of a matched 
          [1mtrigger[22;0m or [1mhook[22;0m.  (The macro still counts as a match for attributes 
          and priority even if it does not execute.) Default: 100%.  

#/def -w
#-w
  -w<[4mworld[24m> 
          If the [1mmacro[22;0m has a [1mtrigger[22;0m or [1mhook[22;0m, it can be matched only by text 
          or events from <[4mworld[24m>.  Default: any world.  

#/def -T
#-T
  -T<[4mtype[24m> 
          If the [1mmacro[22;0m has a [1mtrigger[22;0m or [1mhook[22;0m, it can be matched only by text 
          or events from worlds of type <[4mtype[24m>.  (See: [1m/addworld[22;0m).  The 
          [1mpattern[22;0m matching style is determined by the [1m-m[22;0m option, or defaults 
          to the value of [1m%{matching}[22;0m.  Default: any type.  

#/def -F
#-F
  -F      [1mFall-thru[22;0m: on a [1mtrigger[22;0m or [1mhook[22;0m, allows additional matches of lower 
          [1mpriority[22;0m to be run.  Default: not [1mfall-thru[22;0m.  See: [1mpriority[22;0m 

#/def -a
#-a
  -a[ngGLAurBbhC] 
          Set [1mattribute[22;0m(s) (normal, [1mgag[22;0m, nohistory, nolog, noactivity, 
          underline, reverse, bold, bell, [1mhilite[22;0m, Color) used to display text 
          matched by the [1mtrigger[22;0m or to display the default message of a [1mhook[22;0m.  
          Default: normal.  See: [1mattributes[22;0m.  

#/def -P
#-P
  -P[<[4mpart[24m>][<[4mattr[24m>][;[<[4mpart[24m>][<[4mattr[24m>]]...  
          Define a "partial [1mhilite[22;0m".  The argument consists of a list of pairs 
          of parts (<[4mpart[24m>) and attributes (<[4mattr[24m>), separated by ';'.  When a 
          line matches the [1mregexp[22;0m [1mtrigger[22;0m of this macro, each <[4mattr[24m> is 
          applied to the corresponding <[4mpart[24m> of the line.  <[4mAttr[24m> can contain 
          any of the [1mattribute[22;0m codes "nxurBhC".  (normal, exclusive, 
          underline, reverse, bold, [1mhilite[22;0m, Color).  The value of <[4mpart[24m> 
          determines which part of the text is affected: 
          L       text to the left of the [1mregexp[22;0m match 
          R       text to the right of the [1mregexp[22;0m match 
          0       text matched by the entire [1mregexp[22;0m 
          <[4mnumber[24m>
                  text matched by the the <[4mnumber[24m>th parenthesized 
                  subexpression of the [1mregexp[22;0m.  
          If <[4mpart[24m> is omitted it defaults to 0.  If <[4mpart[24m> is a number and 
          there are multiple matches in the text, the <[4mattr[24m> will be applied 
          to all of the matches.  Implies [1m-m[22;0mregexp.  Only one [1m-P[22;0m option is 
          allowed.  See: [1mattributes[22;0m.  

#/def -f
#-f
  -f      Same as [1m-a[22;0m, for backward compatibility.  

#/def -I
#-I
#/def -i
#-i
  -i 
  -I      Makes the [1mmacro[22;0m "invisible".  Invisible [1mmacros[22;0m are not processed by 
          [1m/list[22;0m, [1m/save[22;0m, or [1m/purge[22;0m unless forced.  Default: not invisible.  

#/def -q
#-q
  -q      Makes the [1mmacro[22;0m "quiet".  If called as a [1mtrigger[22;0m, the [1mmacro[22;0m will not 
          count toward the [1mBACKGROUND[22;0m [1mhook[22;0m or the return value of [1m/trigger[22;0m.  
          If called as a [1mSEND[22;0m [1mhook[22;0m, the [1mmacro[22;0m will not prevent the sending of 
          the original input.  If called as a [1mPROMPT[22;0m [1mhook[22;0m, the [1mmacro[22;0m will not 
          remove the text from the data stream.  

#-1
  -1      Defines a one-shot.  Equivalent to "[1m-n[22;0m1".  

#
  <[4mname[24m>  The name of the [1mmacro[22;0m.  Default: no name.  Names should begin with a 
          letter, and contain letters, numbers, or '_' characters.  This is 
          not enforced, but other characters (especially '$', '/', and '%') 
          may cause unwanted interpretations during [1mexpansion[22;0m.  

  = <[4mbody[24m> 
          Text to be executed when [1mmacro[22;0m is called.  Default: no body.  

  If [1m/def[22;0m could not create a new [1mmacro[22;0m, it returns 0.  Otherwise, it returns 
  the number of the new [1mmacro[22;0m (useful with [1m/undefn[22;0m and [1m/edit[22;0m).  
  ____________________________________________________________________________

##follow
  Example: 

    [1m/def[22;0m follow = \
        [1m/def[22;0m [1m-T^tiny[22;0m [1m-mregexp[22;0m [1m-p2[22;0m [1m-t[22;0m"^[1m%{1}[22;0m goes ([a-z]*)\\\\.$$" do_follow = \
            go %%P1

  This will create a [1mmacro[22;0m named "follow".  When it is called like "/follow 
  Joe", it will execute the command 

    [1m/def[22;0m [1m-T^tiny[22;0m [1m-mregexp[22;0m [1m-p2[22;0m [1m-t[22;0m"^Joe goes ([a-z]*)\\.$" do_follow = go [1m%P1[22;0m

  Note the [1msubstitutions[22;0m that occurred: "[1m%{1}[22;0m" was replaced with the first 
  (and only) argument; each "[1m\\[22;0m" was replaced with "\"; "[1m$$[22;0m" was replaced with 
  "$"; and "[1m%%[22;0m" was replaced with "%".  

  That command, in turn, defines another [1mmacro[22;0m called "do_follow", with a 
  [1mregexp[22;0m [1mtrigger[22;0m 

    ^Joe goes ([a-z]*)\.$

  which will only match on worlds whose type matches the [1mregexp pattern[22;0m 
  "^tiny".  

  Thereafter, when a line like "Joe goes north." is received, it will match 
  the [1mtrigger[22;0m, and cause this command to be executed: 

    go north

  Note how "[1m%P1[22;0m" was substituted with the text matched by the first set of 
  parentheses (in this case, "north").  

  When writing nested [1mmacros[22;0m like this, it is usually easiest to think 
  backwards.  In this example, you would first figure out how /do_follow 
  should be defined, and then figure out how to define /follow in such a way 
  that it will define /do_follow.  
#
  ____________________________________________________________________________

  [1m/def[22;0m is sufficient to perform all the functions of the [1m/trig[22;0m, [1m/trigp[22;0m, 
  [1m/trigc[22;0m, [1m/trigpc[22;0m, [1m/gag[22;0m, [1m/hilite[22;0m, [1m/partial[22;0m, [1m/hook[22;0m, and [1m/bind[22;0m commands.  

  See: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mhooks[22;0m, [1mpriority[22;0m, [1mevaluation[22;0m, [1mattributes[22;0m, 
  [1m/undef[22;0m, [1m/undefn[22;0m, [1m/purge[22;0m, [1m/list[22;0m, [1m/save[22;0m, [1m/load[22;0m 

&/dokey

/dokey

  Usage: 

  [1m/DOKEY[22;0m <[4mname[24m>
  ____________________________________________________________________________

  Performs an action that is intended to be invoked from a [1mkeybinding[22;0m created 
  with [1m/bind[22;0m or [1m/def -b[22;0m.  Most of the actions not meaningful or useful when 
  the [1m/dokey[22;0m command is executed from the command line.  


    Name          Default binding   Action
    ----          ---------------   --------
#bs
#backspace
#bspc
    BSPC          (stty), ^H, ^?    Backspace
#bword
    BWORD         (stty), ^W        Delete previous word
#dline
    DLINE         (stty), ^U        Delete entire line
#refresh
    REFRESH       (stty), ^R        Refresh line
#lnext
    LNEXT         (stty), ^V        Ignore any binding next key might have
#

#up
    UP            (none)            Cursor up
#down
    DOWN          (none)            Cursor down
#right
    RIGHT         [1mkey_right[22;0m         Cursor right
#left
    LEFT          [1mkey_left[22;0m          Cursor left
#

#newline
    NEWLINE       ^J, ^M            Execute current line
#recallb
    RECALLB       ^P                Recall previous input line
#recallf
    RECALLF       ^N                Recall next input line
#recallbeg
    RECALLBEG     ^[<               Recall first input line
#recallend
    RECALLEND     ^[>               Recall last input line
#searchb
    SEARCHB       ^[p               Search backward in input history
#searchf
    SEARCHF       ^[n               Search forward in input history
#socketb
    SOCKETB       ^[b               Switch to previous [1msocket[22;0m
#socketf
    SOCKETF       ^[f               Switch to next [1msocket[22;0m
#dword
    DWORD         ^[d               Delete word
#del
#delete
#dch
    DCH           ^D                Delete character under cursor
#redraw
    REDRAW        ^L                Redraw screen
#clear
    CLEAR         ^[^L              Clear screen
#home
    HOME          ^A                Go to beginning of line
#end
    END           ^E                Go to end of line
#wleft
    WLEFT         ^B                Go left, to beginning of word
#wright
    WRIGHT        ^F                Go right, to end of word
#deol
    DEOL          ^K                Delete from cursor to end of line
#pause
    PAUSE         ^S                Pause screen
#page
    PAGE          [1mkey_tab[22;0m           Scroll 1 page forward ("[1mmore[22;0m")
#pageback
    PAGEBACK      (none)            Scroll 1 page backward ("[1mmore[22;0m")
#hpage
    HPAGE         ^X]               Scroll half page forward ("[1mmore[22;0m")
#hpageback
    HPAGEBACK     ^X[               Scroll half page backward ("[1mmore[22;0m")
#pgup
    PGDN          [1mkey_pgdn[22;0m          [1m/dokey_hpage[22;0m
#pgup
    PGUP          [1mkey_pgup[22;0m          [1m/dokey_hpageback[22;0m
#line
    LINE          ^[^N              Scroll forward 1 line ("[1mmore[22;0m")
#lineback
    LINEBACK      ^[^P              Scroll backward 1 line ("[1mmore[22;0m")
#flush
    FLUSH         ^[j               Jump to end of scroll buffer
#selflush
    SELFLUSH      ^[J               Show lines with [1mattributes[22;0m,
                                        and jump to end of buffer

#

  A default of "(stty)" means the key sequence is that used by your terminal 
  driver.  A default of the form "key_<[4mname[24m>" means the key named <[4mname[24m> (see 
  [1mkeybindings[22;0m).  

  The return value of [1m/dokey[22;0m depends on the action.  The movement and deletion 
  actions return the new position of the cursor; the scrolling actions return 
  the number of lines scrolled.  The return values of other actions aren't 
  very useful.  

  See "[1mkeybindings[22;0m" for a complete list of keybindings.  

  Example: 

    [1m/bind[22;0m ^B = [1m/dokey[22;0m RECALLB
    [1m/bind[22;0m ^F = [1m/dokey[22;0m RECALLF

  Then, ^B and ^F could be used to recall input backwards and forwards.  

  See: [1mkeybindings[22;0m, [1m/bind[22;0m, [1msockets[22;0m, [1mhistory[22;0m, [1m/more[22;0m 

&/echo
&/_echo
&echo()

echo()

  [1mFunction[22;0m usage: 

  [1mECHO[22;0m(<[4mtext[24m> [, <[4mattrs[24m> [, <[4minline[24m> [, <[4mdest[24m>]]])

  Command usage: 

  [1m/ECHO[22;0m [-peA] [-a<[4mattrs[24m>] [-w[<[4mworld[24m>]] <[4mtext[24m>
  [1m/_ECHO[22;0m <[4mtext[24m>
  ____________________________________________________________________________

  Displays <[4mtext[24m> on the [1mtfout stream[22;0m (i.e., the screen, usually), unless 
  otherwise redirected by options.  

  [1mOptions[22;0m and arguments: 
  command: -a<[4mattrs[24m> 
  function: <[4mattrs[24m> 
          Echo <[4mtext[24m> with the [1mattributes[22;0m given by <[4mattrs[24m>.  
  command: -p 
  function: <[4minline[24m> = "on" or 1 
          Interpet "@{<[4mattr[24m>}" strings as commands to set [1mattributes[22;0m inline.  
          "@@" strings are interpreted as "@".  "@{n}" or "@{x}" will turn 
          attributes off.  See also: [1mdecode_attr()[22;0m.  
  command: -w<[4mworld[24m> 
  function: <[4mdest[24m> = "w<[4mworld[24m>" 
          Echo <[4mtext[24m> to the <[4mworld[24m> [1mstream[22;0m instead of the default [1mtfout 
          stream[22;0m (see [1mtfio[22;0m).  If <[4mworld[24m> is blank, the [1mcurrent[22;0m world is 
          assumed.  
  command: -e 
  function: <[4mdest[24m> = "e" 
          Echo <[4mtext[24m> to the [1mtferr stream[22;0m, instead of the default [1mtfout stream[22;0m 
          (see [1mtfio[22;0m).  
  function: <[4mdest[24m> = "o" 
          Echo <[4mtext[24m> to the [1mtfout stream[22;0m (the default).  
  command: -A 
  function: <[4mdest[24m> = "a" 
          Echo <[4mtext[24m> to the [1malert stream[22;0m, instead of the default [1mtfout stream[22;0m 
          (see [1mtfio[22;0m).  

  The command form is usually more convenient, but the function form is the 
  only way to echo text with leading or trailing spaces.  Remember that "-" by 
  itself can be used to mark the end of command [1moptions[22;0m, in case <[4mtext[24m> begins 
  with "-".  

  [1m/_echo[22;0m is more efficient than [1m/echo[22;0m, so it is better for use in heavily used 
  macros that don't need all the options of [1m/echo[22;0m.  

  Example: Both of these commands 

    [1m/test[22;0m [1mecho[22;0m("@{u}Hello@{n}, world!", "BCred", 1)
    [1m/echo[22;0m -aBCred -p @{u}Hello@{n}, world!

  echo the following line, with "Hello" underlined, and the whole line bold 
  red: 

    [31m[1m[4mHello[24m, world![22m[0m

  Echoed text is not matched against [1mtriggers[22;0m.  To do that, use [1m/trigger[22;0m.  

  See: [1mattributes[22;0m, [1mworlds[22;0m, [1mfwrite()[22;0m, [1mpad()[22;0m, [1mtfio[22;0m 

&/edit

/edit

  Usage: 

  [1m/EDIT[22;0m [<[4moptions[24m>] [<[4mname[24m>] [= <[4mbody[24m>]
  ____________________________________________________________________________

  Edits a currently existing [1mmacro[22;0m or the [1mtrigger[22;0m associated with a [1mmacro[22;0m.  
  Options are described under "[1mdef[22;0m".  The name of the [1mmacro[22;0m must be specified 
  and cannot be changed, with the following two exceptions: 

  1.  The [1mmacro[22;0m name can be specified as "#<[4mnum[24m>" where <[4mnum[24m> is the number of 
  the [1mmacro[22;0m instead of the name.  A [1mmacro[22;0m number can be determined by listing 
  the [1mmacro[22;0m with [1m/list[22;0m, or from the return value of [1m/def[22;0m or [1m/edit[22;0m.  

  2.  The [1mmacro[22;0m name can be specified as "$<[4mpattern[24m>" where <[4mpattern[24m> is the 
  [1mtrigger[22;0m pattern.  You may still change the pattern if this is used to locate 
  the [1mmacro[22;0m.  

  In either case, the name cannot be changed.  It is possible to create a 
  [1mmacro[22;0m which changes the name of a [1mmacro[22;0m, if it does not have any options 
  other than a name and a body: 

  [1m/def[22;0m rename = [1m/def[22;0m [1m%2[22;0m = $[1m%1[22;0m%; [1m/undef[22;0m [1m%1[22;0m 

  How this works is discussed in the help section "[1mexpansion[22;0m".  

  Also, the [1m/edmac[22;0m command will allow you to edit an existing macro definition 
  on the command line.  

  The [1m-i[22;0m flag will be cleared automatically from the [1mmacro[22;0m if it is not 
  explicitly given to [1m/edit[22;0m.  The body may be cleared by specifiying "=" with 
  nothing after it; if "=" is not present at all, the macro's body will be 
  unchanged.  It is not possible to clear the [1m-F[22;0m option.  The [1m-w[22;0m, [1m-T[22;0m [1m-t[22;0m, and 
  [1m-h[22;0m options also can not be cleared, but their arguments can be changed.  The 
  [1m-T[22;0m, [1m-t[22;0m, and [1m-h[22;0m options will use the [1mpattern matching style[22;0m specified by the 
  [1m-m[22;0m option to the [1m/edit[22;0m command; they will [4mnot[24m inherit [1m-m[22;0m from the original 
  definition.  Any other options that are not specified with [1m/edit[22;0m will remain 
  unchanged from the original definition.  

  As of version 5.0, [1m/edit[22;0m does not renumber the macro being edited.  

  Example: 

  [1m/def[22;0m [1m-p2[22;0m [1m-t[22;0m"* has arrived." [1m-ah[22;0m greet = :greets [1m%1[22;0m
  [1m/edit[22;0m -c0 greet 

  The second command will change the probability of /greet's [1mtrigger[22;0m from 100% 
  to 0%, effectively disabling it without actually [1mundefining[22;0m it (however, 
  because it is not [1mfall-through[22;0m, it will still block other triggers of lower 
  [1mpriority[22;0m).  

  See: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mevaluation[22;0m, [1mattributes[22;0m, [1m/def[22;0m, [1m/list[22;0m, [1m/edmac[22;0m 

&/escape

/escape

  [1mFunction[22;0m usage: 

  [1mESCAPE[22;0m(<[4mmetacharacters[24m>, <[4mstring[24m>)

  Command usage: 

  [1m/ESCAPE[22;0m <[4mmetacharacters[24m> <[4mstring[24m>
  ____________________________________________________________________________

  Echoes (in command form) or returns (in [1mfunction[22;0m form) <[4mstring[24m>, with any 
  <[4mmetacharacters[24m> or '\' characters contained in <[4mstring[24m> preceded by a '\' 
  character.  

  Example: 

  [1m/def[22;0m blue = [1m/def[22;0m [1m-a[22;0mCblue [1m-t[22;0m"$([1m/escape[22;0m " [1m%*[22;0m)"
  /blue * pages, "*" 

  When the second command executes, it will [1mexpand[22;0m to: 

  [1m/def[22;0m [1m-a[22;0mCblue [1m-t[22;0m"* pages, \"*\"" 

  See: [1mevaluation[22;0m 

&/not
&/eval
&eval
&eval()

eval()

  Function usage: 

  [1meval[22;0m(<[4mtext[24m> [, <[4mlevel[24m>])

  Command usage: 

  [1m/EVAL[22;0m [-s<[4mlevel[24m>] <[4mtext[24m>
  [1m/NOT[22;0m [-s<[4mlevel[24m>] <[4mtext[24m>
  ____________________________________________________________________________

  <[4mText[24m> is [1mevaluated[22;0m as a [1mmacro[22;0m body: it goes through [1msubstitution[22;0m, and is 
  executed in a new [1mscope[22;0m.  The return value of [1meval()[22;0m and [1m/eval[22;0m is that of 
  the last command in <[4mtext[24m>; the return value of [1m/not[22;0m is the logical negation 
  of return value of the last command in <[4mtext[24m>.  

  Positional parameters ([1m%1[22;0m, etc) are inherited from the caller.  

  [1mOptions[22;0m and arguments: 
  command: -s<[4mlevel[24m> 
  function: <[4mlevel[24m> 
          Expands the <[4mtext[24m> as if [1m%{sub}[22;0m were set to <[4mlevel[24m>.  By default, 
          [1meval[22;0m expands the <[4mtext[24m> as if [1m%{sub}[22;0m were "full", and echoes it if 
          [1m%{mecho}[22;0m is not "off".  

  Note: calling [1m/eval[22;0m with arguments from a [1mtrigger[22;0m could be dangerous.  If 
  not written carefully, such a [1mtrigger[22;0m could allow anyone with access to the 
  server to gain access to your tf or shell account (if they have not been 
  [1m/restrict[22;0med).  

  Example:
  command: [1m/def[22;0m showvar = [1m/eval[22;0m [1m/echo[22;0m [1m%{1}[22;0m is %%{[1m%{1}[22;0m}. 
  command: /showvar borg
  output: borg is on. 

  "[1m/Eval[22;0m -s0" can be useful when the argument is generated by an expansion.  
  For example, if you defined "[1m/def[22;0m do = [1m%{*}[22;0m, and then called "/do /echo 
  test", it would send "/echo test" to the server instead of executing it as a 
  tf command.  But if you defined "[1m/def[22;0m do = [1m/eval[22;0m -s0 [1m%{*}[22;0m", then "/do /echo 
  test" would execute "/echo test" as a tf command.  

  Note: Instead of [1m/not[22;0m, you should normally use the "/!<[4mcommand[24m>" syntax to 
  execute "/<[4mcommand[24m>" and negate its result.  [1m/not[22;0m evaluates its arguments, 
  which may be undesirable.  

  See: [1mevaluation[22;0m 

&/exit

/exit

  Usage: 

  [1m/EXIT[22;0m [<[4mn[24m>]
  ____________________________________________________________________________

  When called directly or indirectly during a [1m/load[22;0m, [1m/exit[22;0m aborts execution of 
  all enclosing macro bodies, and aborts <[4mn[24m> (default 1) enclosing [1m/load[22;0m's.  

  When called outside of a [1m/load[22;0m, [1m/exit[22;0m has no effect.  

  Example: one way to prevent a file from being loaded more than once is to 
  put commands like these at the beginning of the file: 

    [1m/if[22;0m (<[4mvariable[24m>) [1m/exit[22;0m%; [1m/endif[22;0m
    [1m/set[22;0m <[4mvariable[24m>=1

  ...where <[4mvariable[24m> is the name of the file or some other unique name.  

  See: [1m/load[22;0m, [1m/return[22;0m, [1m/break[22;0m, [1m/loaded[22;0m 

&/export

/export

  Usage: 

  [1m/EXPORT[22;0m <[4mvariable[24m>
  ____________________________________________________________________________

  If <[4mvariable[24m> is a global [1mvariable[22;0m, it becomes an environment [1mvariable[22;0m.  
  This makes <[4mvariable[24m> available to the environment for "[1m/sh[22;0m" and "[1m/quote[22;0m !". 

  Local [1mvariables[22;0m may not be exported.  

  See: [1menvironment[22;0m, [1mvariables[22;0m, [1m/setenv[22;0m 

&/expr

/expr

  Usage: 

  [1m/EXPR[22;0m <[4m[1mexpression[22;0m[24m>
  ____________________________________________________________________________

  Evaluates <[4m[1mexpression[22;0m[24m> and prints its value.  This almost the same as "[1m/eval[22;0m 
  [1m/echo[22;0m -- $$[<[4m[1mexpression[22;0m[24m>]", except that [1m{#}[22;0m and [1mpositional parameters[22;0m ({1}, 
  etc) are not defined.  If you neet to print a value of an expression that 
  uses positional parameters, use [1m/result[22;0m or [1mecho()[22;0m.  

  Example: 

  command: [1m/set[22;0m x=4
  command: [1m/expr[22;0m x * 2
  output: 8

  See: [1mexpressions[22;0m 

&/features

/features

  Usage: 

  [1m/FEATURES[22;0m [<[4mname[24m>]
  ____________________________________________________________________________

  With no arguments, [1m/features[22;0m prints a list of optional TF features, each 
  prefixed with "+" or "-" to indicate that it is enabled or disabled, 
  respectively.  

  With a <[4mname[24m> argument, [1m/features[22;0m returns 0 or 1 if the feature <[4mname[24m> is 
  disabled or enabled, respectively, in this instance of tf.  Case is 
  insignificant in <[4mname[24m>.  

    Feature           Meaning
    -------           -------
    256colors         256 color support
    core              If tf crashes, it can dump a core file
    float             Floating point arithmetic and functions
    ftime             [1mftime[22;0m() accepts % formatting
    history           /recall and /quote #
    IPv6              Internet Protocol version 6
    locale            allow alternate character sets and date formats
                      (see: [1mlocale[22;0m)
    MCCPv1            Mud Client Compression Protocol version 1 (see: [1mmccp[22;0m)
    MCCPv2            Mud Client Compression Protocol version 2 (see: [1mmccp[22;0m)
    process           /repeat and /quote
    SOCKS             SOCKS proxy
    ssl               Secure Sockets Layer
    subsecond         time is measured with subsecond accuracy
    TZ                honors the [1mTZ[22;0m variable

  Example: 

    [1m/if[22;0m (!features("ssl")) [1m/echo[22;0m -e warning: socket is not secure%; /endif
    

&/bg
&/fg

/fg

  Usage: 

  [1m/FG[22;0m [-nsq<>l] [-c<[4mN[24m>] [<[4mworld[24m>]
  [1m/BG[22;0m
  ____________________________________________________________________________

  Bring the [1msocket[22;0m associated with <[4mworld[24m> into the [1mforeground[22;0m.  The <[4mworld[24m> 
  must already be connected with the [1m/connect[22;0m command.  Any lines that arrived 
  while the [1msocket[22;0m was in the background will be displayed or counted in the 
  [1mmore[22;0m prompt, unless the -q option is given.  

  /fg [1mOptions:[22;0m 
  -n      no [1msocket[22;0m: put all [1msockets[22;0m in the [1mbackground[22;0m.  
  -s      suppress error messages.  
  -<      previous [1msocket[22;0m in cycle.  
  ->      next [1msocket[22;0m in cycle.  
  -c<[4mN[24m>   Repeat the -< or -> option <[4mN[24m> times.  
  -l      ignored.  
  -q      quiet: jump to the last screenful of text, instead of starting at 
          the same location you were at the last time the [1msocket[22;0m was in the 
          [1mforeground[22;0m.  

  If successful, [1m/fg[22;0m returns nonzero and invokes the WORLD [1mhook[22;0m; otherwise, it 
  returns 0.  

  By default, [1m/fg[22;0m draws a dividing line between old and new text.  If you 
  would prefer no dividing line, or clearing old text, this can be configured 
  with [1m%textdiv[22;0m.  

  [1m/bg[22;0m puts all [1msockets[22;0m in the [1mbackground[22;0m, and is equivalent to [1m/fg[22;0m -n.  By 
  default, [1m/bg[22;0m is bound to the ^] [1mkey[22;0m (not ESC, which is ^[) 

  See: [1m/connect[22;0m, [1mworlds[22;0m, [1msockets[22;0m, [1m%textdiv[22;0m, [1m%textdiv_str[22;0m.  

&finger.tf
&/finger

/finger

  Usage: 

  [1m/REQUIRE[22;0m finger.tf

  [1m/FINGER[22;0m [<[4muser[24m>][@<[4mhost[24m>]
  ____________________________________________________________________________

  Like unix finger, [1m/finger[22;0m reports information about <[4muser[24m> (default: all 
  users) on <[4mhost[24m> (default: localhost), assuming that <[4mhost[24m> is running a 
  standard finger daemon.  

  See: [1m/require[22;0m, [1mworlds[22;0m, [1msockets[22;0m 

&/for

/for

  Usage: 

  [1m/FOR[22;0m <[4mvariable[24m> <[4mstart[24m> <[4mend[24m> <[4mcommands[24m>
  ____________________________________________________________________________

  The <[4mvariable[24m> will take on all numeric values between <[4mstart[24m> and <[4mend[24m>, 
  inclusive.  The <[4mcommands[24m> will be executed once for each of the values.  If 
  <[4mend[24m> is less then <[4mstart[24m>, <[4mcommands[24m> will not be executed.  

  <[4mCommands[24m> are executed in a new [1mevaluation scope[22;0m.  This means, for example, 
  that a [1m/for[22;0m called from a [1mmacro[22;0m must use "%%{...}" and "%%;" instead of 
  "%{...}" and "%;" to have the [1msubstitutions[22;0m performed when the [1m/for[22;0m is 
  [1mexpanded[22;0m instead of when the calling [1mmacro[22;0m is [1mexpanded[22;0m.  

  Example: 

  Given the definition 

    [1m/def[22;0m countdown = [1m/for[22;0m i 0 %{1} say $$[%{1} - i]
    

  then the command "/countdown 10" would cause you to execute the commands 
  "say 10", "say 9", ...  "say 0".  Note that the "%{1}" is [1msubstituted[22;0m when 
  /countdown is [1mexpanded[22;0m, and the "$$" is replaced with "$".  The resulting 
  "$[10 - i]" is [1msubstituted[22;0m when [1m/for[22;0m is [1mexpanded[22;0m.  If /countdown used 
  "$[...]" instead of "$$[...]" in the <[4mcommands[24m>, it would be [1msubstituted[22;0m 
  when /countdown is [1mexpanded[22;0m, and you would repeat "10" 11 times.  If 
  /countdown used "%%{1}" or "{1}" instead of "%{1}" inside the [1mexpression[22;0m, it 
  would not be [1msubstituted[22;0m until [1m/for[22;0m was [1mexpanded[22;0m, so it would have the value 
  of [1m/for[22;0m's first argument (the string "i", which has numeric value 0), and 
  you would end up counting down from 0 to -10.  

  See: [1m/while[22;0m 

&ftime
&ftime()

ftime()

  [1mFunction[22;0m usage: 

  [1mftime[22;0m([<[4mformat[24m> [, <[4mtime[24m>]])
  ____________________________________________________________________________

  Returns a string formatted from an absolute system time <[4mtime[24m> (obtained 
  from [1mtime()[22;0m or [1mmktime()[22;0m) according to <[4mformat[24m>.  If <[4mtime[24m> is omitted, it 
  defaults to the current time.  If <[4mtime[24m> is out of range, ftime() returns an 
  empty string and prints an error message.  If <[4mformat[24m> is omitted, it 
  defaults to [1m%time_format[22;0m.  If <[4mformat[24m> is "@", a raw system time (e.g., 
  seconds since 1970-01-01 00:00:00 UTC) will be displayed.  Otherwise, each 
  "%" in <[4mformat[24m> describes a conversion: 
  %@      raw system time, in seconds, to the nearest microsecond 
          (nonstandard) 
  %.      microseconds since last whole second (nonstandard) 
  %a      abbreviated weekday name 
  %A      full weekday name 
  %b      abbreviated month name 
  %B      full month name 
  %c      [1mlocal[22;0m time and date representation 
  %d      day of month (01-31) 
  %F      ISO 8601 date format (equivalent to "%Y-%m-%d") 
  %H      hour on 24-hour clock (00-23) 
  %I      hour on 12-hour clock (01-12) 
  %j      day of year (001-366) 
  %m      month (01-12) 
  %M      minute (00-59) 
  %p      [1mlocal[22;0m equivalent of "AM" or "PM" 
  %s      raw system time, rounded down to the nearest whole second 
          (nonstandard) 
  %S      second (00-61) 
  %T      ISO 8601 time format (equivalent to "%H:%M:%S") 
  %U      week number of year, Sunday is first day of week (00-53) 
  %w      weekeday (0-6, Sunday is 0) 
  %W      week number of year, Monday is first day of week (00-53) 
  %x      [1mlocal[22;0m date representation 
  %X      [1mlocal[22;0m time representation 
  %y      year without century (00-99) 
  %Y      year with century 
  %Z      time zone name, if any 
  %%      "%" 
  Names and conversions labeled "local" may be affected by the setting of the 
  LC_TIME [1mlocale[22;0m category.  Additional "%" conversions may be supported by 
  your system, including 3-character conversions starting with "%E" and "%O"; 
  see your system's strftime() documentation for details.  All other 
  characters in <[4mformat[24m> are copied unmodified to the result.  

  The formats "%@" and "%s.%." do not give the same results if <[4mtime[24m> is 
  negative.  

  Example:
  command: [1m/expr[22;0m [1mftime[22;0m("Today is %a %b %d", [1mtime[22;0m())
  output: Today is Thu Jul 02

  See: [1mfunctions[22;0m, [1mtime()[22;0m, [1mlocale[22;0m, [1m%TZ[22;0m, [1m%time_format[22;0m, [1m%clock_format[22;0m.  

&/gag

/gag

  Usage: 

  [1m/GAG[22;0m [<[4mpattern[24m> [=<[4mresponse[24m>]]
  ____________________________________________________________________________

  Creates a [1mmacro[22;0m which will [1mtrigger[22;0m on text matching <[4m[1mpattern[22;0m[24m> and prevent it 
  from being displayed, optionally executing <[4mresponse[24m>.  

  With no arguments, [1m/gag[22;0m sets the flag [1m%{gag}[22;0m to 1 (on).  This flag enables 
  the [1mgag[22;0m [1mattribute[22;0m on [1mtriggers[22;0m.  It is on by default.  

  The matching style of the [1mgag[22;0m [1mpattern[22;0m is determined by [1m%{matching}[22;0m.  The 
  [1mpriority[22;0m of the [1mgag[22;0m is determined by [1m%{gpri}[22;0m.  These variables are examined 
  when the [1mgag[22;0m is defined, not when it is executed.  

  [1mGagged[22;0m lines from [1mbackground[22;0m worlds will not set the activity indicator on 
  the [1mstatus line[22;0m or call the activity [1mhook[22;0m.  

  If [1m/gag[22;0m does not create a new [1mmacro[22;0m, it returns 0.  Otherwise, it returns 
  the number of the new [1mmacro[22;0m (useful in [1m/undefn[22;0m and [1m/edit[22;0m).  

  [1m/gag[22;0m <[4mpattern[24m> [= <[4mresponse[24m>]
  is equivalent to
  [1m/def[22;0m [1m-ag[22;0m [1m-t[22;0m"<[4mpattern[24m>" [= <[4mresponse[24m>]. 

  See: [1mtriggers[22;0m, [1mpatterns[22;0m, [1mevaluation[22;0m, [1m%gag[22;0m, [1m/def[22;0m, [1m/nogag[22;0m 

&download
&/getfile_MUCK
&/getfile_LP
&/getfile_UNIX
&/getfile

/getfile

  Usage: 

  [1m/REQUIRE[22;0m filexfer.tf

  [1m/GETFILE_MUCK[22;0m <[4mfile[24m> [<[4mremote-file[24m>]
  [1m/GETFILE_LP[22;0m <[4mfile[24m> [<[4mremote-file[24m>]
  [1m/GETFILE_UNIX[22;0m <[4mfile[24m> [<[4mremote-file[24m>]
  ____________________________________________________________________________

  Downloads text <[4mremote-file[24m> from a MUCK, LP, or remote UNIX shell to <[4mfile[24m> 
  on the local host.  If <[4mremote-file[24m> is omitted, <[4mfile[24m> is used as the name 
  on both ends.  Do not use "wildcard" globbing characters in the file names.  

  When using [1m/getfile_UNIX[22;0m, an extra line of garbage may appear at the 
  beginning of the downloaded file unless you first disable remote echo with 
  "stty -echo".  

  Bug: if there is a log open for the [1mcurrent[22;0m world, it will be closed by 
  [1m/getfile[22;0m.  

  See: [1m/putfile[22;0m, [1m/log[22;0m 

&/grab

/grab

  Usage: 

  [1m/GRAB[22;0m <[4mtext[24m>
  ____________________________________________________________________________

  This command puts <[4mtext[24m> into the input buffer.  It is not really useful 
  from the normal command line, but is quite useful when called from a [1mmacro[22;0m 
  to redefine [1mmacros[22;0m, or perhaps when bound to a key to speed up part of a 
  line ([1mmacros[22;0m allow you to largely do what this would allow, however).  Any 
  text already in the input buffer is discarded.  

  Example: 

    [1m/def[22;0m reedit = [1m/grab[22;0m [1m/edit[22;0m [1m%1[22;0m = $[1m%1[22;0m

  If you had previously done "[1m/def[22;0m flail = :flails at his keyboard", the 
  command "/reedit flail" would place "[1m/edit[22;0m flail = :flails at his keyboard" 
  in the input buffer and allow you to edit it using the editing keys.  See 
  "[1mevaluation[22;0m" for details on how [1mmacros[22;0m like this work.  

  See: [1m/input[22;0m, [1mgeneral[22;0m 

&oldgrep
&grep.tf

/grep

  Usage: 

  [1m/REQUIRE[22;0m grep.tf

  [1m/FGREP[22;0m <[4mpattern[24m> <[4mcommand[24m>
  [1m/GREP[22;0m <[4mpattern[24m> <[4mcommand[24m>
  [1m/EGREP[22;0m <[4mpattern[24m> <[4mcommand[24m>
  ____________________________________________________________________________

  Executes <[4mcommand[24m> and prints only the output that matches <[4mpattern[24m> (which 
  must not contain spaces).  [1m/fgrep[22;0m prints lines that [4mcontain[24m the string 
  <[4mpattern[24m>; [1m/grep[22;0m prints lines that match the [1mglob[22;0m <[4mpattern[24m>; [1m/egrep[22;0m prints 
  lines that match the [1mregexp[22;0m <[4mpattern[24m>.  

  Remember to use "*" at each end of <[4mpattern[24m> to make [1m/grep[22;0m match lines that 
  [4mcontain[24m a piece that matches the [1mglob[22;0m <[4mpattern[24m>; without the "*"s, the 
  entire line must match.  

  Example: "/fgrep T'tiny.muck' /listworlds" lists all the worlds defined with 
  the -T'tiny.muck' option.  

  See: [1mtextutil.tf[22;0m, [1m/require[22;0m, [1mpatterns[22;0m, [1mexpressions[22;0m, [1mfunctions[22;0m 

&/man
&/help

/help

  Usage: 

  [1m/HELP[22;0m [<[4mtopic[24m>]
  ____________________________________________________________________________

  Displays help on the topic specified, or displays a quick summary of 
  available topics if no topic is given.  

  The [1mvariable[22;0m [1m%TFHELP[22;0m must contain the name of the helpfile.  It is set when 
  TF is installed, and should not normally be changed.  If the helpfile or the 
  help index is not found, [1m/help[22;0m will not function.  The help file is in ASCII 
  with embedded ANSI display codes, so can be read or printed by any program 
  that can handle ANSI codes.  

  Commands are described with the format "/COMMAND arguments".  Words in all 
  caps must be spelled exactly as shown (but do not need to be capitalized).  
  Arguments in <[4mthis format[24m> (underlined angle brackets in /help, or italics 
  in HTML) can be given any value.  Arguments in [square brackets] may be 
  omitted.  The character | means "or".  For example, "[OFF|ON]" means you may 
  type "off", "on", or nothing.  

  Some help topics have punctuation in their names: variables begin with "%", 
  commands begin with "/", and functions end with "()".  A name with omitted 
  punctuation will usually match the same topic (e.g., "[1m/def[22;0m" and "[1mdef[22;0m" both 
  match the /def command topic), but sometime will match a different topic 
  (e.g., "[1m%MAIL[22;0m" matches the MAIL variable topic, but "[1mMAIL[22;0m" matches the MAIL 
  hook topic).  There are also (sub)topics for various tf syntax constructions 
  such as "[1m%{}[22;0m" and "[1m$()[22;0m".  

  Words or phrases in [1mthis format[22;0m are references to other topics.  That is, a 
  hyperlink in HTML, or something that can be used as an argument to [1m/help[22;0m in 
  [1mtf[22m.  

#html
  The help document is available in HTML form at [1mhttp://tf.tcp.com/help/[22;0m.  
#

  See: [1mindex[22;0m, [1mintro[22;0m, [1moptions[22;0m 

&/highlight
&/hilite

/hilite

  Usage: 

  [1m/HILITE[22;0m [<[4mpattern[24m> [= <[4mresponse[24m>]]
  ____________________________________________________________________________

  Creates a [1mmacro[22;0m which will [1mtrigger[22;0m on text matching <[4m[1mpattern[22;0m[24m> and display it 
  with the [1mhilite[22;0m [1mattribute[22;0m, optionally executing <[4mresponse[24m>.  

  With no arguments, [1m/hilite[22;0m sets the flag [1m%{hilite}[22;0m to 1 (on).  This flag 
  enables [1mhilite[22;0m and other [1mattributes[22;0m on [1mtriggers[22;0m.  It is on by default.  

  The [1mattribute[22;0m(s) for [1mhilite[22;0md text are determined by the [1m%{hiliteattr}[22;0m 
  [1mvariable[22;0m.  The default is bold ([1mhiliteattr[22;0m=B).  Colors are also available 
  (e.g., [1mhiliteattr[22;0m=Cgreen); see "[1mattributes[22;0m" and "[1mcolor[22;0m" for more 
  information.  

  The matching style of the [1mhilite[22;0m [1mpattern[22;0m is determined by [1m%{matching}[22;0m.  The 
  [1mpriority[22;0m of the [1mhilite[22;0m is determined by [1m%{hpri}[22;0m.  These [1mvariables[22;0m are 
  examined when the [1mhilite[22;0m is defined, not when it is executed.  

  If [1m/hilite[22;0m does not create a new [1mmacro[22;0m, it returns 0.  Otherwise, it returns 
  the number of the new [1mmacro[22;0m (useful in [1m/undefn[22;0m and [1m/edit[22;0m).  

  The [1mstandard library[22;0m also defines [1m/hilite_page[22;0m and [1m/hilite_whisper[22;0m which 
  [1mhilite[22;0m several different commonly used page and whisper formats.  

  [1m/hilite[22;0m <[4mpattern[24m> [=<[4mresponse[24m>]
  is equivalent to
  [1m/def[22;0m [1m-ah[22;0m [1m-t[22;0m"<[4mpattern[24m>" [=<[4mresponse[24m>]. 

  Example: 

    [1m/hilite[22;0m {*} tried to kill you!

  With the default settings, any line matching that pattern will appear bold.  

  To hilite messages generated by tf, see [1mhooks[22;0m.  

  See: [1mtriggers[22;0m, [1mpatterns[22;0m, [1mattributes[22;0m, [1m/def[22;0m, [1m/nohilite[22;0m, [1m/partial[22;0m 

&/histsize

/histsize

  Usage: 

  [1m/HISTSIZE[22;0m [-lig] [-w[<[4mworld[24m>]] [<[4msize[24m>]
  ____________________________________________________________________________

  [1mOptions:[22;0m 
  -l      local history 
  -i      input history 
  -g      global [1mhistory[22;0m (default) 
  -w<[4mworld[24m> 
          world history 

  If <[4msize[24m> is not given, [1m/histsize[22;0m reports the maximum number of lines that 
  can be stored in the specified [1mhistory[22;0m.  

  If <[4msize[24m> is given, [1m/histsize[22;0m changes the maximum size of the specified 
  [1mhistory[22;0m to <[4msize[24m>.  If the new size is less than the old size, the oldest 
  lines will be lost immediately.  If the new size is greater than the old 
  size, no more old lines will be lost until enough new lines are added to 
  reach the new size.  

  [1m/histsize[22;0m returns 0 for failure, and the size of the [1mhistory[22;0m otherwise.  

  The [1m%{histsize}[22;0m [1mvariable[22;0m can be used to set the default size of world 
  histories before they are created.  

  See: [1mhistory[22;0m, [1m%histsize[22;0m 

&/hook

/hook

  Usage: 

  [1m/HOOK[22;0m <[4mevent[24m>[ <[4mpattern[24m>] [= <[4mbody[24m>]
  [1m/HOOK[22;0m [OFF|ON]
  ____________________________________________________________________________

  Creates a [1mmacro[22;0m which will execute <[4mbody[24m> when <[4mevent[24m> occurs and the 
  event's arguments match the optional <[4mpattern[24m>.  The <[4mevent[24m> may be a single 
  event or a list of events separated by '|'.  If omitted, <[4mpattern[24m> will 
  default to "*".  

  [1m/hook[22;0m with no arguments displays the state of the [1m%{hook}[22;0m flag.  [1m/hook[22;0m with 
  an argument of ON or OFF sets the [1m%{hook}[22;0m flag, which determines if [1mhooks[22;0m 
  will execute their associated [1mmacros[22;0m.  

  The matching style of the [1mhook[22;0m pattern is determined by [1m%{matching}[22;0m.  This 
  [1mvariable[22;0m is examined when the [1mhook[22;0m is defined, not when it is executed.  

  Defining a [1mhook[22;0m will not replace an existing [1mhook[22;0m on the same event, but 
  rather creates an additional [1mhook[22;0m [1mmacro[22;0m on the event.  The [1mmacro[22;0m or [1mmacros[22;0m 
  to be executed are chosen by the normal [1mpriority[22;0m rules.  

  See the section "[1mhooks[22;0m" for details on [1mhook[22;0m operation, a list of event 
  names, and examples.  

  If [1m/hook[22;0m does not create a new [1mmacro[22;0m, it returns 0.  Otherwise, it returns 
  the number of the new [1mmacro[22;0m (useful in [1m/undefn[22;0m and [1m/edit[22;0m).  

  [1m/hook[22;0m <[4mevent[24m>[ <[4mpattern[24m>] [=<[4mresponse[24m>]
  is equivalent to
  [1m/def[22;0m [1m-h[22;0m"<[4mevent[24m>[ <[4mpattern[24m>]" [=<[4mresponse[24m>]. 

  Example: 

    [1m/hook[22;0m MAIL = [1m/sh[22;0m mutt

  will automatically invoke "mutt" to read mail when it arrives.  

  See: [1mhooks[22;0m, [1mmacros[22;0m, [1mevaluation[22;0m, [1mpatterns[22;0m, [1m/def[22;0m, [1m/unhook[22;0m 

&/if
&/then
&/elseif
&/else
&/endif
&/if

/if

  Usage: 

  [1m/IF[22;0m ([4mexpr[24m) [4mlist[24m [ [1m/ELSEIF[22;0m ([4mexpr[24m) [4mlist[24m ]...  [ [1m/ELSE[22;0m [4mlist[24m ] [1m/ENDIF[22;0m
  [1m/IF[22;0m [4mlist[24m [1m/THEN[22;0m [4mlist[24m [ [1m/ELSEIF[22;0m [4mlist[24m [1m/THEN[22;0m [4mlist[24m ]...  [ [1m/ELSE[22;0m [4mlist[24m ] [1m/ENDIF[22;0m
  ____________________________________________________________________________

  <[4mList[24m> is any list of commands.  The return value of a <[4mlist[24m> is the return 
  value of the last command executed in the <[4mlist[24m>.  Note that each <[4mlist[24m> 
  must be terminated by "[1m%;[22;0m".  

  <[4mexpr[24m> is any [1mexpression[22;0m, and must be surrounded by parentheses.  

  The <[4mlist[24m> or <[4mexpr[24m> following the [1m/IF[22;0m is executed or evaluated.  If the 
  result is non-zero, the next <[4mlist[24m> is executed.  Otherwise, this is 
  repeated for each [1m/ELSEIF[22;0m.  If none of the [1m/IF[22;0m or [1m/ELSEIF[22;0m <[4mlist[24m>s or <[4mexpr[24m>s 
  return non-zero, the [1m/ELSE[22;0m <[4mlist[24m> is executed if there is one.  

  The return value of the [1m/IF[22;0m...[1m/ENDIF[22;0m statement is undefined.  

  [1m/IF[22;0m (expr) body%; [1m/ENDIF[22;0m 
  is equivalent to
  [1m/IF[22;0m [1m/TEST[22;0m expr%; [1m/THEN[22;0m body%; [1m/ENDIF[22;0m 
  except that in the former, <[4mexpr[24m> does not undergo macro body [1msubstitution[22;0m.  

  When [1m/IF[22;0m is used on the command line, "[1m%;[22;0m" command separation is done even 
  if [1m%sub[22;0m=off.  Of course, full substitution will be done if [1m%sub[22;0m=full.  

  If <[4mlist[24m> is a server (mud) command, the condition being tested is whether 
  the command is sent successfully; that is, whether there is a [1mcurrent 
  socket[22;0m.  TF has no way of knowing how the server deals with the command or 
  what is considered "success" for a server command, and tf does not wait for 
  a server response which will be delayed by network latency.  So, doing 
  something like "[1m/if[22;0m rob corpse%; /then ..." will not have the effect you 
  probably want.  To achieve that effect, you should define a [1mtrigger[22;0m on each 
  of the possible server responses, before you send your command.  

  Example: 

    [1m/if[22;0m ([1mTERM[22;0m !~ "dumb") [1m/visual[22;0m on%; [1m/endif[22;0m

  will do "[1m/visual[22;0m on" if your [1m%{TERM}[22;0m is not "dumb".  

  See: [1mevaluation[22;0m, [1mexpressions[22;0m, [1m/test[22;0m, [1m/def -E[22;0m, 

&builtins
&commands
&index

index

  Commands marked with '+' are new in the current version.  Commands marked 
  with '*' have changed significantly in the current version.  

  *[1mADDWORLD[22;0m      *[1mFG[22;0m             [1mLISTVAR[22;0m        [1mREPLACE[22;0m        [1mTOGGLE[22;0m        
  *[1mAT[22;0m             [1mFINGER[22;0m         [1mLISTWORLDS[22;0m    *[1mRESTRICT[22;0m       [1mTR[22;0m            
   [1mBAMF[22;0m           [1mFOR[22;0m            [1mLOAD[22;0m           [1mRETURN[22;0m         [1mTRIG[22;0m          
   [1mBEEP[22;0m           [1mGAG[22;0m            [1mLOCALECHO[22;0m     +[1mRUNTIME[22;0m       *[1mTRIGGER[22;0m       
  *[1mBIND[22;0m           [1mGETFILE[22;0m        [1mLOG[22;0m            [1mSAVE[22;0m           [1mUNBIND[22;0m        
   [1mBREAK[22;0m          [1mGRAB[22;0m           [1mmapping[22;0m        [1mSAVEWORLD[22;0m      [1mUNDEF[22;0m         
   [1mCAT[22;0m            [1mHELP[22;0m          *[1mMORE[22;0m          *[1mSEND[22;0m           [1mUNDEFN[22;0m        
   [1mCHANGES[22;0m        [1mHILITE[22;0m         [1mNOHILITE[22;0m       [1mSET[22;0m            [1mUNDEFT[22;0m        
  *[1mCONNECT[22;0m        [1mHISTSIZE[22;0m       [1mPARTIAL[22;0m        [1mSETENV[22;0m         [1mUNHOOK[22;0m        
   [1mDC[22;0m             [1mHOOK[22;0m          *[1mPASTE[22;0m          [1mSH[22;0m             [1mUNSET[22;0m         
  *[1mDEF[22;0m            [1mIF[22;0m            *[1mPS[22;0m             [1mSHIFT[22;0m          [1mUNTRIG[22;0m        
  *[1mDOKEY[22;0m          [1mINPUT[22;0m          [1mPURGE[22;0m          [1mspelling[22;0m       [1mUNWORLD[22;0m       
  *[1mECHO[22;0m           [1mKILL[22;0m           [1mPURGEWORLD[22;0m     [1mSUB[22;0m            [1mVERSION[22;0m       
  *[1mEDIT[22;0m           [1mLCD[22;0m            [1mPUTFILE[22;0m        [1mSUBSTITUTE[22;0m     [1mWATCHDOG[22;0m      
   [1mESCAPE[22;0m         [1mLET[22;0m           *[1mQUIT[22;0m           [1mSUSPEND[22;0m        [1mWATCHNAME[22;0m     
  *[1mEVAL/NOT[22;0m      +[1mLIMIT[22;0m         *[1mQUOTE[22;0m          [1mTELNET[22;0m         [1mWHILE[22;0m         
   [1mEXIT[22;0m           [1mlist commands[22;0m  [1mquoter.tf[22;0m      [1mTEST[22;0m           [1mWORLD[22;0m         
   [1mEXPORT[22;0m         [1mLIST[22;0m          *[1mRECALL[22;0m        *[1mtextutil.tf[22;0m                  
   [1mEXPR[22;0m          *[1mLISTSOCKETS[22;0m    [1mRECORDLINE[22;0m     [1mTICK[22;0m                         
  +[1mFEATURES[22;0m       [1mLISTSTREAMS[22;0m   *[1mREPEAT[22;0m         [1mTIME[22;0m                         

  See also: [1mintro[22;0m, [1mtopics[22;0m 

&/input

/input

  Usage: 

  [1m/INPUT[22;0m <[4mtext[24m>
  ____________________________________________________________________________

  Enters <[4mtext[24m> into the input buffer as if it had been typed at the keyboard, 
  without deleting the current contents of the input buffer.  

  [1m/Input[22;0m is perhaps most useful in combination with [1m/bind[22;0m, to create short key 
  sequences that expand to longer text.  For example, if you have this 
  binding: 

  [1m/bind[22;0m ^[oj = [1m/input[22;0m OliverJones 

  and then type "page ^[oj = snausages!" at the keyboard, it will appear in 
  the input window as "page OliverJones = snausages!".  

  See: [1m/bind[22;0m, [1m/grab[22;0m 

&/ismacro

/ismacro

  Usage: 

  [1m/ISMACRO[22;0m <[4mmacro-options[24m>
  ____________________________________________________________________________

  If <[4mmacro-options[24m> matches one or more existing [1mmacros[22;0m, [1m/ismacro[22;0m returns the 
  number of the last matching [1mmacro[22;0m; otherwise, [1m/ismacro[22;0m returns 0.  
  <[4mMacro-options[24m> may include any of the options accepted by [1m/list[22;0m.  If -m is 
  not specified, [1m%{matching}[22;0m is used.  

  Example: 

    [1m/if[22;0m /!ismacro -b"^X*"%; [1m/then[22;0m [1m/bind[22;0m ^X = [1m/foobar[22;0m%; [1m/endif[22;0m

  See: [1m/list[22;0m, [1mmacros[22;0m 

&/isvar

/isvar

  Usage: 

  [1m/ISVAR[22;0m <[4mname[24m>
  ____________________________________________________________________________

  Returns 1 if [1mvariable[22;0m <[4mname[24m> is set, 0 otherwise.  

  Example: 

    [1m/if[22;0m (!isvar('LANG')) [1m/set[22;0m LANG=en_US%; [1m/endif[22;0m

  See: [1m/listvar[22;0m, [1mvariables[22;0m 

&/kill

/kill

  Usage: 

  [1m/KILL[22;0m <[4mpid[24m>... 
  ____________________________________________________________________________

  For each <[4mpid[24m> given, [1m/kill[22;0m terminates the corresponding [1mprocess[22;0m ([1m/quote[22;0m or 
  [1m/repeat[22;0m command).  The pid of a [1mprocess[22;0m can be determined from the return 
  value of the [1m/quote[22;0m or [1m/repeat[22;0m, the [1m/ps[22;0m command, or a PROCESS [1mhook[22;0m.  

  Bug: [1m/kill[22;0m on a pending [1m/quote[22;0m ! will block until the shell process exits.  
  The block can be broken with an interrupt.  

  See: [1mprocesses[22;0m, [1m/quote[22;0m, [1m/repeat[22;0m, [1m/ps[22;0m 

&/cd
&/pwd
&/lcd

/lcd

  Usage: 

  [1m/LCD[22;0m [<[4mdir[24m>]
  [1m/CD[22;0m [<[4mdir[24m>]
  [1m/PWD[22;0m
  ____________________________________________________________________________

  [1m/lcd[22;0m and [1m/cd[22;0m change to a new working directory.  If <[4mdir[24m> is omitted with 
  [1m/lcd[22;0m, the current directory is displayed (if supported on your system).  If 
  <[4mdir[24m> is omitted with [1m/cd[22;0m, [1m%{HOME}[22;0m is assumed.  

  The <[4mdir[24m> name is expanded as described under "[1mfilenames[22;0m".  

  [1m/pwd[22;0m displays the current working directory (if supported on your system).  

&/let

/let

  Usage: 

  [1m/LET[22;0m <[4mname[24m>=<[4mvalue[24m>
  [1m/LET[22;0m <[4mname[24m> <[4mvalue[24m>
  ____________________________________________________________________________

  Assigns <[4mvalue[24m> to [1mvariable[22;0m <[4mname[24m> in the current local [1mscope[22;0m.  Can only be 
  used during [1mmacro[22;0m [1mexpansion[22;0m.  The [1mvariable[22;0m will be destroyed when the [1mscope[22;0m. 
  in which it was created exits.  

  Note to lisp users: this is nothing like lisp's let.  

  See: [1m/set[22;0m, [1mvariables[22;0m 

&/limit
&/relimit
&/unlimit

/limit

  Usage: 

  [1m/LIMIT[22;0m [-v] [-a] [-m<[4mstyle[24m>] [<[4mpattern[24m>]
  [1m/RELIMIT[22;0m
  [1m/UNLIMIT[22;0m
  ____________________________________________________________________________

  /Limit redraws the window, showing only lines that match <[4m[1mpattern[22;0m[24m>.  It is 
  then possible to scroll forward and backward within the "limited" window.  
  The limit affects only the current screen, and stays in effect until 
  [1m/unlimit[22;0m is called.  

  /Limit [1moptions:[22;0m 
  -v      show only lines that [4mdon't[24m match <[4m[1mpattern[22;0m[24m> 
  -a      show only lines that have attributes 
  -m<[4mstyle[24m> 
          use matching style ([1msimple[22;0m, [1mglob[22;0m, or [1mregexp[22;0m), instead of the default 
          [1m%{matching}[22;0m.  

  If <[4m[1mpattern[22;0m[24m> is given, only lines in the given range that match <[4m[1mpattern[22;0m[24m> 
  will be recalled.  The matching style is determined by the -m option if 
  given, [1m%{matching}[22;0m otherwise.  By default, the @more [1mstatus field[22;0m does not 
  count lines that are omitted by [1m/limit[22;0m.  

  With no options or arguments, [1m/limit[22;0m returns 1 if a limit is in effect, 0 if 
  not.  

  [1m/unlimit[22;0m disables the [1m/limit[22;0m so all lines are displayed.  

  During [1m/limit[22;0m, scrolling to any point, including the bottom, results in a 
  More prompt that shows the number of lines (possibly 0) below the status 
  line.  In this state, [1m/unlimit[22;0m will leave the bottom visible line where it 
  is, and redraw the unlimited lines above it.  Thus, you can use [1m/limit[22;0m to 
  find a line you are interested in, use the scrolling keys to position that 
  line at the bottom of the window, then [1m/unlimit[22;0m to see the context of that 
  line.  But if you attempt to scroll [4mpast[24m the bottom during [1m/limit[22;0m, the More 
  prompt changes to "LIMIT ON"; in this state, [1m/unlimit[22;0m will redraw with the 
  previously invisible last line at the bottom of the screen.  

  [1m/relimit[22;0m repeats the last [1m/limit[22;0m.  

  The default keybinding ^[L toggles the last limit off and on.  

  See: [1m/recall[22;0m 

&/listbind
&/listdef
&/listgag
&/listhilite
&/listhook
&/listtrig
&/list

/list

  Usage: 

  [1m/LIST[22;0m [-s] [<[4mmacro-options[24m>] [<[4mname[24m>] [= <[4mbody[24m>]
  ____________________________________________________________________________

  Lists [1mmacros[22;0m having all the specified options.  Except for "-s", each option 
  is compared against a [1mmacro[22;0m's option, and the [1mmacro[22;0m selected only if the 
  options match.  Omitted options are "don't care", and will not be used in 
  the comparison.  Thus, with no arguments, [1m/list[22;0m will list all non-[1minvisible[22;0m 
  [1mmacros[22;0m.  

#list options
  [1mOptions:[22;0m 
  -s      List [1mmacros[22;0m in short format.  
  -S      Sort [1mmacros[22;0m by name.  
  -m<[4mmatching[24m> 
          Determines matching style used for comparison of string fields 
          ([1mtrigger[22;0m, keybinding, keyname, [1mhook[22;0m, worldtype, name, and body).  
          This is [4mnot[24m compared against the -m options of [1mmacros[22;0m.  If omitted, 
          the style is determined by [1m%{matching}[22;0m.  
  -t<[4mpattern[24m> 
  -b<[4mpattern[24m> 
  -B<[4mpattern[24m> 
  -E<[4mpattern[24m> 
  -T<[4mpattern[24m> 
          Matches [1mmacros[22;0m with a corresponding [1m/def[22;0m option whose 
          option-argument matches <[4mpattern[24m>.  <[4mpattern[24m>.  An option with no 
          pattern matches all [1mmacros[22;0m that have that option, regardless of the 
          value of the option-argument.  A "{}" [1mglob[22;0m pattern or "^$" [1mregexp[22;0m 
          can be used to match [1mmacros[22;0m that [4mdon't[24m have that option, 
  -h["<[4mevent[24m>[ <[4mpattern[24m>]"] 
          Matches [1mmacros[22;0m with [1mhooks[22;0m matching <[4mevent[24m> and <[4mpattern[24m>.  "-h" by 
          itself matches all non-empty [1mhooks[22;0m; "-h0" matches only [1mmacros[22;0m 
          without [1mhooks[22;0m.  
  -a<[4mattrs[24m> 
          Matches [1mmacros[22;0m having one or more of the display [1mattributes[22;0m in 
          <[4mattrs[24m>.  
  -P<[4mpart[24m><[4mattrs[24m> 
          Matches [1mmacros[22;0m having a [1m-P[22;0m<[4mpart[24m> with one or more of the display 
          [1mattributes[22;0m in <[4mattrs[24m>.  
  -i      Matches invisible [1mmacros[22;0m as well as normal [1mmacros[22;0m.  
  -I      Matches only invisible [1mmacros[22;0m.  
  <[4mname[24m>  A pattern that [1mmacro[22;0m names must match.  The [1mglob[22;0m pattern "{}" or 
          [1mregexp[22;0m "^$" will match only [1mmacros[22;0m without names.  If <[4mname[24m> starts 
          with "#", it is compared against macro numbers, instead of as a 
          pattern against macro names.  
  = <[4mbody[24m> 
          <[4mbody[24m> is a pattern that macro bodies must match.  The [1mglob[22;0m pattern 
          "{}", or the [1mregexp[22;0m "^$" or the [1msimple pattern[22;0m "" will match 
          bodyless [1mmacros[22;0m only.  
#

  Other options allowed by [1m/def[22;0m may be used with [1m/list[22;0m, and are compared 
  directly to macros.  

  The return value of [1m/list[22;0m is the number of the last [1mmacro[22;0m listed, or 0 if no 
  [1mmacros[22;0m were listed (because of error or none matched the specified options). 

  The standard library also defines the [1mmacros[22;0m [1m/listbind[22;0m, [1m/listdef[22;0m, [1m/listgag[22;0m, 
  [1m/listhilite[22;0m, [1m/listfullhilite[22;0m, [1m/listpartial[22;0m, [1m/listhook[22;0m, and [1m/listtrig[22;0m, which 
  list [1mmacros[22;0m of the appropriate type.  

  Example: 

      [1m/list[22;0m -mregexp -n0 -t -aurh ^foo =

  will list all [1mmacros[22;0m whose names begin with "foo"; have a [1mtrigger[22;0m; are not 
  multi-shots; have any of the underline, reverse, or [1mhilite[22;0m [1mattributes[22;0m; and 
  have an empty body.  

  To list functions for named keys, try "[1m/list[22;0m -i key_*".  

  See: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mattributes[22;0m, [1mlibrary[22;0m, [1m/def[22;0m 

&/car
&/cdr
&/cadr
&/cddr
&/caddr
&/cdddr
&/length
&/reverse
&/mapcar
&/maplist
&/remove
&/unique
&lisp
&lisp.tf
&list
&list commands

list commands

  Usage: 

  [1m/REQUIRE[22;0m lisp.tf
  ____________________________________________________________________________

  These commands operate on lists of words, and are similar to those in lisp.  
  They all give their results with [1m/echo[22;0m, and are intended to be used in 
  [1m$(...) command substitution[22;0m to capture the result.  

  [1m/car[22;0m <[4mlist[24m> 
          Echo first word.  (Same as [1m/first[22;0m).  
  [1m/cdr[22;0m <[4mlist[24m> 
          Echo all words after first.  (Same as [1m/rest[22;0m).  
  [1m/cadr[22;0m <[4mlist[24m> 
          Echo second word.  
  [1m/cddr[22;0m <[4mlist[24m> 
          Echo all words after second.  
  [1m/caddr[22;0m <[4mlist[24m> 
          Echo third word.  
  [1m/cdddr[22;0m <[4mlist[24m> 
          Echo all words after third.  

  [1m/length[22;0m <[4mlist[24m> 
          Echo number of words in <[4mlist[24m>.  

  [1m/reverse[22;0m <[4mlist[24m> 
          Reverse the order of the words in <[4mlist[24m>.  

  [1m/mapcar[22;0m <[4mcmd[24m> <[4mlist[24m> 
          Execute "<[4mcmd[24m> <[4mword[24m>" for each word in <[4mlist[24m>.  
  [1m/maplist[22;0m <[4mcmd[24m> <[4mlist[24m> 
          Execute "<[4mcmd[24m> <[4mlist[24m>" repeatedly, removing the first word from 
          <[4mlist[24m> each time, until <[4mlist[24m> is empty.  

  [1m/remove[22;0m <[4mword[24m> <[4mlist[24m> 
          Echo <[4mlist[24m> with all occurrences of <[4mword[24m> removed.  

  [1m/unique[22;0m <[4mlist[24m> 
          Remove all duplicate words from <[4mlist[24m>.  Note: [1m/unique[22;0m is very slow 
          on long lists.  

  See: [1m/nth[22;0m 

&/listsockets

/listsockets

  Usage: 

  [1m/LISTSOCKETS[22;0m [-sn] [-m<[4mstyle[24m>] [-S<[4mfield[24m>] [-T<[4mtype[24m>] [<[4mname[24m>]
  ____________________________________________________________________________

  Lists the [1msockets[22;0m to which TinyFugue is connected.  

  [1mOptions[22;0m and arguments: 
  -s      short form, list only world names 
  -n      print host and port in numeric form 
  -m<[4mstyle[24m> 
          Use <[4mstyle[24m> for [1mpattern matching[22;0m in other options (default: 
          [1m%{matching}[22;0m).  
  -S<[4mfield[24m> 
          Sort sockets by <[4mfield[24m>.  <[4mField[24m> may be "name", "type", 
          "character", "host", "port", "lines", "idle", or "-" (don't sort; 
          this is the default).  Only the first character is necessary.  
  -T<[4mtype[24m> 
          list only worlds with a type matching the [1mpattern[22;0m <[4mtype[24m>.  
  <[4mname[24m>  list only worlds with a name matching the [1mpattern[22;0m <[4mname[24m>.  

  The output will look something like this (unless the -s option is given): 

       LINES IDLE TYPE      NAME            HOST                       PORT
     10+  48  13h tiny.muck Cave            tcp.com                    2283
  *  foregnd   1m tiny.mush DeepSeas        muds.okstate.edu           6250
           0   7s telnet    whitehouse.gov, whitehouse.gov             smtp
   ?       0  15s tiny      SlowMUD         slow.machine.com           4201

  The columns and their meanings are: 
  unlabeled first column 
          "*" marks the [1mcurrent[22;0m socket.  
  unlabeled second column 
          the state of the [1msocket[22;0m is one of: 
          !       dead 
          ?       hostname lookup or network connection is incomplete 
          C/c     an established normal connection 
          S/s     an established connection currently in telnet subnegotiation 
          X/x     an established [1mSSL[22;0m connection 
          O       an open [1mconnectionless[22;0m socket 
          A lowercase state character indicates the connection is using [1mMCCP[22;0m.  
  unlabeled third column 
          "P" if the connection is [1mproxied[22;0m 
  LINES   for a [1mbackground[22;0m [1msocket[22;0m, the number of old (seen) and new (unseen) 
          lines past the bottom of the [1msocket[22;0m's window (ignoring any [1mlimit[22;0m 
          that may be in effect on that window); or, "foregnd" for a 
          [1mforeground[22;0m [1msocket[22;0m.  
  IDLE    how long since the last text was received on the [1msocket[22;0m.  
  TYPE    the type of the world (set with [1m/addworld[22;0m -T).  
  NAME    the name of the world associated with the [1msocket[22;0m.  
  HOST    the host to which the [1msocket[22;0m is connected.  
  PORT    the port to which the [1msocket[22;0m is connected.  

  The return value of [1m/listsockets[22;0m is the number of sockets listed.  

  See: [1msockets[22;0m, [1m%background[22;0m, [1m/connect[22;0m, [1m/fg[22;0m, [1mnactive()[22;0m, [1midle()[22;0m 

&/liststreams

/liststreams

  Usage: 

  [1m/LISTSTREAMS[22;0m
  ____________________________________________________________________________

  Lists [1mtfio streams[22;0m opened by [1mtfopen()[22;0m.  The [1mtfin[22;0m, [1mtfout[22;0m, and [1mtferr[22;0m [1mstreams[22;0m 
  are not included.  

  The columns and their meanings are: 
  HANDLE  The handle returned by [1mtfopen()[22;0m.  
  MODE    The mode argument given to [1mtfopen()[22;0m.  
  FLUSH   Whether automatic flushing is enabled.  See [1mtfflush()[22;0m.  
  NAME    The name argument, if any, given to [1mtfopen()[22;0m.  Files of mode "q" do 
          not need a name, but you may wish to give them one anyway so it 
          appears here.  

  The return value of [1m/liststreams[22;0m is the number of open streams listed.  

  See: [1mtfio[22;0m 

&/listvar

/listvar

  Usage: 

  [1m/LISTVAR[22;0m [-m<[4mmatching[24m>] [-gxsv] [<[4mname[24m> [<[4mvalue[24m>]]
  ____________________________________________________________________________

  [1mOptions:[22;0m 
  -m<[4mmatching[24m> 
          Determines matching style used for comparison of <[4mname[24m> and <[4mvalue[24m>. 
          If omitted, the style is determined by [1m%{matching}[22;0m.  
  -g      List only global (unexported) variables.  
  -x      List only variables that are exported to the environment.  
  -s      Short format: list variable names only.  
  -v      List values only.  

  [1m/Listvar[22;0m lists values of [1mvariables[22;0m whose name and value match <[4mname[24m> and 
  <[4mvalue[24m> according to <[4mmatching[24m>.  If neither -g nor -x is given, global and 
  environment variables are listed.  

  The return value of [1m/listvar[22;0m is the number of variables listed.  

  See: [1mvariables[22;0m, [1m/set[22;0m, [1m/setenv[22;0m, [1m/export[22;0m, [1m/let[22;0m, [1m/unset[22;0m 

&/listworlds

/listworlds

  Usage: 

  [1m/LISTWORLDS[22;0m [-cus] [-m<[4mstyle[24m>] [-S<[4mfield[24m>] [-T<[4mtype[24m>] [<[4mname[24m>]
  ____________________________________________________________________________

  Lists world definitions.  

  [1mOptions[22;0m and arguments: 
  -m<[4mstyle[24m> 
          Use <[4mstyle[24m> for [1mpattern matching[22;0m of <[4mtype[24m> and <[4mname[24m> patterns.  
          (default: [1m%{matching}[22;0m).  
  -s      Display short format (world names only).  
  -c      Display command format (including passwords).  
  -S<[4mfield[24m> 
          Sort worlds by <[4mfield[24m>.  <[4mField[24m> may be "name" (the default), 
          "type", "character", "host", "port", or "-" (don't sort).  Only the 
          first character is necessary.  
  -u      Include unnamed temporary worlds in the listing.  
  -T<[4mtype[24m> 
          List only worlds with a type matching the [1mpattern[22;0m <[4mtype[24m>.  
  <[4mname[24m>  List only worlds with a name matching the [1mpattern[22;0m <[4mname[24m>.  

  If neither -s nor -c are given, a table format is used, and passwords are 
  not shown.  The return value of [1m/listworlds[22;0m is the number of worlds listed.  

  See: [1mworlds[22;0m, [1mpatterns[22;0m 

&/loadbind
&/loaddef
&/loadgag
&/loadhilite
&/loadtrig
&/loadhook
&/loadworld
&/require
&/loaded
&/load

/load

  Usage: 

  [1m/LOAD[22;0m [-q] <[4mfile[24m>
  [1m/REQUIRE[22;0m [-q] <[4mfile[24m>

  [1m/LOADED[22;0m <[4mtoken[24m>
  ____________________________________________________________________________

  [1m/Load[22;0m and [1m/require[22;0m both read and execute commands from <[4mfile[24m>.  They are 
  identical, except that if <[4mfile[24m> calls [1m/loaded[22;0m and has already been read 
  once, [1m/require[22;0m will not read it again (but the LOAD message/[1mhook[22;0m will still 
  be displayed/called).  

  "[1m/Loaded[22;0m <[4mtoken[24m>" should be the first command in a file that is designed to 
  be loaded only once with [1m/require[22;0m.  <[4mToken[24m> should be a string that does not 
  contain space or [1mglob[22;0m metacharacters, and is different than the token used 
  by any other [1m/loaded[22;0m call.  The file's full name is usually a good choice 
  for <[4mtoken[24m>.  

  [1mOptions:[22;0m 
  -q      Do not echo the "% Loading commands from <[4mfile[24m>" message in this 
          [1m/load[22;0m call or any [1m/load[22;0m calls in <[4mfile[24m>.  (but the [1mLOAD hook[22;0m will 
          still be called).  

  The file may contain any legal TinyFugue commands.  Blank lines and lines 
  beginning with ';' or '#' are ignored.  Any leading whitespace on a line is 
  stripped.  Any line ending in '\' will have the following line joined to it 
  (after leading spaces are stripped).  A '%' preceding a '\' eliminates its 
  special meaning.  

  The <[4mfile[24m> name is expanded as described under "[1mfilenames[22;0m".  

  If the [1mCOMPRESS_SUFFIX[22;0m and [1mCOMPRESS_READ[22;0m [1mmacros[22;0m are defined, the file will 
  be automatically uncompressed if needed.  

  If the expanded filename is not an absolute path name, TF will search first 
  in the current directory (which can be changed with [1m/lcd[22;0m), and then in the 
  list of directories named by [1m%{TFPATH}[22;0m.  If [1m%{TFPATH}[22;0m is blank or unset, the 
  single directory named by [1m%{TFLIBDIR}[22;0m is used.  

  A [1m/load[22;0m may be aborted early with the [1m/exit[22;0m command in the file.  

  Loaded files may be given any name, but names ending in ".tf" are 
  recommended.  

  [1m/Load[22;0m and [1m/require[22;0m return 1 if successful (for [1m/require[22;0m, this includes not 
  needing to read the file), or 0 if not successful.  [1m/Loaded[22;0m does not return 
  if the file that calls it has already been loaded.  

  The standard [1mmacro[22;0m library also defines the commands [1m/loaddef[22;0m, [1m/loadbind[22;0m, 
  [1m/loadhilite[22;0m, [1m/loadgag[22;0m, [1m/loadtrig[22;0m, [1m/loadhook[22;0m, and [1m/loadworld[22;0m.  These [1mmacros[22;0m 
  will load from a [1mdefault file[22;0m if no file is specified.  

  See: [1mmacros[22;0m, [1mlibrary[22;0m, [1m/exit[22;0m, [1m/def[22;0m, [1m/save[22;0m, [1m/lcd[22;0m, [1mfilenames[22;0m, [1mcompression[22;0m 

&%always_echo
&always_echo
&/localecho

/localecho

  Usage: 

  [1m/LOCALECHO[22;0m [ON|OFF]
  ____________________________________________________________________________

  [1m/Localecho[22;0m with no arguments returns 1 if local echoing is enabled for the 
  [1mcurrent socket[22;0m, 0 otherwise.  TF echoes its input by default, unless the 
  server has negotiated otherwise.  

  [1m/Localecho[22;0m with an argument attempts to enable or disable echoing for the 
  [1mcurrent socket[22;0m.  If the server is not known to support TELNET protocol, 
  "[1m/localecho[22;0m [ON|OFF]" does nothing, and returns 0.  ON tells the server DONT 
  ECHO; if the server acknowledges (as it must according to TELNET protocol), 
  tf will echo its own input.  OFF tells the server to DO ECHO; if the server 
  acknowledges, tf will not echo its own input, expecting the server to do it. 
  The actual change of state takes place after the server agrees, which may be 
  delayed by network latency ("netlag").  

  Note that tf does not transmit input until a newline is pressed, and the 
  server can not echo it until it is received; so, with [1m/localecho[22;0m off, your 
  typing will not be visible until you hit return, at which time the server 
  may echo back the entire line.  

  Some mud servers use the ECHO option to disable local echo during password 
  entry.  Telnet servers, however, try to disable local echo for the entire 
  session, which would interfere with many useful tf features.  Hooks defined 
  in the [1mstandard library[22;0m use [1m/localecho[22;0m to override the telnet server 
  automatically.  

  [1m/Localecho[22;0m is intended to be called by library macros, and should not need 
  to be called by the user.  [1m/Localecho[22;0m obsoletes %{always_echo}.  

  The TELNET ECHO option is defined in RFC 857.  

  See: [1mprompts[22;0m, [1m%telopt[22;0m, [1m/telnet[22;0m 

&/log

/log

  Usage: 

  [1m/LOG[22;0m [-ligw[<[4mworld[24m>]] [OFF|ON|<[4mfile[24m>]
  ____________________________________________________________________________

  Enables or disables logging, or lists currently open log files.  An [-ligw] 
  option specifies which [1mhistory[22;0m is used (only one can be used).  The 
  [OFF|ON|<[4mfile[24m>] argument specifies what action is taken on that [1mhistory[22;0m.  

  [1mOptions:[22;0m 
  -w<[4mworld[24m> 
          Output from <[4mworld[24m> only.  
  -w      Output from the [1mcurrent[22;0m world.  
  -l      Local output (i.e., output generated by TF).  
  -i      Keyboard input.  
  -g      Global output (all worlds and local TF output).  

  Arguments: 
  OFF     Disable specified log, or all logs if unspecified.  
  ON      Log to [1m${LOGFILE}[22;0m; -g is assumed if -ligw not given.  
  <[4mfile[24m>  Log to <[4mfile[24m>; -g is assumed if -ligw not given.  
  (none)  With no option, lists all open logs.  
  (none)  With an -ligw option, same as "ON".  

  When logging is enabled for a [1mhistory[22;0m, lines that are normally recorded in 
  that [1mhistory[22;0m are also appended to the log file (unless the line has the "L" 
  nolog [1mattribute[22;0m).  The previously existing contents of the file, if any, are 
  not affected.  

  It is possible to have multiple log files open simultaneously.  It is also 
  possible to have several types of output go to the same log file, by using 
  several [1m/log[22;0m commands.  For example, 

    [1m/log[22;0m -i tt.log
    [1m/log[22;0m -wTT tt.log
    [1m/log[22;0m -g on

  will send input from the keyboard and output from the world TT to the file 
  "tt.log", and also send all (global) output to the file named by the [1mLOGFILE[22;0m 
  macro.  

  This example logs the [1mcurrent[22;0m world's output to a file whose name contains 
  the world's name and today's date: 

    [1m/eval[22;0m [1m/log[22;0m -w [1m${world_name}[22;0m.$[[1mftime[22;0m("%F")]
    

  The functions of the [1m/logme[22;0m command in older versions of TF can be performed 
  with [1m/log[22;0m -i.  

  Wrapping will be done in the log file only if the [1m%{wraplog}[22;0m [1mvariable[22;0m is 
  "on".  

  Logging is disabled by default.  The default value of [1m${LOGFILE}[22;0m is 
  "tiny.log".  

  Note: the natural logarithm function was renamed from log() to ln() in 
  version 5.0, to avoid confusion with /log.  

  See: [1m%wraplog[22;0m, [1mhistory[22;0m, [1mnlog()[22;0m [1mfwrite()[22;0m 

&/logme

/logme

  Obsolete.  See "[1mlog[22;0m".  

&/map
&/mark
&/path
&/revert
&/savepath
&/unpath
&/unmark
&/dopath
&mapping

mapping

  Usage: 

  [1m/REQUIRE[22;0m map.tf

  [1m/MARK[22;0m <[4mdir[24m>
  [1m/UNMARK[22;0m
  [1m/PATH[22;0m
  [1m/RETURN[22;0m
  [1m/MAP[22;0m
  [1m/UNPATH[22;0m
  [1m/SAVEPATH[22;0m <[4mname[24m>
  [1m/DOPATH[22;0m <[4mpath[24m>
  ____________________________________________________________________________

  These commands, similar to those in tintin, help keep track of sequences of 
  directions between two locations on a mud.  When mapping is enabled with 
  [1m/mark[22;0m, all mud movement commands (n, s, e, w, ne, sw, nw, se, u, d) that you 
  type are recorded in the "current path".  

  [1m/mark[22;0m clears the current path and starts recording your movement.  

  [1m/unmark[22;0m disables map recording (but does not clear the current path).  

  [1m/path[22;0m prints the current recorded path.  

  [1m/revert[22;0m "undoes" the last movement by deleting it from the path and 
  executing the opposite movement command.  (This was called "/return" prior 
  to version 4.0).  

  [1m/map[22;0m adds <[4mdir[24m> to the current path as if you had actually gone in that 
  direction.  

  [1m/unpath[22;0m deletes the last movement from the path (but does not move you to 
  your previous position) 

  [1m/savepath[22;0m [1mdefines[22;0m a [1mmacro[22;0m named <[4mname[24m> that will execute the movements in 
  the currently defined path.  (To save this [1mmacro[22;0m to a file, use "[1m/save[22;0m [-a] 
  <[4mfile[24m> <[4mname[24m>").  

  [1m/dopath[22;0m executes a <[4mpath[24m>.  <[4mPath[24m> must be a space-separated list of 
  movement commands with optional repeat counts.  For example, "[1m/dopath[22;0m 10 n e 
  d 2 w" will execute "n" 10 times, "e" once, "d" once, and "w" twice.  

  See: [1m/require[22;0m, [1mspeedwalk[22;0m 

&scroll
&pager
&--more--
&--More--
&/more

/more

  Usage: 

  [1m/MORE[22;0m [OFF|ON]
  ____________________________________________________________________________

  Sets the value of the [1m%{more}[22;0m flag.  If the [1m%{more}[22;0m flag is ON when the 
  screen or output window fills up, output will stop, and a "More" prompt will 
  be displayed.  With the default keybindings, TAB will scroll one screenful, 
  PgDn and PgUp will scroll a half screen forward or backward, ^[^N and ^[^P 
  will scroll one line forward or backward, and ^[j will Jump to the last 
  screenful.  

  Regardless of the setting of the [1m%more[22;0m flag, you can use "[1m/dokey[22;0m pause" (^S) 
  at any time to pause the screen immediately, or use any of the scrolling 
  commands to scroll backward and forward.  After doing so, the "more" prompt 
  will remain until you reach the bottom line again; after that point, newly 
  displayed lines will obey the [1m%more[22;0m flag normally.  

  In [1mvisual mode[22;0m, with the default [1mstatus bar[22;0m settings, the More prompt 
  displays the number of old lines (i.e., how far you have scrolled backwards) 
  and the number of new lines you haven't had a chance to see yet (i.e.  lines 
  that arrived since the More prompt first appeared).  If you have not 
  scrolled backwards, only the count of new lines is shown, so the More prompt 
  looks the same as it would have in version 4.0.  If either count would not 
  fit in the space allotted to it in the More prompt, they may be displayed in 
  units of thousands (e.g., "17523" would be shown as "17k").  

  Each [1msocket[22;0m and open world [1mworld[22;0m has its own window with its own "more" 
  state.  

  If your terminal can't scroll in [1mvisual mode[22;0m, TF will start over at the top 
  of the output window instead.  

  See: [1m/dokey[22;0m, [1mvisual[22;0m, [1m%more[22;0m, [1mmorescroll()[22;0m, [1mmoresize()[22;0m, [1mstatus_fields[22;0m 

&/nogag

/nogag

  Usage: 

  [1m/NOGAG[22;0m [<[4mpattern[24m>]
  ____________________________________________________________________________

  Eliminates a [1mmacro[22;0m that is [1mtrigger[22;0med by <[4mpattern[24m> and has the [1mgag[22;0m [1mattribute[22;0m. 
  [1m/nogag[22;0m with no arguments turns off the flag [1m%{gag}[22;0m, disabling all [1mgag[22;0m 
  [1mattributes[22;0m.  <[4mPattern[24m> is matched against existing patterns using simple 
  comparison.  

  The flag [1m%{gag}[22;0m defaults to 1 (on).  

  See: [1mtriggers[22;0m, [1m/gag[22;0m, [1m%gag[22;0m 

&/nohilite

/nohilite

  Usage: 

  [1m/NOHILITE[22;0m [<[4mpattern[24m>]
  ____________________________________________________________________________

  With a <[4mpattern[24m> argument, [1m/nohilite[22;0m undefines a [1mmacro[22;0m that is [1mtrigger[22;0med by 
  <[4mpattern[24m> and has the [1mhilite[22;0m [1mattribute[22;0m.  <[4mPattern[24m> is matched against 
  existing patterns using simple comparison.  

  With no argument, [1m/nohilite[22;0m turns off the flag [1m%{hilite}[22;0m, disabling all 
  display [1mattributes[22;0m.  

  The flag [1m%{hilite}[22;0m defaults to 1 (on).  

  See: [1mtriggers[22;0m, [1m/hilite[22;0m, [1m%hilite[22;0m 

&/first
&/last
&/nth

/nth

  Usage: 

  [1m/FIRST[22;0m <[4mtext[24m>
  [1m/LAST[22;0m <[4mtext[24m>
  [1m/NTH[22;0m <[4mn[24m> <[4mtext[24m>
  ____________________________________________________________________________

  Echoes the first, last, or <[4mn[24m>th word from text.  `[1m/first[22;0m <[4mtext[24m>' is 
  equivalent to `[1m/nth[22;0m 1 <[4mtext[24m>'.  

  These commands can be useful in command substitutions.  For example, to make 
  "ctrl-O 1" input the first word of the most recent mud output, you could do 
  this: 

  [1m/bind[22;0m ^O1 = [1m/input[22;0m $([1m/first[22;0m $([1m/recall[22;0m 1)) 

  See: [1mparameters[22;0m, [1mcommand substitution[22;0m 

&/partial

/partial

  Usage: 

  [1m/PARTIAL[22;0m <[4mregexp[24m>
  ____________________________________________________________________________

  Creates a [1mmacro[22;0m which will [1mhilite[22;0m the part of a line containing text matched 
  by the [1mregular expression[22;0m <[4mregexp[24m>.  Remember that [1mregular expressions[22;0m are 
  case sensitive.  The new [1mmacro[22;0m is a [1mfall-thru[22;0m, so multiple [1m/partial[22;0ms (and 
  other [1mtriggers[22;0m) can match the same text.  

  The [1mattribute[22;0m(s) for [1mhilited[22;0m text are determined by the [1m%{hiliteattr}[22;0m 
  [1mvariable[22;0m.  The default is bold ([1mhiliteattr[22;0m=B).  [1mColors[22;0m are also available.  

  For example, "[1m/partial[22;0m [Hh]awkeye" will [1mhilite[22;0m any occurrence of "Hawkeye" 
  or "hawkeye".  

  Unlike version 3.2, a partial [1mhilite[22;0m will be applied to every match on a 
  line, not just the first match.  

  [1m/partial[22;0m <[4mregexp[24m>
  is equivalent to
  [1m/def[22;0m [1m-Ph[22;0m [1m-F[22;0m [1m-t[22;0m<[4mregexp[24m>

  See: [1mattributes[22;0m, [1mpatterns[22;0m, [1m/hilite[22;0m, [1m/def[22;0m 

&paste_prefix
&%paste_prefix
&/endpaste
&/paste

/paste

  Usage: 

  [1m/PASTE[22;0m [-pnx] [<[4mprefix[24m>]
  [1m/ENDPASTE[22;0m
  ____________________________________________________________________________

  After executing [1m/paste[22;0m, every line of input (including lines that begin with 
  "/") will have <[4mprefix[24m> prepended to it and then get sent to the [1mcurrent 
  socket[22;0m.  If <[4mprefix[24m> is omitted and -n is not specified, the prefix defaults 
  to the value of %paste_prefix; if %paste_prefix is empty or unset, it 
  defaults to ":|".  Typing "[1m/endpaste[22;0m" or "." on a line by itself ends the 
  pasting; "/abort" on a line by itself aborts the pasting.  [1m/Paste[22;0m can be 
  very useful when using the cut-and-paste mechanism of many windowing 
  systems.  

  [1mOptions:[22;0m 
  -p      "paragraph mode": adjacent non-blank lines are joined, and leading 
          spaces are stripped (this is particularly useful when pasting text 
          cut from a web browser or a window of different width).  
  -n      Don't prepend any prefix.  
  -x      After prepending the prefix (if any), execute the resulting line as 
          a command (without [1msubstitution[22;0m) instead of sending it.  
  -w<[4mworld[24m> 
          Send the text to <[4mworld[24m>.  
  -e<[4mend[24m> 
          End when the user types <[4mend[24m> (default: "/endpaste").  With or 
          without this option, "." will always work.  
  -a<[4mabort[24m> 
          Abort when the user types <[4mabort[24m> (default: "/abort").  With or 
          without this option, interrupt (^C) will always work.  
  -q      quiet: do not print "Entering paste mode" message.  
  -s      strip trailing spaces from each pasted line 
  -h      invoke matching [1mSEND hooks[22;0m for each line sent by [1m/paste[22;0m.  

  Note that [1m/endpaste[22;0m is not actually a command, but a "magic cookie" 
  recognized by [1m/paste[22;0m.  "[1m/Endpaste[22;0m", ".", and SIGINT (^C) are the only ways 
  to end [1m/paste[22;0m.  

  Lines sent by [1m/paste[22;0m will invoke matching [1mSEND hooks[22;0m.  

  Examples: 
  Prepare to paste text from a web page to a mud: 
          [1m/paste[22;0m -p 
  Prepare to paste a bunch of lines to be recorded in your input [1mhistory[22;0m: 
          [1m/paste[22;0m -x [1m/recordline[22;0m -i - 

  See: [1m/quote[22;0m 

&/prompt

/prompt

  Usage: 

  [1m/PROMPT[22;0m <[4mtext[24m>
  ____________________________________________________________________________

  Sets the [1mprompt[22;0m for the [1mcurrent[22;0m [1msocket[22;0m to <[4mtext[24m>, replacing any existing 
  [1mprompt[22;0m.  [1m/prompt[22;0m is most useful when called from a PROMPT [1mhook[22;0m, like this: 

      [1m/def[22;0m [1m-h[22;0m"PROMPT *> " catch_prompt = [1m/test[22;0m [1mprompt[22;0m([1m{*}[22;0m)

  Then, any text that ends in ">" without a newline will be made the prompt.  

  For a more sophisticated example, see "[1mstatus line[22;0m".  

  See: [1mprompts[22;0m, [1mhooks[22;0m (PROMPT) 

&/ps

/ps

  Usage: 

  [1m/PS[22;0m [-srq] [-w<[4mworld[24m>] [<[4mpid[24m>]
  ____________________________________________________________________________

  [1mOptions[22;0m: 
  -s      short form, lists only PIDs.  
  -r      list /repeats only.  
  -q      list /quotes only.  
  -w[<[4mworld[24m>] 
          list only processes for <[4mworld[24m>.  

  Lists information about [1mprocess[22;0m <[4mpid[24m>, or all currently running [1m/quote[22;0m and 
  [1m/repeat[22;0m [1mprocesses[22;0m: 

  PID     unique [1mprocess[22;0m identification number.  
  NEXT    time remaining until next execution of [1mprocess[22;0m, or "pending" if 
          [1mprocess[22;0m is waiting for output from a shell command.  
  T       the type of the command: "q" for 
          [1mquote[22;0m or "r" for [1mrepeat[22;0m.  
  D       disposition of [1m/quote[22;0m lines: "e" for echo, "s" for send, or "x" for 
          exec.  
  WORLD   world to which output is sent, if not the [1mcurrent[22;0m world.  
  PTIME   delay between executions.  
  COUNT   number of [1m/repeat[22;0m executions remaining.  
  COMMAND 
          the command to be executed.  

  See: [1mprocesses[22;0m 

&/purgebind
&/purgedef
&/purgedeft
&/purgegag
&/purgehilite
&/purgehook
&/purgetrig
&/purge

/purge

  Usage: 

  [1m/PURGE[22;0m [<[4mmacro-options[24m>] [<[4mname[24m>] [= <[4mbody[24m>]
  ____________________________________________________________________________

  Removes all [1mmacros[22;0m matching the specified restrictions.  The [1m<[4mmacro-options[24m>[22;0m 
  are the same as those in the [1m/list[22;0m command; see "[1m/list[22;0m" for details.  
  Invisible [1mmacros[22;0m will not be purged unless "-i" is specified.  Remember that 
  "macros" includes keybindings, [1mhilite[22;0ms, [1mgag[22;0ms, [1mtriggers[22;0m, and [1mhooks[22;0m.  

  The standard [1mmacro[22;0m library also defines the commands [1m/purgedef[22;0m, [1m/purgebind[22;0m, 
  [1m/purgehilite[22;0m, [1m/purgegag[22;0m, [1m/purgetrig[22;0m, [1m/purgedeft[22;0m, and [1m/purgehook[22;0m, which purge 
  [1mmacros[22;0m of the appropriate type.  These always use [1mglob[22;0m matching.  

  See: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mattributes[22;0m, [1mlibrary[22;0m, [1m/def[22;0m, [1m/list[22;0m, 
  [1m/purgeworld[22;0m 

&/purgeworld

/purgeworld

  Usage: 

  [1m/PURGEWORLD[22;0m [-m<[4mstyle[24m>] [-T<[4mtype[24m>] [<[4mname[24m>]
  ____________________________________________________________________________

  Removes [1mworld[22;0m definitions.  

  [1mOptions[22;0m and arguments: 
  -m<[4mstyle[24m> 
          Use <[4mstyle[24m> for [1mpattern matching[22;0m of <[4mtype[24m> and <[4mname[24m> patterns.  
          (default: [1m%{matching}[22;0m).  
  -T<[4mtype[24m> 
          Remove only worlds with a type matching the [1mpattern[22;0m <[4mtype[24m>.  
  <[4mname[24m>  Remove only worlds with a name matching the [1mpattern[22;0m <[4mname[24m>.  

  The return value of [1m/purgeworld[22;0m is the number of world definitions that were 
  removed.  

  See: [1mworlds[22;0m, [1m/listworlds[22;0m, [1mpatterns[22;0m 

&upload
&/putfile_MUCK
&/putfile_UNIX
&/putfile_LP
&/putfile

/putfile

  Usage: 

  [1m/REQUIRE[22;0m filexfer.tf

  [1m/PUTFILE_MUCK[22;0m <[4mfile[24m> [<[4mremote-file[24m>]
  [1m/PUTFILE_LP[22;0m <[4mfile[24m> [<[4mremote-file[24m>]
  [1m/PUTFILE_UNIX[22;0m <[4mfile[24m> [<[4mremote-file[24m>]
  ____________________________________________________________________________

  Uploads text <[4mfile[24m> from the local system to <[4mremote-file[24m> on a MUCK, LP, or 
  UNIX server, using an editor on the remote system.  If <[4mremote-file[24m> is 
  omitted, <[4mfile[24m> is used as the name of the remote file.  

  [1m/Putfile_LP[22;0m assumes the LPmud has an "ed" editor similar to that in UNIX.  

  For backward compatibility, [1m/putfile[22;0m is the same as [1m/putfile_MUCK[22;0m.  

  See: [1m/getfile[22;0m, [1m/quote[22;0m 

&/quit

/quit

  Usage: 

  [1m/QUIT[22;0m [-y]
  ____________________________________________________________________________

  Exits TF.  If TF is [1minteractive[22;0m, and there are any [1mworlds[22;0m with unseen text, 
  /quit first asks you to confirm the exit; if you type anything other than 
  "Y" or "y", TF does not exit.  

  [1mOptions:[22;0m 
  -y      exit unconditionally, without prompting.  
  When TF exits, all [1msocket[22;0m connections will be disconnected; all logfiles 
  will be closed; all [1m/quote[22;0ms and [1m/repeat[22;0ms will be killed; and all [1mhistory[22;0m, 
  unsaved [1mmacros[22;0m, and [1mvariables[22;0m will be lost.  

  If you prefer to never be prompted by /quit, you can redefine it like this: 

    [1m/def[22;0m quit = /@quit -y

  See also: [1m/dc[22;0m, [1m%quitdone[22;0m 

&/quote

/quote

  Usage: 

  [1m/QUOTE[22;0m [<[4moptions[24m>] [<[4mpre[24m>] '"<[4mfile[24m>"[<[4msuf[24m>]
  [1m/QUOTE[22;0m [<[4moptions[24m>] [<[4mpre[24m>] #"<[4mrecall_args[24m>"[<[4msuf[24m>]
  [1m/QUOTE[22;0m [<[4moptions[24m>] [<[4mpre[24m>] !"<[4mshell_cmd[24m>"[<[4msuf[24m>]
  [1m/QUOTE[22;0m [<[4moptions[24m>] [<[4mpre[24m>] `"<[4mTF_cmd[24m>"[<[4msuf[24m>]
  ____________________________________________________________________________

  [1m/Quote[22;0m generates lines of text, one for each line quoted from a file, shell 
  command, [1mhistory[22;0m, or TF command.  Each generated line is then echoed, sent 
  to a socket, or executed as a command.  Lines will be generated at a rate 
  described in the section "[1mprocesses[22;0m".  

  [1mOptions[22;0m and arguments: 
  -d<[4mdisp[24m> 
          disposition of generated text.  <[4mDisp[24m> is one of: "echo" (echo to 
          the screen), "send" (send directly to the [1msocket[22;0m), or "exec" 
          (execute text as a tf command).  The default <[4mdisp[24m> is "send" if 
          there is no <[4mpre[24m>, and "exec" if there is a <[4mpre[24m>.  
  -w<[4mworld[24m> 
          Generated commands will be executed with <[4mworld[24m> as the [1mcurrent[22;0m 
          world.  If <[4mworld[24m> is blank, it uses the world that was [1mcurrent[22;0m when 
          the [1m/quote[22;0m started.  If -w is omitted, each command's [1mcurrent[22;0m world 
          will be whatever happens to be in the [1mforeground[22;0m when each command 
          occurs.  (See "[1msockets[22;0m").  
  -<[4mtime[24m> 
          The delay between each generated line.  It can have the format 
          "<[4mhours[24m>:<[4mminutes[24m>:<[4mseconds[24m>", "<[4mhours[24m>:<[4mminutes[24m>", or "<[4mseconds[24m>", 
          and <[4mseconds[24m> may be specified to the nearest microsecond.  If 
          -<[4mtime[24m> is omitted, the [1mvariable[22;0m [1m%{ptime}[22;0m is used.  If <[4mtime[24m> is 
          given as the letter "S", the quote will run synchronously, with no 
          delay.  If a slow shell command is used with [1m/quote[22;0m -S !, tf will 
          hang until the command produces some output or exits.  A synchronous 
          [1m/quote[22;0m may be used inside another [1m/quote[22;0m.  If <[4mtime[24m> is given as the 
          letter "P", the quote will run whenever a [1mprompt[22;0m is received.  See 
          "[1mprocesses[22;0m" for more information on process timing.  
  -s<[4msub[24m> 
          [1mExpand[22;0m <[4mTF_cmd[24m> as if [1m%{sub}[22;0m were set to <[4msub[24m>.  By default, [1m/quote[22;0m 
          [1mexpands[22;0m <[4mTF_cmd[24m> as if [1m%{sub}[22;0m were "full".  
  <[4mpre[24m>   <[4mpre[24m> is prefixed to each generated line.  If <[4mpre[24m> contains any of 
          the command characters ('!`#), they must be preceded with '\' to 
          remove their special meaning.  
  '<[4mfile[24m> 
          Get text from <[4mfile[24m>.  The <[4mfile[24m> name is expanded as described 
          under [1m/help[22;0m filenames.  
  !<[4mshell_cmd[24m> 
          Get text from the standard output and standard error of executing 
          <[4mshell_cmd[24m> in the shell.  
  `<[4mTF_cmd[24m> 
          Get text from the output of executing <[4mTF_cmd[24m> in tf.  
  #<[4mrecall_args[24m> 
          Get text from executing [1m/recall[22;0m <[4mrecall_args[24m>.  (See "[1mrecall[22;0m" for 
          the exact syntax).  
  <[4msuf[24m>   Append <[4msuf[24m> to each generated line.  If omitted, the double quotes 
          around the <[4mfile[24m> or <[4mcommand[24m> may also be omitted.  

  An asynchronous [1m/quote[22;0m (i.e., a [1m/quote[22;0m without -S) returns the pid of the 
  new [1mprocess[22;0m, or 0 if an error occurred.  A synchronous (-S) shell (!) or 
  command (`) quote returns the return value of the command.  A synchronous 
  file (') quote returns 0 on error, nonzero otherwise.  

  The [1mlibrary[22;0m file [1mquoter.tf[22;0m defines some useful [1mquoter commands[22;0m that are 
  shortcuts for some common uses of [1mquote[22;0m.  

  The following is a list of some nearly equivalent pairs of commands: 
  [1m/quote[22;0m -S -dexec '<[4mfile[24m> 
          [1m/load[22;0m <[4mfile[24m> 
  [1m/quote[22;0m -S /echo -aG - #<[4margs[24m> 
          [1m/recall[22;0m <[4margs[24m> 
  [1m/quote[22;0m <[4mopts[24m> `[1m/recall[22;0m <[4margs[24m> 
          [1m/quote[22;0m <[4mopts[24m> #<[4margs[24m> 

  ____________________________________________________________________________

  Examples: 


    [1m/quote[22;0m -1 :reads about '"/usr/dict/words" in the dictionary.

  This sends off lines like:

    :reads about aardvark in the dictionary.
    :reads about aardvore in the dictionary.

  with one-second delays between lines.  


    [1m/quote[22;0m -S [1m/echo[22;0m !ps -gux

  This displays the output of the system command "ps -gux" by echoing it 
  locally, immediately.  


    [1m/quote[22;0m -0 :heard: #-wCave /2 *pages*

  This sends off quickly: 

  :heard: [the last 2 lines from Cave that contain "pages"] 


    [1m/quote[22;0m :is using `[1m/version[22;0m

  will tell everybody in the room what version of TF you're running.  


    [1m/quote[22;0m -wlpmud -dsend 'prog.c

  will send the file "prog.c" to the world "lpmud", without any interpretation 
  of leading spaces or slashes (in lines like "/* comment */"), etc.) 

  ____________________________________________________________________________

  See: [1mprocesses[22;0m, [1m%ptime[22;0m, [1m%lpquote[22;0m, [1mquoter.tf[22;0m, [1mhistory[22;0m, [1mcommand subs[22;0m, [1m/load[22;0m, 
  [1m/recall[22;0m, [1m/sh[22;0m, [1m/sys[22;0m, [1m/paste[22;0m 

&/qdef
&/qmac
&/qworld
&/qtf
&/qsh
&/qmud
&quoter
&quoter.tf

Quoter Commands

  [1m/REQUIRE[22;0m quoter.tf
  ____________________________________________________________________________

  After doing "[1m/REQUIRE[22;0m quoter.tf", the quoting commands can be used to take 
  the output of various sources and execute them as commands, typically 
  quoting them to a mud server.  These are all just shortcuts for things you 
  can already do with [1m/quote[22;0m -S.  The default <[4mprefix[24m> is ":|", which will 
  perform a pose on Tiny-style muds.  The default prefix can be changed by 
  setting the appropriate variable: qdef_prefix, qmac_prefix, qworld_prefix, 
  qtf_prefix, qsh_prefix, or qmud_prefix.  An alternate <[4mprefix[24m> can be given 
  on the command line for [1m/qdef[22;0m, [1m/qmac[22;0m, [1m/qworld[22;0m, and [1m/qfile[22;0m.  Also, before any 
  output is generated, the command used to generate the output is quoted.  

  [1m/QDEF[22;0m [<[4mprefix[24m>] <[4mname[24m> 
          Prepends <[4mprefix[24m> to each line generated by "[1m/list[22;0m <[4mname[24m>", and 
          executes each resulting line as a command.  

  [1m/QMAC[22;0m [<[4mprefix[24m>] <[4mname[24m> 
          Searches for the definition of macro <[4mname[24m> in a group of tf files, 
          prepends <[4mprefix[24m> to each line found, "[1m/quote[22;0m <[4mname[24m>", and executes 
          each resulting line as a command.  

  [1m/QWORLD[22;0m [<[4mprefix[24m>] <[4mname[24m> 
          Prepends <[4mprefix[24m> to each line generated by "[1m/listworlds[22;0m <[4mname[24m>", 
          and executes each resulting line as a command.  

  [1m/QFILE[22;0m [<[4mprefix[24m>] <[4mname[24m> 
          Prepends <[4mprefix[24m> to each line of file <[4mname[24m>, and executes each 
          resulting line as a command.  

  [1m/QTF[22;0m <[4mcmd[24m> 
          Prepends <[4mprefix[24m> to each line generated by executing <[4mcmd[24m> in tf, 
          and executes each resulting line as a command.  

  [1m/QSH[22;0m <[4mcmd[24m> 
          Prepends <[4mprefix[24m> to each line generated by executing <[4mcmd[24m> in the 
          shell, and executes each resulting line as a command.  

  [1m/QMUD[22;0m [-w<[4mworld[24m>] <[4mcmd[24m> 
          Prepends <[4mprefix[24m> to each line generated by executing <[4mcmd[24m> on world 
          <[4mworld[24m> (default: the [1mcurrent[22;0m [1mworld[22;0m), and executes each resulting 
          line as a command.  [1m/Qmud[22;0m requires that the mud supports the 
          OUTPUTPREFIX and OUTPUTSUFFIX commands.  

  Examples: 

  The command 

    [1m/qsh[22;0m finger

  would generate a series of commands something like this: 

    :! finger
    :| Login       Name              TTY Idle    When    Site Info
    :| hawkeye  Ken Keys              p3       Fri 19:32 
    :| hawkeye  Ken Keys              p4       Sat 17:37 

  And, on a Tiny-style mud named "Cave", the command 

    [1m/qmud[22;0m score

  would generate a series of commands something like this: 

    :| Cave> score
    :| You have 8704 pennies.

  ____________________________________________________________________________

  See: [1m/quote[22;0m, [1mprocesses[22;0m, [1m/paste[22;0m 

&/recall

/recall

  Usage: 

  [1m/RECALL[22;0m [-w<[4mworld[24m>] [-ligv] [-t[<[4mformat[24m>]] [-a<[4mattrs[24m>] [-m<[4mstyle[24m>] [-A<[4mn[24m>] 
  [-B<[4mn[24m>] [-C<[4mn[24m>] [#]<[4mrange[24m> [<[4mpattern[24m>]
  ____________________________________________________________________________

  Recalls lines from a [1mhistory[22;0m buffer.  Only one of the [-ligw] options can be 
  used, to specify the history from which to recall.  

  [1mOptions:[22;0m 
  -w      recall from [1mcurrent[22;0m world's [1mhistory[22;0m (default) 
  -w<[4mworld[24m> 
          recall from <[4mworld[24m>'s [1mhistory[22;0m 
  -l      recall from local [1mhistory[22;0m (i.e., TF output) 
  -g      recall from global [1mhistory[22;0m (all worlds, and local) 
  -i      recall from input history 
  -t[<[4mformat[24m>] 
          display timestamps on each line, using <[4mformat[24m>.  If <[4mformat[24m> is 
          omitted, "[[1m%{time_format}[22;0m]" will be used.  The format is described 
          in [1mftime()[22;0m.  
  -v      recall lines that [4mdon't[24m match the [1mpattern[22;0m 
  -q      quiet: suppress the header and footer lines 
  -a<[4mattr[24m> 
          suppress specified [1mattributes[22;0m (e.g., -ag shows [1mgag[22;0mged lines) 
  -m<[4mstyle[24m> 
          matching style ([1msimple[22;0m, [1mglob[22;0m, or [1mregexp[22;0m).  
  -A<[4mn[24m>   Print <[4mn[24m> lines of context after each matching line.  
  -B<[4mn[24m>   Print <[4mn[24m> lines of context before each matching line.  
  -C<[4mn[24m>   Equivalent to -A<[4mn[24m> -B<[4mn[24m>.  
  #       display line numbers (must be last option, before <[4mrange[24m>) 

  <[4mrange[24m> can have one of the formats below.  If <[4mx[24m> and <[4my[24m> are plain 
  integers, they are interpreted as line numbers or counts.  If they have the 
  form "<[4mhours[24m>:<[4mminutes[24m>" or "<[4mhours[24m>:<[4mminutes[24m>:<[4mseconds[24m>", they are 
  interpreted as time values (either a period of time, or a clock time within 
  the last 24 hours).  If they are real numbers (with up to 6 decimal places), 
  they are interpreted as absolute system times.  
  /[4mx[24m      Recall the last <[4mx[24m> matching lines.  
  [4mx[24m       Recall from the last <[4mx[24m> lines, or lines within the last time period 
          <[4mx[24m>.  
  [4mx[24m-[4my[24m     Recall lines starting with <[4mx[24m> and ending with <[4my[24m>.  
  -[4my[24m      If <[4my[24m> is a line number, recall the <[4my[24m>th previous line; if <[4my[24m> is a 
          time, recall lines earlier than <[4my[24m>.  Remember to use "[1m-[22;0m" before 
          "-[4my[24m" so it isn't interpreted as an [1moption[22;0m.  
  [4mx[24m-      Recall lines after <[4mx[24m>.  

  If <[4mrange[24m> is prefixed with "#", line numbers will be displayed.  

  If <[4m[1mpattern[22;0m[24m> is given, only lines in the given range that match <[4m[1mpattern[22;0m[24m> 
  will be recalled.  The matching style is determined by the -m option if 
  given, [1m%{matching}[22;0m otherwise.  

  If the output of [1m/recall[22;0m is being sent to the screen, it will be preceded by 
  "================ Recall start ================" and follwed by 
  "================= Recall end =================" unless -q is used.  These 
  lines will not be produced if the output is redirected, for example with 
  [1m$(...)[22;0m [1mcommand substitution[22;0m or "[1m/quote `[22;0m[1m/recall[22;0m".  When -A, -B, or -C is 
  used, groups of lines that are not adjacent in history will be separated by 
  "--".  

  If lines are received while tf is suspended (by [1m^Z[22;0m or [1m/suspend[22;0m) or in a 
  subshell (by [1m/sh[22;0m), the timestamps on the lines will correspond to the time 
  tf resumed control, not the time they actually arrived.  

  The return value of [1m/recall[22;0m is the number of lines that were actually 
  recalled.  

  Because the output of [1m/recall[22;0m may clutter the current window, you may wish 
  to use [1m/limit[22;0m instead.  

  Examples These examples assume that [1mmatching[22;0m=glob (the default).  
  Recall every line beginning with "Kite whispers" that arrived in the last 
  hour:   [1m/recall[22;0m 1:00 Kite whispers* 
  Recall every line that arrived between 11 am and 1 pm: 
          [1m/recall[22;0m 11:00-13:00 
  Recall the last 5 lines containing "spam": 
          [1m/recall[22;0m /5 *spam* 

  See: [1mhistory[22;0m, [1mattributes[22;0m, [1m/limit[22;0m, [1m/quote[22;0m, [1m%time_format[22;0m 

&/recordline

/recordline

  Usage: 

  [1m/RECORDLINE[22;0m [-lig] [-w[<[4mworld[24m>]] [-t<[4mtime[24m>] <[4mtext[24m>
  ____________________________________________________________________________

  Records <[4mtext[24m> into a [1mhistory[22;0m buffer.  

  [1mOptions:[22;0m 
  -w      record to [1mcurrent[22;0m world's [1mhistory[22;0m 
  -w<[4mworld[24m> 
          record to <[4mworld[24m>'s [1mhistory[22;0m 
  -l      record to local [1mhistory[22;0m 
  -g      record to global [1mhistory[22;0m (default) 
  -i      record to input history 
  -t<[4mtime[24m> 
          record the line with the system time <[4mtime[24m> (as displayed by [1m/recall[22;0m 
          -t@) instead of the current time 
  -a<[4mattrs[24m> 
          Record <[4mtext[24m> with the [1mattributes[22;0m given by <[4mattrs[24m>.  
  -p      Interpet "@{<[4mattr[24m>}" strings as commands to set [1mattributes[22;0m inline.  
          "@@" strings are interpreted as "@".  "@{n}" or "@{x}" will turn 
          attributes off.  See also: [1mdecode_attr()[22;0m.  

  The <[4mtext[24m> will not be echoed to the screen or saved in any log.  

  [1m/Recordline[22;0m can be combined with [1m/quote[22;0m to read a log file back into 
  [1mhistory[22;0m.  For example, if you had created a log with "[1m/log[22;0m -i input.log" in 
  an earlier tf session, you could start a new tf session and use 

  [1m/quote[22;0m -S -dexec [1m/recordline[22;0m -i [1m-[22;0m 'input.log 

  to restore that input [1mhistory[22;0m.  That way, you could use the RECALLB, 
  RECALLF, RECALLBEG, RECALLEND, SEARCHB, and SEARCHF (^P, ^N, ^[<, ^[>, ^[P, 
  and ^[N) keys to recall lines you typed in the earlier session.  

  Note that [1m/recordline[22;0m always appends to the end of a [1mhistory[22;0m.  [1m/Recordline[22;0m 
  -t<[4mtime[24m> makes it possible to insert lines that are not in chronological 
  order, which may produce strange results with [1m/recall[22;0m.  

  See: [1m/recall[22;0m, [1m/quote[22;0m, [1mhistory[22;0m 

&delay
&/repeat

/repeat

  Usage: 

  [1m/REPEAT[22;0m [-w[<[4mworld[24m>]] [-n] {[-<[4mtime[24m>]|-S|-P} <[4mcount[24m> <[4mcommand[24m>
  ____________________________________________________________________________

  Repeats <[4mcommand[24m>, <[4mcount[24m> times.  <[4mCommand[24m> may be any legal [1mmacro[22;0m body.  
  If <[4mcount[24m> is "i", the <[4mcommand[24m> repeats indefinitely.  This works through a 
  [1mprocess[22;0m, which runs concurrently with normal operations.  

  [1mOptions:[22;0m 
  -w[<[4mworld[24m>] 
          <[4mCommand[24m> will execute with <[4mworld[24m> as the [1mcurrent[22;0m world.  If 
          <[4mworld[24m> is omitted, it is assumed to be the world that was [1mcurrent[22;0m 
          for /repeat.  If this option is omitted entirely, the <[4mcommand[24m>'s 
          [1mcurrent[22;0m world will be whatever world happens to be in the [1mforeground[22;0m 
          when it's time for <[4mcommand[24m> to run.  
  -<[4mtime[24m> 
          <[4mTime[24m> is the delay between each execution of <[4mcommand[24m>.  <[4mTime[24m> may 
          be specified in the format "<[4mhours[24m>:<[4mminutes[24m>:<[4mseconds[24m>", 
          "<[4mhours[24m>:<[4mminutes[24m>", or "<[4mseconds[24m>" (<[4mseconds[24m> may be specified to 
          the nearest microsecond).  
  -S      The repeat will run synchronously.  
  -P      The repeat will run whenever a [1mprompt[22;0m is received.  
  -n      When combined with the -<[4mtime[24m> option, this makes the first 
          execution of <[4mcommand[24m> happen with no delay.  
  At most one of the -S, -P, and -<[4mtime[24m> options should be specified.  If none 
  are specified, the delay between each execution of <[4mcommand[24m> is determined 
  by the [1mvariable[22;0m [1m%{ptime}[22;0m.  See "[1mprocesses[22;0m" for more information on process 
  timing.  

  The <[4mcommand[24m> undergoes [1mmacro[22;0m body [1msubstitution[22;0m when it is executed.  

  An asynchronous [1m/repeat[22;0m (without -S) returns the pid of the new [1mprocess[22;0m, or 
  0 if an error occurred.  A synchronous [1m/repeat[22;0m returns the return value of 
  the last command.  

  Since the first run is not done until after the first interval (for [1m/repeat[22;0m 
  without -S or -n), a useful trick is to use "[1m/repeat[22;0m -<[4mtime[24m> 1 <[4mcommand[24m>" to 
  delay the execution of a single command.  

  Example: [1m/repeat[22;0m -0:30 1 [1m/echo[22;0m -ab Dinner's ready 
#sleep

  There is no good way to directly "sleep" within a [1mmacro[22;0m body.  Any attempt 
  to write your own /sleep macro will, at best, "freeze" tf for the duration 
  of the sleep, or even worse hog the machine's CPU time in a busy wait.  The 
  best way to achieve the effect a sleep in a [1m/while[22;0m loop is probably to use a 
  [1m/repeat[22;0m where each execution of the [1m/repeat[22;0m body corresponds to an iteration 
  of the desired [1m/while[22;0m loop.  That is, if you want to write 

      [1m/def[22;0m foo = \
          /before_stuff%; \
          [1m/while[22;0m (condition) \
              /do_stuff%; \
              /sleep 5%; \
          [1m/done[22;0m%; \
          /after_stuff

  you must instead write: 

      [1m/def[22;0m foo = \
          /before_stuff%; \
          /foo_loop

      [1m/def[22;0m foo_loop = \
          [1m/if[22;0m (condition) \
              /do_stuff%; \
              [1m/repeat[22;0m -5 1 /foo_loop%; \
          [1m/else[22;0m
              /after_stuff%; \
          [1m/endif[22;0m

  Of course, local [1mvariables[22;0m will not survive between calls of /do_stuff in 
  the second version as they would in the first (if it were possible), so any 
  [1mvariables[22;0m you need to share between iterations must be global.  

  But, if the reason you want to sleep is to wait for a response from a 
  server, then you really don't want to sleep at all: you want a [1mtrigger[22;0m.  
  First, set up [1mtriggers[22;0m on the possible responses, then send the command.  If 
  one of the possible responses is no response at all, then a [1m/repeat[22;0m can be 
  useful to wait for some maximum timeout and then handle the no-reponse case 
  and delete the response [1mtriggers[22;0m.  This is in general the best way to write 
  [1mmacros[22;0m that interact with a server.  
#

  See: [1mprocesses[22;0m, [1m%ptime[22;0m, [1m/at[22;0m [1mkbnum[22;0m 

&/replace

/replace

  [1mFunction[22;0m usage: 

  [1mREPLACE[22;0m(<[4mold[24m>, <[4mnew[24m>, <[4mstring[24m>)

  Command usage: 

  [1m/REPLACE[22;0m <[4mold[24m> <[4mnew[24m> <[4mstring[24m>
  ____________________________________________________________________________

  Echoes (in command form) or returns (in [1mfunction[22;0m form) <[4mstring[24m>, with any 
  occurrences of <[4mold[24m> in <[4mstring[24m> replaced by <[4mnew[24m>.  

#replace-ex
  Example: 

  This example replaces "TF" with "TinyFugue" in every line sent by the 
  server.  

    [1m/def[22;0m [1m-m[22;0mregexp [1m-t[22;0m"TF" replace_tf = \
        [1m/test[22;0m [1msubstitute[22;0m([1mreplace[22;0m("TF", "TinyFugue", {P0}))

  See: [1mevaluation[22;0m, [1m/tr[22;0m 

&security
&/restrict

/restrict

  Usage: 

  [1m/RESTRICT[22;0m [SHELL|FILE|WORLD]
  ____________________________________________________________________________

  With no arguments, [1m/restrict[22;0m reports the current restriction level.  

  With an argument, [1m/restrict[22;0m sets the restriction level.  Once restriction 
  has been set to a particular level, it can not be lowered.  
  level 0: NONE 
          No restrictions.  
  level 1: SHELL 
          Prevents all access to shell or external commands.  Disables TF 
          builtins "[1m/sh[22;0m" and "[1m/quote[22;0m !", and uncompression during [1m/load[22;0m and 
          [1m/help[22;0m.  
  level 2: FILE 
          Prevents reading and writing of files.  Disables TF builtins 
          "[1m/load[22;0m", "[1m/save[22;0m", "[1m/saveworld[22;0m", "[1m/lcd[22;0m", "[1m/log[22;0m", and "[1m/quote[22;0m '", 
          "[1mtfopen()[22;0m", the "[1msockmload[22;0m feature.  Implies [1m/restrict[22;0m shell.  
  level 3: WORLD 
          Disallows all new user-defined connections.  The TF builtins 
          [1m/addworld[22;0m and the "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>" semantics are disabled.  
          Implies [1m/restrict[22;0m file.  

  [1m/Restrict[22;0m is typically placed in [1m%{TFLIBDIR}[22;0m/[1mlocal.tf[22;0m by an administrator of 
  a public copy of TF who wishes to restrict users' access.  

  Note that while I believe these options to be secure, I provide no warranty 
  to that effect.  

  See: [1mwarranty[22;0m 

&/result
&/return

/return and /result

  Usage: 

  [1m/RETURN[22;0m [<[4m[1mexpression[22;0m[24m>]
  [1m/RESULT[22;0m [<[4m[1mexpression[22;0m[24m>]
  ____________________________________________________________________________

  [1m/return[22;0m stops execution of the [1mmacro[22;0m body that called it, and causes the 
  macro to return the string value of <[4m[1mexpression[22;0m[24m>.  If the <[4m[1mexpression[22;0m[24m> is 
  omitted, the return value of the [1mmacro[22;0m is the empty string.  

  When a macro that calls [1m/result[22;0m was called as a [1mfunction[22;0m, [1m/result[22;0m is 
  identical to [1m/return[22;0m.  When a macro that calls [1m/result[22;0m was called as a 
  [1mcommand[22;0m, [1m/result[22;0m has the additional effect of echoing the value of 
  <[4m[1mexpression[22;0m[24m> to the [1mtfout stream[22;0m.  [1m/Result[22;0m thus allows the same macro to be 
  called usefully as either a [1mcommand[22;0m or a [1mfunction[22;0m.  

  Note that [1m/return[22;0m and [1m/result[22;0m take the [4mstring[24m value of <[4mexpression[24m>.  This 
  is not a problem for integer- or float-valued expressions, since they 
  convert freely to strings and back without loss of information.  But if the 
  expression is an [1menumerated special variable[22;0m (e.g., borg), the value 
  returned will be its string value (e.g., "on"), not its integer value (e.g., 
  1).  To force it to use the integer value, you can use the unary plus 
  operator (e.g., +borg).  

  The return value of the last command (builtin or macro) is stored in [1m%{?}[22;0m.  
  The return value of a function (builtin or macro) is just the value of the 
  function.  

  These examples define several [1mmacros[22;0m intended to be called as a [1mfunctions[22;0m: 

    [1m/def[22;0m square = [1m/return[22;0m [1mpow[22;0m({1}, 2)

    [1m/def[22;0m hypot = [1m/return[22;0m [1msqrt[22;0m(square({1}) + square({2}))

    [1m/def[22;0m strrev = \
        /let len=$[[1mstrlen[22;0m({*})]%; \
        [1m/return[22;0m (len <= 1) ? {*} : \
            [1mstrcat[22;0m(strrev([1msubstr[22;0m({*},len/2)), strrev([1msubstr[22;0m({*},0,len/2)))

  If those examples had used [1m/result[22;0m instead of [1m/return[22;0m, they could also be 
  used as commands when echoing is more convenient.  For example, 

      [1m/eval[22;0m say My name backwards is [1m$([22;0m/strrev ${world_character}).

  See: [1m/if[22;0m, [1m/while[22;0m, [1m/test[22;0m, [1m/break[22;0m, [1m/exit[22;0m, [1mexpressions[22;0m, [1mevaluation[22;0m, [1mvariables[22;0m 

&/runtime

/runtime

  Usage: 

  [1m/runtime[22;0m <[4mcommand[24m>
  ____________________________________________________________________________

  Executes <[4mcommand[24m>, and prints the real time and cpu time used.  <[4mCommand[24m> 
  is not put through any additional [1msubstitution[22;0m before being executed.  The 
  return value of [1m/runtime[22;0m is that of <[4mcommand[24m>.  

  See: [1mcputime()[22;0m, [1mdebugging[22;0m.  

&mudwho
&rwho.tf
&/rwho

/rwho

  Usage: 

  [1m/REQUIRE[22;0m rwho.tf

  [1m/RWHO[22;0m
  [1m/RWHO[22;0m name=<[4mplayer[24m>
  [1m/RWHO[22;0m mud=<[4mmud[24m>
  ____________________________________________________________________________

  Gets a remote WHO list from a mudwho server.  The first form gives a 
  complete list, the other forms give partial lists.  Due to the short timeout 
  of the mudwho server, sometimes the complete list is sent even if the second 
  or third format is used (send complaints to the author or maintainer of the 
  mudwho server, not to me).  

  Make sure you [1m/load[22;0m rwho.tf _after_ you define your worlds, or rwho will be 
  the default world.  

&/savebind
&/savedef
&/savegag
&/savehilite
&/savehook
&/savetrig
&/save

/save

  Usage: 

  [1m/SAVE[22;0m [-a] <[4mfile[24m> [<[4mlist-options[24m>]
  ____________________________________________________________________________

  Saves specified [1mmacros[22;0m to <[4mfile[24m>.  The [1m<[4mlist-options[24m>[22;0m are the same as those 
  in the [1m/list[22;0m command; see "[1m/list[22;0m" for details.  Invisible [1mmacros[22;0m will not be 
  saved unless "-i" is specified.  

  If "-a" is specified, [1mmacros[22;0m will be appended to <[4mfile[24m>.  Otherwise, the 
  [1mmacros[22;0m will overwrite any existing contents of <[4mfile[24m>.  

  The return value of [1m/save[22;0m is the number of the last [1mmacro[22;0m listed, or 0 if no 
  [1mmacros[22;0m were listed (because of error or none matched the specified options). 

  The standard [1mmacro[22;0m library also defines commands that save macros of a 
  particular type: 
  [1m/savedef[22;0m 
          macros with names, but no [1mtriggers[22;0m, [1mhooks[22;0m, or [1mkeybindings[22;0m 
  [1m/savebind[22;0m 
          macros with [1mkeybindings[22;0m 
  [1m/savehilite[22;0m 
          macros with [1mtriggers[22;0m and [1mattributes[22;0m other than -ag 
  [1m/savegag[22;0m 
          macros with [1mtriggers[22;0m and the -ag [1mattribute[22;0m 
  [1m/savetrig[22;0m 
          macros with [1mtriggers[22;0m and no [1mattributes[22;0m 
  [1m/savehook[22;0m 
          macros with hooks 
  These commands take a filename argument; if it is omitted, a default file 
  name will be used.  No -a (append) option is allowed.  

  The [1m/save*[22;0m commands are useful if your [1mmacros[22;0m are few and simple, but if you 
  have many and/or complex [1mmacros[22;0m, you will probably find it easier to write 
  them with an editor and then [1m/load[22;0m them in tf, instead of writing them in tf 
  and [1m/save[22;0m'ing them to a file.  Avoiding [1m/save[22;0m allows you to keep the file(s) 
  nicely formatted, use comments, and organize them better.  Use whatever 
  works best for you.  

  Note that when tf starts, it does not automatically read files created with 
  any of the [1m/save[22;0m commands.  To make it do so, add the corresponding [1m/load[22;0m 
  command to your [1m.tfrc[22;0m file.  

  Except for its return value,
  [1m/save[22;0m [-a] <[4mfile[24m> [<[4mlist-options[24m>]
  is equivalent to
  [1m/eval[22;0m [1m/list[22;0m [<[4mlist-options[24m>] [1m%|[22;0m [1m/writefile[22;0m [-a] <[4mfile[24m> 

  See: [1mmacros[22;0m, [1mpatterns[22;0m, [1mattributes[22;0m, [1mlibrary[22;0m, [1m/def[22;0m, [1m/list[22;0m, [1m/load[22;0m, [1m/saveworld[22;0m 

&/saveworld

/saveworld

  Usage: 

  [1m/SAVEWORLD[22;0m [-a] [<[4mfile[24m>]
  ____________________________________________________________________________

  Saves world definitions to <[4mfile[24m> if specified, otherwise from the file 
  named in the body of the [1mWORLDFILE[22;0m macro.  

  If "-a" is given, world definitions will be appended to <[4mfile[24m>; otherwise, 
  the world definitions will replace any original contents of <[4mfile[24m>.  

  Note that when tf starts, it does not automatically read files created with 
  [1m/saveworld[22;0m.  To make it do so, add the [1m/loadworld[22;0m command to your [1m.tfrc[22;0m 
  file.  

  See: [1mworlds[22;0m, [1mlibrary[22;0m, [1m/addworld[22;0m, [1m/load[22;0m 

&send()
&/send

/send

  Function usage: 

  [1mSEND[22;0m(<[4mtext[24m>[, <[4mworld[24m>[, <[4mflags[24m>]])

  Command Usage: 

  [1m/SEND[22;0m [-W] [-T<[4mtype[24m>] [-w[<[4mworld[24m>]] [-n] <[4mtext[24m>
  ____________________________________________________________________________

  Sends <[4mtext[24m> to a world.  If no world is specified, the current world is 
  used.  By default, [1msend[22;0m does not execute SEND [1mhooks[22;0m.  

  In the function form, the optional <[4mflags[24m> is a string containing letters 
  that modify the function's behavior: 
  "h"     test for and invoke matching SEND [1mhooks[22;0m.  
  "u"     send <[4mtext[24m> unterminaed (i.e., without a CR LF end-of-line marker).  
  For backwards compatibility, the flags "o", "n", and "1" are ignored, and 
  the flags "0" and "f" are equivalent to "u".  

  Command [1moptions:[22;0m 
  -w<[4mworld[24m> 
          sends <[4mtext[24m> to <[4mworld[24m>.  
  -T<[4mtype[24m> 
          sends <[4mtext[24m> to all connected worlds with a type that matches the 
          pattern <[4mtype[24m>.  
  -W      sends <[4mtext[24m> to all connected worlds.  
  -n      send <[4mtext[24m> without an end-of-line marker (CR LF).  
  -h      test for and invoke matching SEND [1mhooks[22;0m.  

  The return value of [1msend[22;0m is 0 if the text is not successfully sent, nonzero 
  if it is.  

  See: [1mfunctions[22;0m.  

&/set

/set

  Usage: 

  [1m/SET[22;0m <[4mname[24m>=<[4mvalue[24m>
  [1m/SET[22;0m [<[4mname[24m> [<[4mvalue[24m>]]
  ____________________________________________________________________________

  In the first form, or with two arguments, [1m/set[22;0m will set the value of 
  [1mvariable[22;0m <[4mname[24m> to <[4mvalue[24m>.  With one argument, [1m/set[22;0m will display the value 
  of [1mvariable[22;0m <[4mname[24m>.  With no arguments, [1m/set[22;0m will display the value of all 
  internal [1mvariables[22;0m.  If the first form is used, there should be no spaces on 
  either side of the '='.  

  [1mVariable[22;0m <[4mname[24m> will be an internal [1mvariable[22;0m unless it has already been 
  defined as an environment [1mvariable[22;0m.  

  Note: The [1mvariables[22;0m 'L' and 'R' are reserved.  You should not assign values 
  to them.  

  When setting a variable, [1m/set[22;0m returns 1 if successful, 0 if not.  When 
  listing variables, [1m/set[22;0m returns the number of variables listed.  

  See: [1mvariables[22;0m, [1m/listvar[22;0m, [1m/setenv[22;0m, [1m/export[22;0m, [1m/let[22;0m, [1m/unset[22;0m, [1m/edvar[22;0m 

&/setenv

/setenv

  Usage: 

  [1m/SETENV[22;0m [<[4mname[24m> [<[4mvalue[24m>]]
  [1m/SETENV[22;0m <[4mname[24m>=<[4mvalue[24m>

  With two arguments, [1m/setenv[22;0m will set the value of <[4mname[24m> to <[4mvalue[24m> in the 
  environment.  With one argument, [1m/setenv[22;0m will display the value of <[4mname[24m>.  
  With no arguments, [1m/setenv[22;0m will display the value of all environment 
  [1mvariables[22;0m.  If the second form is used, spaces around the '=' will not be 
  stripped.  

  If <[4mname[24m> was already defined as an internal [1mvariable[22;0m, it will become an 
  environment [1mvariable[22;0m.  

  When setting a variable, [1m/setenv[22;0m returns 1 if successful, 0 if not.  When 
  listing variables, [1m/setenv[22;0m returns the number of variables listed.  

  See: [1mvariables[22;0m, [1m/listvar[22;0m, [1m/set[22;0m, [1m/export[22;0m 

&/sh

/sh

  Usage: 

  [1m/SH[22;0m [-q] [<[4mcommand[24m>]
  [1m/PSH[22;0m [<[4mcommand[24m>]
  ____________________________________________________________________________

  If no command is given, [1m/sh[22;0m and [1m/psh[22;0m execute an interactive shell named by 
  [1m%{SHELL}[22;0m.  With a <[4mcommand[24m>, [1m/sh[22;0m will execute <[4mcommand[24m> in the default shell 
  (/bin/sh on unix), and [1m/psh[22;0m will execute <[4mcommand[24m> in the shell named by 
  [1m%{SHELL}[22;0m.  <[4mCommand[24m> is executed interactively, so it may accept input and 
  may produce any output.  

  In [1mvisual mode[22;0m, [1m/sh[22;0m and [1m/psh[22;0m will fix the screen first, and restore it after 
  executing the shell.  [1m/Sys[22;0m does not.  

  If the -q option is given, /sh will be quiet: the [1mSHELL[22;0m [1mhook[22;0m will not be 
  called, and the "Executing" line will not be printed.  

  If the [1m%{shpause}[22;0m and [1m%{interactive}[22;0m flags are on, TF will wait for a 
  keypress before returning.  

  Note: calling [1m/sh[22;0m or [1m/psh[22;0m with arguments from a [1mtrigger[22;0m is very dangerous.  
  If not written carefully, such a [1mtrigger[22;0m could allow anyone connected to the 
  server to gain access to your shell account.  

  The return value of [1m/sh[22;0m and [1m/psh[22;0m is the exit status of the shell if it 
  exited normally, -1 otherwise.  Note that UNIX shell commands usually return 
  0 for success and nonzero for failure.  

  See: [1m/quote[22;0m, [1m/sys[22;0m, [1mutilities[22;0m ([1m/psh[22;0m) 

&/shift

/shift

  Usage: 

  [1m/SHIFT[22;0m [[4mn[24m]
  ____________________________________________________________________________

  Shifts the positional parameters left by <[4mn[24m>.  That is, the positional 
  parameters %([4mn[24m+1) ...  [1m%#[22;0m are renamed to [1m%1[22;0m ...  %(#-[4mn[24m).  If <[4mn[24m> is omitted, 
  1 is assumed.  

  [1m/shift[22;0m is useful only during [1mmacro[22;0m [1mexpansion[22;0m.  

  Example: 

    [1m/def[22;0m worlds = [1m/while[22;0m ({#}) [1m/world[22;0m [1m%1[22;0m%; [1m/shift[22;0m%; [1m/done[22;0m

  Then, the command "[1m/worlds[22;0m foo bar baz" would execute the commands "[1m/world[22;0m 
  foo", "[1m/world[22;0m bar", and "[1m/world[22;0m baz".  

  See: [1mvariables[22;0m, [1mevaluation[22;0m, [1mlist commands[22;0m 

&/signal

/signal

  Usage: 

  [1m/SIGNAL[22;0m [<[4msig[24m>]
  ____________________________________________________________________________

  Sends signal <[4msig[24m> to the tf process, or with no arguments, [1m/signal[22;0m lists 
  all valid signal names.  Valid signals usually include: HUP, INT, QUIT, 
  KILL, SEGV, TERM, USR1, USR2, and TSTP.  The complete list varies from 
  system to system.  

  See: [1msignals[22;0m, [1m/suspend[22;0m, [1mgetpid()[22;0m, [1mhooks[22;0m (SIGHUP, SIGTERM, SIGUSR1, SIGUSR2) 

&spell
&spelling
&/spell_line

spelling checker

  Usage: 

  [1m/REQUIRE[22;0m spell.tf

  [1m/SPELL_LINE[22;0m
  Keybinding: ^[s
  ____________________________________________________________________________

  After executing "[1m/require[22;0m spell.tf", typing "^[s" will call [1m/spell_line[22;0m to 
  report any misspellings in the current input line.  [1m/Spell_line[22;0m can of 
  course be bound to other keys with "[1m/def[22;0m [1m-b[22;0m".  

  [1m/Spell_line[22;0m assumes your system has a program called "spell" that reports 
  misspellings in its standard input.  

  See: [1minterface[22;0m, [1mkeys[22;0m 

&/split

/split

  Usage: 

  [1m/split[22;0m <[4margs[24m>
  ____________________________________________________________________________

  Sets [1m%{P1}[22;0m to the substring of <[4margs[24m> before the first '=', and sets [1m%{P2}[22;0m 
  to the substring of <[4margs[24m> after the first '='.  If there is no '=' in 
  <[4margs[24m>, [1m%{P1}[22;0m will contain the entire string and [1m%{P2}[22;0m will be empty.  [1m%{P0}[22;0m 
  will contain the entire string.  

  Spaces surrounding the '=' are stripped.  

  See: [1mgetopts()[22;0m 

&/sub

/sub

  Usage: 

  [1m/SUB[22;0m [OFF|ON|FULL]
  ____________________________________________________________________________

  Sets the flag [1m%{sub}[22;0m.  

  If the flag [1m%{sub}[22;0m is OFF (0), all lines except for [1mhistory[22;0m substitutions 
  (line beginning with '^') and commands (/) are sent as-is to the [1msocket[22;0m.  

  If the flag [1m%{sub}[22;0m is ON (1), the sequences "[1m%;[22;0m" and "%\" are substituted 
  with newlines, and the sequence "[1m%%[22;0m" is substituted with "%", and the 
  sequence "[1m\<[4mn[24m>[22;0m" is substituted with the character with decimal ASCII code 
  <[4mn[24m>.  

  If the flag [1m%{sub}[22;0m is FULL, text is processed just as if it were the body of 
  a [1mmacro[22;0m (see "[1mevaluation[22;0m") called without any arguments.  This allows you to 
  have in-line [1mmacros[22;0m in regular input.  

  The flag [1m%{sub}[22;0m defaults to 0 (off).  

  See: [1mgeneral[22;0m, [1mevaluation[22;0m 

&/substitute
&substitute()

/substitute

  [1mFunction[22;0m usage: 

  [1mSUBSTITUTE[22;0m(<[4mtext[24m> [, <[4mattrs[24m> [, <[4minline[24m>]])

  Command usage: 

  [1m/SUBSTITUTE[22;0m [-a<[4mattrs[24m>] [-p] <[4mtext[24m>
  ____________________________________________________________________________

  When called from a [1mtrigger[22;0m (directly or indirectly), the entire [1mtrigger[22;0ming 
  line is replaced with <[4mtext[24m>.  After a [1m/substitute[22;0m, it will appear as if 
  <[4mtext[24m> is what caused the [1mtrigger[22;0m; the original line is lost.  In 
  particular, this means when [1m/substitute[22;0m is called from a [1mfall-thru[22;0m [1mtrigger[22;0m, 
  [1mtriggers[22;0m of lower [1mpriority[22;0m will be compared against <[4mtext[24m> instead of the 
  original line.  

  [1mOptions[22;0m and arguments: 
  command: -a<[4mattrs[24m> 
  function: <[4mattrs[24m> 
          Give <[4mtext[24m> the [1mattributes[22;0m described by <[4mattrs[24m>.  These are added to 
          the original line's [1mattributes[22;0m unless <[4mattrs[24m> include the "x" 
          [1mattribute[22;0m.  
  command: -p 
  function: <[4minline[24m> = "on" or 1 
          Interpet @{<[4mattr[24m>} strings as commands to set [1mattributes[22;0m inline, as 
          in [1m/echo[22;0m.  (See [1m/echo[22;0m).  

  Example: 

  On a mud that uses MUFpage, you could set your #prepend string to "##page>", 
  and define a [1mtrigger[22;0m like: 

    [1m/def[22;0m [1m-ah[22;0m [1m-t[22;0m"##page> *" [1mhilite[22;0m_mufpage = [1m/substitute[22;0m [1m%-1[22;0m

  This will match no matter what page format the sender uses, and strip off 
  the "##page>" so you never see it.  

  For another example, see [1m/replace[22;0m.  

  See: [1mtriggers[22;0m 

&/suspend

/suspend

  Usage: 

  [1m/SUSPEND[22;0m
  ____________________________________________________________________________

  Suspends the TF process, if your system and shell support job control.  This 
  has the same effect as typing ^Z on most UNIX-like systems.  When TF is 
  resumed, it redraws the screen and processes all [1m/repeat[22;0m and [1m/quote[22;0m commands 
  that were scheduled to run while TF was suspended and processes all text 
  that was received while TF was suspended.  

  See: [1msignals[22;0m, [1m/signal[22;0m.  

&/sys

/sys

  Usage: 

  [1m/SYS[22;0m <[4mshell-command[24m>
  ____________________________________________________________________________

  Executes <[4mshell-command[24m>.  The command is executed without a tty, so it 
  should have no input, and its output, if any, should be plain text.  The 
  command's stdout and stderr are echoed to tf's output window.  [1m/sys[22;0m differs 
  from [1m/sh[22;0m in that [1m/sys[22;0m can not do an interactive shell command, but does not 
  redraw the screen or produce any extra messages.  

  Note: calling [1m/sys[22;0m with arguments from a [1mtrigger[22;0m is dangerous.  If not 
  written carefully, such a [1mtrigger[22;0m could allow anyone with access to the 
  server to gain access to your shell account.  

  The return value of [1m/sys[22;0m is the exit status of the shell if it exited 
  normally, -1 otherwise.  Note that UNIX shell commands usually return 0 for 
  success and nonzero for failure, which is the opposite of the TF convention. 

  See: [1m/sh[22;0m, [1m/quote[22;0m 

&/telnet

/telnet

  Usage: 

  [1m/TELNET[22;0m <[4mhost[24m> [<[4mport[24m>]
  ____________________________________________________________________________

  Connect to a line-based telnet host.  The telnet login port is used if 
  <[4mport[24m> is omitted.  

  Note that TF operates strictly in line-by-line mode, but telnetd (the server 
  running on the telnet login port) expects character-by- character mode.  So, 
  simple shell operations and anything else which is basically line-by-line 
  should work without much difficulty, but anything that tries to control the 
  screen or expects single keystroke input will [4mnot[24m work.  [1m/Telnet[22;0m is somewhat 
  useful, but not useful enough to alter the fundamental line-by-line nature 
  of TF.  If you want a general telnet client, you know where to find it.  

  TF supports most of the TELNET protocol (even if a command other than 
  [1m/telnet[22;0m was used to connect).  TF implements the TELNET options ECHO (lets 
  server control echoing of input), SGA (suppress GOAHEAD), EOR (allows use of 
  END-OF-RECORD in [1mprompts[22;0m), NAWS (allows TF to send window size information 
  to the server), TTYPE (allows server to ask about the terminal type), and 
  BINARY (allows transmission of 8-bit characters).  For TTYPE queries, TF 
  responds "TINYFUGUE", "ANSI-ATTR", "ANSI", and "UNKNOWN", in that order.  
  For information on TELNET protocol, see RFC 854 and 1123.  See also: 
  [1mprompts[22;0m.  

  See: [1m/addtelnet[22;0m, [1m/connect[22;0m, [1m%telopt[22;0m, [1m%binary_eol[22;0m, [1mprotocols[22;0m 

&/test

/test

  Usage: 

  [1m/TEST[22;0m <[4m[1mexpression[22;0m[24m>
  ____________________________________________________________________________

  [1m/test[22;0m evaluates the <[4m[1mexpression[22;0m[24m> and returns its value, also setting the 
  special [1mvariable[22;0m [1m%?[22;0m.  The return value may be any type (before version 4.0, 
  only integer values were allowed).  A new [1mvariable[22;0m scope is NOT created.  

  [1m/Test[22;0m can be useful for evaluating an [1mexpression[22;0m for its side effects, 
  ignoring the return value.  For example, the command "[1m/test[22;0m [1mkbdel[22;0m([1mkbpoint()[22;0m 
  - 1)" will perform a backspace, and "[1m/test[22;0m [1mregmatch[22;0m('foo(.*)', 'foobar')" 
  will assign "bar" to [1m%P1[22;0m.  

  Before version 3.5, [1m/test[22;0m was frequently used as the condition of an [1m/IF[22;0m or 
  [1m/WHILE[22;0m statement.  This is no longer needed, since [1m/IF[22;0m and [1m/WHILE[22;0m can now 
  take an [1mexpression[22;0m as a condition.  

  Before version 4.0, [1m/test[22;0m was sometimes used to set the return value of a 
  [1mmacro[22;0m, since a [1mmacro[22;0m's return value is that of the last command executed.  
  The preferred way to do this now is with [1m/return[22;0m or [1m/result[22;0m.  

  See: [1m/return[22;0m, [1m/if[22;0m, [1m/while[22;0m, [1mexpressions[22;0m, [1mevaluation[22;0m, [1mvariables[22;0m 

&/textencode

textencode()

  [1m/require[22;0m textencode.tf

  Function usage: 

  [1mtextencode[22;0m(<[4mstring[24m>)
  [1mtextdecode[22;0m(<[4mencodedstring[24m>)
  ____________________________________________________________________________

  [1mtextencode[22;0m converts <[4mstring[24m> to a form that contains only letters, digits, 
  and underscores.  [1mtextdecode[22;0m converts <[4mencodedstring[24m> (returned by a 
  previous call to [1mtextencode[22;0m) back to the original string.  

  These two functions can be useful for converting arbitrary text, such as a 
  world name or the name of a player on a mud, into a form that is safe to use 
  as part of a tf [1mvariable[22;0m or [1mmacro[22;0m name, or a filename.  

  The following example records the time a player connects to the mud, and is 
  safe even if the player name contains characters that are not legal in tf 
  [1mvariable[22;0m names:
  [1m/def[22;0m [1m-m[22;0mglob [1m-t[22;0m'{*} has connected.' record_connect_time = \
       [1m/set[22;0m connect_time_[1m$[[22;0m[1mtextencode[22;0m([1m{1}[22;0m)]=[1m$[[22;0m[1mtime[22;0m()] 

  See: [1mfunctions[22;0m 

&/fgrep
&/grep
&/egrep
&/readfile
&/writefile
&/head
&/wc
&/tee
&/copyio
&/fmt
&/uniq
&/randline
&textutil
&textutil.tf

Text Utilities

  [1m/REQUIRE[22;0m textutil.tf
  ____________________________________________________________________________

  The library file [1mtextutil.tf[22;0m defines several unix-like commands that are 
  particularly convenient when used with the [1m%|[22;0m pipe to redirect their input 
  or output.  

  In the descriptions below, <[4mfilename[24m> is the name of a file, and <[4min[24m> and 
  <[4mout[24m> are handles of [1mtfio streams[22;0m.  When <[4min[24m> is optional, its default is 
  [1mtfin[22;0m.  

  [1m/fgrep[22;0m [-cvi] <[4mpattern[24m> 
  [1m/grep[22;0m [-cv] <[4mpattern[24m> 
  [1m/egrep[22;0m [-cvi] <[4mpattern[24m> 
          These commands search [1mtfin[22;0m for lines that match the given pattern, 
          and by default prints those lines.  For [1m/fgrep[22;0m, a line must contain 
          <[4mpattern[24m> to match; for [1m/grep[22;0m, the [4mentire[24m line must match the [1mglob[22;0m 
          pattern <[4mpattern[24m>; for [1m/egrep[22;0m, it must match the [1mregexp[22;0m pattern 
          <[4mpattern[24m>.  
          [1mOptions[22;0m: 
          -c      print only the count of matching lines.  
          -v      select only non-matching lines.  
          -i      ignore case (for /fgrep and /egrep only; /grep always 
                  ignores case).  
          Note: these commands are not compatible with those defined in the 
          old library file [1mgrep.tf[22;0m.  

  [1m/readfile[22;0m <[4mfilename[24m> 
          Reads lines from <[4mfilename[24m> and writes them to [1mtfout[22;0m.  

  [1m/writefile[22;0m [-a] <[4mfilename[24m> 
          Reads lines from [1mtfin[22;0m and writes them to file <[4mfilename[24m>.  
          [1mOptions[22;0m: 
          -a      append to file instead of overwriting.  

  [1m/head[22;0m [-n<[4mcount[24m>] [<[4min[24m>] 
          Reads the first <[4mcount[24m> (default 10) lines from <[4min[24m> or [1mtfin[22;0m and 
          writes them to [1mtfout[22;0m.  

  [1m/wc[22;0m [-lwc] [<[4min[24m>] 
          Reads lines from <[4min[24m> or [1mtfin[22;0m and prints the count of lines, 
          space-separated words, and characters that were read.  
          [1mOptions[22;0m: 
          -l      Print the count of lines only.  
          -w      Print the count of words only.  
          -c      Print the count of characters only.  

  [1m/tee[22;0m <[4mout[24m> 
          Reads lines from [1mtfin[22;0m and echoes them to <[4mout[24m> and [1mtfout[22;0m.  

  [1m/copyio[22;0m <[4min[24m> <[4mout[24m> 
          Reads lines from <[4min[24m> and writes them to <[4mout[24m>.  This can be useful, 
          for example, when you want to send text from a [1mtfio[22;0m stream to a 
          command that reads only [1mtfin[22;0m: 

              /copyio <[4min[24m> o %| /<[4mcommand[24m>
              

  [1m/fmt[22;0m    Copies [1mtfin[22;0m to [1mtfout[22;0m, with adjacent non-blank lines joined.  

  [1m/uniq[22;0m   Copies [1mtfin[22;0m to [1mtfout[22;0m, with adjacent duplicate lines removed.  

  [1m/randline[22;0m [<[4min[24m>] 
          Copies one randomly selected line from <[4min[24m> or [1mtfin[22;0m to [1mtfout[22;0m.  

  ____________________________________________________________________________

  See: [1mtfio[22;0m, [1mevaluation[22;0m, [1msubstitution[22;0m, [1moldgrep[22;0m 

&/tick
&/tickon
&/tickoff
&/tickset
&/ticksize

/tick

  Usage: 

  [1m/REQUIRE[22;0m tick.tf

  [1m/tick[22;0m
  [1m/tickoff[22;0m
  [1m/tickon[22;0m
  [1m/tickset[22;0m
  [1m/ticksize[22;0m <[4mn[24m>
  ____________________________________________________________________________

  The [1m/tick*[22;0m commands implement dikumud tick counting, similar to tintin.  
  When the ticker is started with [1m/tickon[22;0m, it will warn you 10 seconds before 
  each tick, and print "TICK" on the tick.  

  The messages can be changed by redefining the /tick_warn (10-second warning) 
  and /tick_action ("TICK") macros.  You can make them perform any tf command, 
  not just printing.  

  It is up to you to start the ticker in synch with the mud.  If the mud 
  prints something on a tick, you can define a [1mtrigger[22;0m on that which calls 
  [1m/tickon[22;0m.  

  [1m/Tick[22;0m displays the time remaining until the next tick.  

  [1m/Tickoff[22;0m stops the ticker.  

  [1m/Tickon[22;0m and [1m/tickset[22;0m reset and start the ticker.  

  [1m/Ticksize[22;0m sets the tick period to <[4mn[24m> seconds (the default is 75).  

  See: [1m/require[22;0m, [1mtiming[22;0m, [1mprompts[22;0m 

&/time

/time

  Usage: 

  [1m/TIME[22;0m [<[4mformat[24m>]
  ____________________________________________________________________________

  Displays the current time.  <[4mFormat[24m> is described under "[1mftime()[22;0m".  If 
  <[4mformat[24m> is omitted, [1m%{time_format}[22;0m is used.  

  See: [1mtime()[22;0m, [1mftime()[22;0m, [1mmktime()[22;0m, [1m%TZ[22;0m, [1m%time_format[22;0m, [1m%clock[22;0m, [1midle()[22;0m 

&/toggle

/toggle

  Usage: 

  [1m/TOGGLE[22;0m <[4mvariable[24m>
  ____________________________________________________________________________

  If <[4mvariable[24m> has a value of 0, its value will be set to "1".  If <[4mvariable[24m> 
  has a non-zero value, its value will be set to "0".  

  See: [1mvariables[22;0m 

&/tr

/tr

  Usage: 

  [1m/REQUIRE[22;0m tr.tf

  [1m/TR[22;0m <[4mdomain[24m> <[4mrange[24m> <[4mstring[24m>
  ____________________________________________________________________________

  <[4mDomain[24m> and <[4mrange[24m> are lists of characters of equal length.  Each 
  character in <[4mstring[24m> that appears in <[4mdomain[24m> is translated to the 
  corresponding character in <[4mrange[24m>, and the resulting string is printed.  

  Example:
  command: [1m/def[22;0m biff = [1m/tr[22;0m OIS.  01Z! $[[1mtoupper[22;0m({*})]
  command: /biff TinyFugue is cool wares, dude. 
  output: T1NYFUGUE 1Z C00L WAREZ, DUDE!

  See: [1m/replace[22;0m, [1mexpressions[22;0m, [1mfunctions[22;0m 

&/act
&/trigpc
&/trigp
&/trigc
&/trig

/trig

  Usage: 

  [1m/TRIG[22;0m <[4mpattern[24m> = <[4mbody[24m>
  [1m/TRIGP[22;0m <[4mpriority[24m> <[4mpattern[24m> = <[4mbody[24m>
  [1m/TRIGC[22;0m <[4mchance[24m> <[4mpattern[24m> = <[4mbody[24m>
  [1m/TRIGPC[22;0m <[4mpriority[24m> <[4mchance[24m> <[4mpattern[24m> = <[4mbody[24m>
  ____________________________________________________________________________

  Creates an unnamed [1mmacro[22;0m that will [1mtrigger[22;0m on <[4m[1mpattern[22;0m[24m> and execute <[4mbody[24m>.  
  If <[4mchance[24m> is given with [1m/trigc[22;0m or [1m/trigpc[22;0m, it will be the percentage 
  probability of the [1mtrigger[22;0m going off; default is 100%.  If <[4mpriority[24m> is 
  given with [1m/trigp[22;0m or [1m/trigpc[22;0m, it will be the [1mpriority[22;0m of the [1mtrigger[22;0m; 
  default is 0.  The matching style of the [1mtrigger[22;0m is determined by the global 
  [1mvariable[22;0m [1m%{matching}[22;0m.  

  If the command fails it returns 0.  Otherwise, it creates a new [1mmacro[22;0m and 
  returns its (positive) number (useful in [1m/undefn[22;0m and [1m/edit[22;0m).  

  [1m/trig[22;0m is equivalent to: [1m/def[22;0m [1m-t[22;0m<[4mpattern[24m> = <[4mbody[24m>. 
  [1m/trigp[22;0m is equivalent to: [1m/def[22;0m [1m-p[22;0m<[4mpriority[24m> [1m-t[22;0m<[4mpattern[24m> = <[4mbody[24m>. 
  [1m/trigc[22;0m is equivalent to: [1m/def[22;0m [1m-c[22;0m<[4mchance[24m> [1m-t[22;0m<[4mpattern[24m> = <[4mbody[24m>. 
  [1m/trigpc[22;0m is equivalent to: [1m/def[22;0m [1m-p[22;0m<[4mpriority[24m> [1m-c[22;0m<[4mchance[24m> [1m-t[22;0m<[4mpattern[24m> = <[4mbody[24m>.

  Note: the [1m/trig[22;0m commands create [1mmacros[22;0m without names.  Thus each [1m/trig[22;0m 
  command will create a new [1mmacro[22;0m macro instead of replacing an old [1mmacro[22;0m.  
  For this reason, it is usually better to use [1m/def[22;0m and give your [1mmacros[22;0m 
  names.  

  See: [1mtriggers[22;0m, [1mevaluation[22;0m, [1mpatterns[22;0m, [1m/def[22;0m, [1m/untrig[22;0m 

&/trigger

/trigger

  Usage: 

  [1m/TRIGGER[22;0m [-ln] [-g] [-w[<[4mworld[24m>]] [-h[<[4mevent[24m>]] <[4mtext[24m>
  ____________________________________________________________________________

  Executes [1mmacros[22;0m with [1mtriggers[22;0m or [1mhook[22;0m arguments that match <[4mtext[24m>, just as 
  if <[4mtext[24m> had come from a [1msocket[22;0m or a hook event had occurred with <[4mtext[24m> as 
  its arguments.  The return value of [1m/trigger[22;0m is the number of (non-[1mquiet[22;0m) 
  [1mmacros[22;0m that were executed.  [1m/Trigger[22;0m is useful for debugging [1mtriggers[22;0m and 
  [1mhooks[22;0m.  

  [1mOptions:[22;0m 
  -g      Match "global" [1mtriggers[22;0m or [1mhooks[22;0m that were not defined with [1m/def[22;0m [1m-w[22;0m 
  -w<[4mworld[24m> 
          Match [1mtriggers[22;0m or [1mhooks[22;0m for <[4mworld[24m>, or the [1mcurrent[22;0m [1mworld[22;0m if <[4mworld[24m> 
          is omitted.  
  -h<[4mevent[24m> 
          Match [1mhooks[22;0m where <[4mevent[24m> matches the hook event and <[4mtext[24m> matches 
          the hook argument pattern.  Without -h, [1m/trigger[22;0m matches [1mtriggers[22;0m, 
          not [1mhooks[22;0m.  
  -n      Do not execute any of the matched macros; instead, display a list of 
          each macro that would have matched, including its [1mfallthru flag[22;0m, 
          [1mpriority[22;0m, and name.  (Note that if any macro in the list would have 
          executed [1msubstitute()[22;0m or [1m/substitute[22;0m, the macros listed after it may 
          not be correct.) 
  -l      Like -n, but list each macro in full, as if by [1m/list[22;0m.  
  If neither -g nor -w options are given, both are assumed.  That is, <[4mtext[24m> 
  is matched against global [1mtriggers[22;0m or [1mhooks[22;0m, as well as [1mtriggers[22;0m or [1mhooks[22;0m 
  for the [1mcurrent[22;0m [1mworld[22;0m.  

  See: [1mtriggers[22;0m, [1mhooks[22;0m, [1mdebugging[22;0m, [1m/def[22;0m 

&/false
&/:
&/true

/true

  Usage: 

  [1m/TRUE[22;0m
  [1m/FALSE[22;0m
  ____________________________________________________________________________

  [1m/True[22;0m does nothing, and returns nonzero.  

  [1m/False[22;0m does nothing, and returns zero.  

  /: is the same as [1m/true[22;0m.  

&/unbind

/unbind

  Usage: 

  [1m/UNBIND[22;0m <[4msequence[24m>
  ____________________________________________________________________________

  Removes a [1mmacro[22;0m with the keybinding <[4msequence[24m>.  

  See: [1mgeneral[22;0m, [1m/bind[22;0m, [1m/purge[22;0m 

&/undef

/undef

  Usage: 

  [1m/UNDEF[22;0m <[4mname[24m>... 
  ____________________________________________________________________________

  For each <[4mname[24m> given, [1m/undef[22;0m removes the definition of the [1mmacro[22;0m with that 
  name.  

  The return value of [1m/undef[22;0m is the number of macros that were removed.  

  See: [1mmacros[22;0m, [1m/def[22;0m, [1m/purge[22;0m, [1m/undefn[22;0m, [1m/undeft[22;0m, [1m/untrig[22;0m, [1m/unhook[22;0m 

&/undefn

/undefn

  Usage: 

  [1m/UNDEFN[22;0m <[4mnumber[24m> ... 
  ____________________________________________________________________________

  Removes [1mmacros[22;0m with the numbers specified in the arguments.  [1mMacro[22;0m numbers 
  can be determined with [1m/list[22;0m, or from the return value of the command used 
  to create the [1mmacro[22;0m.  

  See: [1mmacros[22;0m, [1m/def[22;0m, [1m/list[22;0m, [1m/purge[22;0m, [1m/undef[22;0m 

&/undeft

/undeft

  Usage: 

  [1m/UNDEFT[22;0m <[4mtrigger[24m>
  ____________________________________________________________________________

  Removes a [1mmacro[22;0m with a [1mtrigger[22;0m associated with it that is [1mtrigger[22;0med by the 
  pattern <[4mtrigger[24m>.  <[4mTrigger[24m> is matched against existing [1mtriggers[22;0m using 
  simple comparison.  

  See: [1mmacros[22;0m, [1mtriggers[22;0m, [1m/def[22;0m, [1m/purge[22;0m, [1m/undef[22;0m 

&/unhook

/unhook

  Usage: 

  [1m/UNHOOK[22;0m <[4mevent[24m> [<[4mpattern[24m>]
  ____________________________________________________________________________

  Removes a [1mmacro[22;0m with an associated [1mhook[22;0m on <[4mevent[24m> <[4mpattern[24m>.  

  See: [1mhooks[22;0m, [1m/hook[22;0m, [1m/purge[22;0m, [1m/undef[22;0m 

&/unset

/unset

  Usage: 

  [1m/UNSET[22;0m <[4mname[24m>
  ____________________________________________________________________________

  [1m/Unset[22;0m removes the value of [1mvariable[22;0m <[4mname[24m>.  

  [1m/Unset[22;0m returns 0 if an error occurred, nonzero otherwise.  

  See: [1mvariables[22;0m, [1m/set[22;0m, [1m/setenv[22;0m, [1m/let[22;0m 

&/untrig

/untrig

  Usage: 

  [1m/UNTRIG[22;0m [-a<[4mattrs[24m>] <[4mtrigger[24m>
  ____________________________________________________________________________

  Removes a [1mmacro[22;0m with an associated [1mtrigger[22;0m that is [1mtrigger[22;0med by the pattern 
  <[4mtrigger[24m> and has [1mattributes[22;0m <[4mattrs[24m>.  If -a<[4mattrs[24m> is omitted, -an is 
  assumed.  <[4mTrigger[24m> is matched against existing [1mtriggers[22;0m using simple 
  comparison.  

  See: [1mtriggers[22;0m, [1m/trig[22;0m, [1m/purge[22;0m, [1m/undef[22;0m 

&/unworld

/unworld

  Usage: 

  [1m/UNWORLD[22;0m <[4mname[24m>... 
  ____________________________________________________________________________

  For each <[4mname[24m> given, [1m/unworld[22;0m removes the definition of the world with 
  that name.  The [1mhistory[22;0m for removed worlds will be deleted, but some or all 
  of the lines may still exist in the global [1mhistory[22;0m.  

  The return value of [1m/unworld[22;0m is the number of worlds that were removed.  

  See: [1mworlds[22;0m, [1m/addworld[22;0m 

&/ver
&/version

/version

  Usage: 

  [1m/VERSION[22;0m
  [1m/VER[22;0m
  ____________________________________________________________________________

  [1m/Version[22;0m displays the TinyFugue version you're running and the operating 
  system for which it was compiled (if known).  

  [1m/Ver[22;0m displays an abbreviated version number.  

  The latest version of TF should be available for anonymous ftp from [1m 
  ftp.tcp.com in pub/mud/Clients/tf[22;0m.  

  Also see [1mhttp://tf.tcp.com/[22;0m for the latest info on TF.  

  See: [1m/changes[22;0m 

&/watchdog

/watchdog

  Usage: 

  [1m/WATCHDOG[22;0m [OFF|ON]
  [1m/WATCHDOG[22;0m <[4mn1[24m> [<[4mn2[24m>]
  ____________________________________________________________________________

  Sets the flag [1m%{watchdog}[22;0m.  This flag determines whether Fugue will watch 
  for identical lines and suppress them.  Fugue looks for lines which have 
  occurred <[4mn1[24m> times out of <[4mn2[24m> (<[4mn1[24m> defaults to 2 and <[4mn2[24m> to 5) and 
  suppress them, so with the default settings Fugue will suppress any lines 
  that have occurred 2 times out of the last 5.  

  The <[4mn1[24m> and <[4mn2[24m> settings for [1m/watchdog[22;0m are distinct from the <[4mn1[24m> and <[4mn2[24m> 
  settings for [1m/watchname[22;0m.  

  The flag [1m%{watchdog}[22;0m defaults to 0 (off).  

  See: [1m%watchdog[22;0m, [1m/watchname[22;0m 

&/watchname

/watchname

  Usage: 

  [1m/WATCHNAME[22;0m [OFF|ON]
  [1m/WATCHNAME[22;0m <[4mn1[24m> [<[4mn2[24m>]
  ____________________________________________________________________________

  Sets the flag [1m%{watchname}[22;0m.  This flag determines whether Fugue will watch 
  for players displaying lots of output.  Fugue looks for names which have 
  begun the line <[4mn1[24m> times out of <[4mn2[24m> (<[4mn1[24m> defaults to 4 and <[4mn2[24m> to 5) and 
  [1mgag[22;0m that person (with a message), so with the default settings Fugue will 
  [1mgag[22;0m any person whose name has begun 4 of the last 5 lines.  

  The <[4mn1[24m> and <[4mn2[24m> settings for [1m/watchname[22;0m are distinct from the <[4mn1[24m> and 
  <[4mn2[24m> settings for [1m/watchdog[22;0m.  

  The flag [1m%{watchname}[22;0m defaults to 0 (off).  

  See: [1m%watchname[22;0m, [1m/watchdog[22;0m 

&/while
&/do
&/done
&/while

/while

  Usage: 

  [1m/WHILE[22;0m ([4mexpr[24m) [4mlist[24m [1m/DONE[22;0m
  [1m/WHILE[22;0m [4mlist[24m [1m/DO[22;0m [4mlist[24m [1m/DONE[22;0m
  ____________________________________________________________________________

  The <[4mlist[24m>s may be any list of commands.  The return value of a <[4mlist[24m> is 
  the return value of the last command executed in the <[4mlist[24m>.  Each <[4mlist[24m> 
  must be terminated by "[1m%;[22;0m".  

  The <[4mlist[24m> or <[4mexpr[24m> following the [1m/WHILE[22;0m is called the condition.  The 
  condition is executed or evaluated, and if its result is non-zero, the next 
  <[4mlist[24m> is executed.  This sequence is repeated until the condition returns 
  zero.  

  The [1m/BREAK[22;0m command can be used within the loop to terminate the loop early.  
  The loop can also be terminated early by catching a SIGINT (usually 
  generated by typing ^C).  If the [1mvariable[22;0m [1m%{max_iter}[22;0m is non-zero, the loop 
  will terminate automatically if the number of iterations reaches that 
  number.  

  When [1m/WHILE[22;0m is used on the command line, "[1m%;[22;0m" command separation will be 
  done even if [1m%sub[22;0m=off.  Of course, full substitution will be done if 
  [1m%sub[22;0m=full.  

  Example: 


    [1m/def[22;0m count = \
        [1m/let[22;0m i=1%; \
        [1m/while[22;0m (i <= {1}) \
            say %{i}%; \
            [1m/let[22;0m i=$[i + 1]%; \
        [1m/done[22;0m

  The command "/count 10" will execute the commands "say 1", "say 2", ...  
  "say 10".  

  See: [1mevaluation[22;0m, [1m/test[22;0m, [1m/break[22;0m, [1m/for[22;0m 

&/world

/world

  Usage: 

  [1m/WORLD[22;0m [-lqnxfb] [<[4mworld[24m>]
  [1m/WORLD[22;0m <[4mhost[24m> <[4mport[24m>
  ____________________________________________________________________________

  If <[4mworld[24m> is already connected, "[1m/world[22;0m <[4mworld[24m>" is equivalent to "[1m/fg[22;0m 
  <[4mworld[24m>", and brings <[4mworld[24m> into the [1mforeground[22;0m.  If <[4mworld[24m> is not 
  connected, "[1m/world[22;0m <[4mworld[24m>" is equivalent to "[1m/connect[22;0m <[4mworld[24m>", and 
  attempts to open a connection to that world.  

  The second form is equivalent to "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>".  

  The -lqnxfb options are the same as those for [1m/fg[22;0m and [1m/connect[22;0m.  

  See: [1m/connect[22;0m, [1m/fg[22;0m 

&
&hilites
&gags
&underline
&reverse
&flash
&dim
&bell
&bold
&attrs
&attributes
&display attributes
&attribute

display attributes

  Many TF commands take an argument to specify an [1mattribute[22;0m list, containing 
  one or more of: "n" (none), "x" (exclusive), "g" ([1mgag[22;0m), "G" (nohistory), "L" 
  (nolog), "A" (noactivity), "u" (underline), "r" (reverse), "B" (bold), "b" 
  (bell), "h" ([1mhilite[22;0m), "E" (error), "W" (warning), or "C<[4mcolor[24m>" ([1mcolor[22;0m).  
  These [1mattributes[22;0m are used to display text associated with the command.  Use 
  commas to separate attributes within an attribute list; commas may be 
  omitted between single-letter attributes.  For example, "BuCred,Cbgyellow" 
  means bold underlined red text on a yellow background.  

  "None" ("n") is useful for finding macros without attributes (e.g.  "[1m/list[22;0m 
  -an") or for turning off attributes in the middle of a line (e.g.  "[1m/echo[22;0m -p 
  foo @{u}bar@{n} baz").  

  Normally, new attributes are combined with the pre-existing attributes.  But 
  if the new attributes include "x" (exclusive), the pre-existing display 
  attributes are turned off first.  So, for example, if one trigger with [1m-a[22;0mu 
  and another trigger with [1m-P[22;0mr match the same line, the whole line will be 
  underlined and part of it will also be reversed; but if the second trigger 
  had [1m-P[22;0mxr instead, then most of the line would be underlined, and part would 
  be reversed but not underlined.  

  The "G" (nohistory) [1mattribute[22;0m prevents the line from being recorded in 
  [1mhistory[22;0m.  The "L" (nolog) [1mattribute[22;0m prevents the line from being recorded in 
  a [1mlog[22;0m file.  

  The "A" (noactivity) [1mattribute[22;0m prevents the line from causing an [1mACTIVITY[22;0m 
  [1mhook[22;0m or a nonzero [1mmoresize[22;0m().  For example, the following command prevents 
  people connecting and disconnecting from counting as activity: 

        [1m/def[22;0m [1m-a[22;0mA [1m-q[22;0m [1m-t[22;0m"{*} has {*connected.}" noact_connect
    

  The "C<[4mname[24m>" ([1mColor[22;0m) [1mattribute[22;0m allows you to name a color.  The "C" must be 
  followed by the <[4mname[24m> of the color; a comma after the <[4mname[24m> can be used to 
  separate it from attributes that follow it.  Depending on your terminal and 
  how tf was compiled, there may be 8, 16, or 256 colors available.  See: 
  [1mcolor[22;0m.  

  The "h" ([1mhilite[22;0m), "E" (error), and "W" (warning) [1mattributes[22;0m is special.  If 
  specified, the [1mattributes[22;0m listed in the [1m%{hiliteattr}[22;0m, [1m%{error_attr}[22;0m, or 
  [1m%{warning_attr}[22;0m [1mvariable[22;0m, respectively, will be combined with the other 
  [1mattributes[22;0m listed.  For example, the commands 

        [1m/set[22;0m [1mhiliteattr[22;0m=r
        [1m/echo[22;0m -ahu foobar

  will display the word "foobar" with reverse and underline [1mattributes[22;0m.  
  [1m%{hiliteattr}[22;0m makes it easy to change the meaning of all your hilite macros 
  at once, without editing each one individually.  

  The "f" (flash) and "d" (dim) [1mattributes[22;0m are accepted for backward 
  compatiblity, but ignored.  

  All [1mattributes[22;0m except 'n' may be combined usefully.  (Even [1mgag[22;0ms can be 
  combined with other [1mattributes[22;0m: combining 'g' and 'B', for example, will [1mgag[22;0m 
  the text initially, but will display it as bold if it is recalled with 
  [1m/recall[22;0m -ag.) 

  It is possible to apply [1mattributes[22;0m to a part of a line, using [1m/partial[22;0m or 
  the [1m-P[22;0m option of [1m/def[22;0m.  If two or more partial [1mattributes[22;0m overlap, their 
  effects will be combined (unless the "x" attribute is used).  For example, 
  overlapping bold and reverse will appear bold and reverse; overlapping blue 
  and red will appear magenta.  

  Ansi [1mattribute[22;0m codes sent by the server will be interpreted by tf if 
  [1m%{emulation}[22;0m is set to "ansi_attr".  See: [1m%emulation[22;0m.  

  As of version 5.0, [1mattributes[22;0m in string values are preserved by just about 
  every string operation, including [1mcommands[22;0m, [1mvariables[22;0m, [1mexpression operators[22;0m, 
  [1mfunctions[22;0m, [1mregexp substitutions[22;0m, [1m$() command substitution[22;0m, and [1mstatus bar 
  field expressions[22;0m.  The [1minline_attr()[22;0m function can be used to convert 
  attribute codes within a string to actual attributes.  

  [1mAttributes[22;0m not supported by your terminal type will be stored, but not 
  displayed.  

&%catch_ctrls

%catch_ctrls

  See: [1m%emulation[22;0m 
&/color_off
&color
&colour
&colours
&256colors
&colors

colors

  Color is enabled by default.  To disable it, use "/color_off"; to re-enable 
  color using ANSI codes, use "/color_on".  

  The color [1mattribute[22;0m allows you to specify a foreground color with "C<[4mname[24m>" 
  or a background color with "Cbg<[4mname[24m>".  Any terminal that supports color 
  should support the 8 basic colors: [30mblack[0m (black), [31mred[0m, [32mgreen[0m, [33myellow[0m, [34mblue[0m, 
  [35mmagenta[0m, [36mcyan[0m, [37mwhite[0m (white).  (If you are reading this in tf, and the 
  previous sentence did not contain colored words, you do not have working 
  color support.  If it contained strange codes, you should do "/color_off" or 
  redefine the codes as described below.) The standard library defines these 8 
  basic colors with ANSI control codes, which will work on most terminals that 
  support color.  

  Many terminals also support brighter versions of the 8 basic colors, but may 
  need to be configured to do so.  On xterm, you may want to disable the 
  "boldColors" resource so that bold plus a normal color does not produce one 
  of these bright colors.  The bright color names are: gray, brightred, 
  brightgreen, brightyellow, brightblue, brightmagenta, brightcyan, or 
  brightwhite.  The standard library defines these 8 bright colors with ISO 
  6429 extension control codes, which will work on most terminals that support 
  16 colors.  

  Some newer terminals can display 256 colors.  If tf was built with the 
  "256colors" [1mfeature[22;0m, tf will recognize the following additional color names. 
  Names names of the form "rgb<[4mR[24m><[4mG[24m><[4mB[24m>" describe a color within a 6x6x6 color 
  cube: <[4mR[24m>, <[4mG[24m> and <[4mB[24m> are each a single digit between 0 and 5 that 
  specifies the brightness of the red, green, or blue component of the color.  
  For example, "rgb020" is a dark green, and "rgb520" is reddish orange.  
  Names of the form "gray<[4mN[24m>" describe a point on a grayscale, where <[4mN[24m> is 
  between 0 (dark) and 23 (light).  The standard library defines the "rgb*" 
  and "gray*" colors with xterm 256 color extension control codes.  

  To test the functionality and appearance of colors in tf, you can "[1m/load[22;0m 
  testcolor.tf".  

  You can use a defined color in any [1mattribute[22;0m string.  For example, to make 
  [1m/hilite[22;0m'd text appear blue, you can [1m/set[22;0m [1mhiliteattr[22;0m=Cblue.  

  To define your own control codes for terminals that don't accept the 
  predefined codes, you will need to edit the color [1mvariables[22;0m.  The code to 
  enable foreground or background color <[4mname[24m> is stored in a [1mvariable[22;0m called 
  [1m%{start_color_<[4mname[24m>}[22;0m or [1m%{start_color_bg<[4mname[24m>}[22;0m.  The code to turn off 
  colors is stored in [1m%{end_color}[22;0m.  These [1mvariables[22;0m may contain carat 
  notation and backslashed ascii codes in decimal, octal, or hexadecimal 
  (e.g., ESC is ^[, \27, \033, or \0x1B).  

  The default definition of [1m%end_color[22;0m is "\033[39;49;0m", which should work 
  on most ANSI-like terminals.  If this does not work on your terminal, then 
  try "[1m/set[22;0m [1mend_color[22;0m \033[30;47;0m" (for black on white) or "[1m/set[22;0m [1mend_color[22;0m 
  \033[37;40;0m" (for white on black).  

  If [1m%{emulation}[22;0m is set to "ansi_attr" (the default), then ANSI, ISO 6429, 
  and xterm 256 color extension codes sent by the server will be interpreted 
  by tf.  As a result, if the [1m%{start_color_<[4mname[24m>}[22;0m [1mvariables[22;0m are set 
  correctly for your terminal, tf will translate color codes from the server 
  into codes for your terminal, displaying them correctly even if your 
  terminal does not use the same codes the server sends.  See: [1m%emulation[22;0m.  

  Note for "screen(1)" users: to make 8-16 colors work under Screen, you need 
  the following screenrc settings: 

      termcap  xterm AF=\E[3%dm
      terminfo xterm AF=\E[3%p1%dm
      termcap  xterm AB=\E[4%dm
      terminfo xterm AB=\E[4%p1%dm
    

  To make 256 colors work under Screen, it must have been compiled with 
  "--enable-colors256", and you need the following screenrc settings: 

      terminfo xterm Co=256
      termcap  xterm Co=256
      termcap  xterm AF=\E[38;5;%dm
      terminfo xterm AF=\E[38;5;%p1%dm
      termcap  xterm AB=\E[48;5;%dm
      terminfo xterm AB=\E[48;5;%p1%dm
    

  Colors are numbered 0 through 255 in the order in which they are described 
  above, but refering to colors by their enumeration number is generally not 
  recommended, as the numbering is subject to change.  In particular, the 
  numbering and interpretation of background colors changed in version 5.0 
  beta 7.  

  See: [1mattributes[22;0m 

&copy
&warranty
&copying
&copyright

copyright

  TinyFugue - programmable mud client
  Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2002, 2003, 2004, 
  2005 Ken Keys 

  PCRE regexp package is Copyright (C) 1997-1999 University of Cambridge 

  For bug reports, questions, suggestions, etc., I can be reached by email at 
  hawkeye@tcp.com.  For problems specific to the OS/2 version, contact Andreas 
  Sahlbach at asa@stardiv.de.  Please see "[1mproblems[22;0m" before sending a bug 
  report.  

  This program is free software; you can redistribute it and/or modify it 
  under the terms of the [1mGNU General Public License[22;0m as published by the Free 
  Software Foundation; either version 2 of the [1mLicense[22;0m, or (at your option) 
  any later version.  

  This program is distributed in the hope that it will be useful, but WITHOUT 
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
  FITNESS FOR A PARTICULAR PURPOSE.  See the [1mGNU General Public License[22;0m for 
  more details.  

  You should have received a copy of the [1mGNU General Public License[22;0m along with 
  this program; if not, write to the Free Software Foundation, Inc., 675 Mass 
  Ave, Cambridge, MA 02139, USA.  

#sites
#find
#where
#www
#ftp
  The latest version of TinyFugue can be found at: 

    * [1m ftp://tf.tcp.com/pub/tinyfugue/[22;0m 
    * [1m http://ftp.tcp.com/pub/mud/Clients/tinyfugue/[22;0m 
    * Australia: [1m ftp://ftp.progsoc.uts.edu.au/pub/tinyfugue/[22;0m 

  Other ftp sites may not have the latest version.  

  Also see [1mhttp://tf.tcp.com/[22;0m for the latest info on TF.  

&debug
&debugger
&debugging

Debugging

  Debugging topics: 

    * [1m%kecho[22;0m - echo keyboard input 
    * [1m%mecho[22;0m - echo [1mmacros[22;0m as they execute 
    * [1m%qecho[22;0m - echo generated [1m/quote[22;0m text 
    * [1m%secho[22;0m - echo text sent to server 
    * [1m%pedantic[22;0m - enable extra warnings 
    * [1m%emulation[22;0m=debug - display nonprintable characters 
    * [1m%telopt[22;0m - echo telnet negotiation 
    * [1m/trigger[22;0m -n - see what [1mmacros[22;0m would be triggered 
    * [1m/addworld[22;0m -e - fake "loopback" server 
    * [1m/runtime[22;0m - measure running time of commands 

  See also: [1mhints[22;0m 

&syntax
&body
&macro body
&reentrance
&execution
&expansion
&evaluation

evaluation

  A Builtin Command is any of the commands listed under "[1mcommands[22;0m".  All 
  builtin commands start with "/".  All builtins have a return value, usually 
  nonzero for success and 0 for failure.  

  A [1mMacro[22;0m Command is a user-defined command.  [1mMacro[22;0m commands also start with 
  '/'.  The return value of a [1mmacro[22;0m is the return value of its body when 
  executed.  

#/!
#/@
#/#
#/
  A command starting with a single "/" is either a [1mMacro[22;0m Command or a [1mBuiltin[22;0m 
  Command.  If the "/" is followed by "!", the return value of the command 
  will be negated.  If the "/" or "/!" is followed by "@", the rest of the 
  word is interpreted as the name of a [1mBuiltin[22;0m Command.  If the "/" or "/!" is 
  followed by "#", the rest of the word is interpreted as the number of a 
  [1mmacro[22;0m.  If neither "@" nor "#" is used (the normal case), the rest of the 
  word is interpreted as a [1mmacro[22;0m if there is one with that name, otherwise it 
  is interpreted as the name of a [1mBuiltin Command[22;0m.  If the name does not match 
  any [1mmacro[22;0m or [1mBuiltin Command[22;0m, the [1mNOMACRO[22;0m [1mhook[22;0m is called.  
#

  A Simple Command is any command that does not start with "/".  The text of 
  such a command is sent directly to the [1mcurrent[22;0m world, if there is one.  The 
  return value of a simple command is 1 if the text is successfully sent to 
  the [1mcurrent[22;0m world, otherwise 0.  To send a line that starts with "/" without 
  having it interpreted as a [1mMacro[22;0m Command or [1mBuiltin[22;0m Command, use a leading 
  "//"; the first "/" will be stripped.  

  A Compound Command is one of [1m/IF[22;0m...[1m/ENDIF[22;0m or [1m/WHILE[22;0m...[1m/DONE[22;0m.  These are 
  described under separate help sections.  Their return value is that of the 
  last command executed.  

  A List is a sequence of commands separated by "[1m%;[22;0m" (separator) or "[1m%|[22;0m" 
  (pipe) tokens.  The commands are executed in sequence, but may be aborted 
  early with the [1m/RETURN[22;0m or [1m/BREAK[22;0m commands.  and the return value of the List 
  is the return value of the last command executed in the sequence.  An empty 
  List has a return value of 1.  

  Two commands separated by "[1m%|[22;0m" pipe token mentioned above will have the 
  output stream ([1mtfout[22;0m) of the first connected to the input stream ([1mtfin[22;0m) of 
  the second.  The first command runs to completion before the second command 
  begins; the second command should stop reading [1mtfin[22;0m when it becomes empty.  
  Simple Commands have no [1mtfin[22;0m or [1mtfout[22;0m, so they may not be piped.  The [1mtfout[22;0m 
  of a Compound Command may not be piped directly, but the output of a macro 
  that contains a Compound Command may be piped.  

  Some characters within a [1mmacro[22;0m body undergo substitution.  These special 
  characters are not interpreted as themselves, but cause some evaluation to 
  be performed, and the result substituted in place of these characters.  This 
  is described under "[1msubstitution[22;0m".  

#scope
#dynamic scope
  When an [1mexpansion[22;0m begins, a new scope is created.  Any local [1mvariables[22;0m 
  created during the [1mexpansion[22;0m will be placed in this new scope.  The scope 
  and all [1mvariables[22;0m in it are destroyed when the [1mexpansion[22;0m exits.  

  Any [1mvariable[22;0m reference will refer to the [1mvariable[22;0m with that name in the 
  nearest enclosing (i.e., most recently created) still existing scope.  This 
  is called "dynamic scope".  

  Lexical scope can be simulated to some extent by using [1mvariable[22;0m 
  substitutions with the correct number of "%"s instead of [1mvariable[22;0m 
  references.  (Remember, a "reference" uses the name by itself in an 
  [1mexpression[22;0m, like "[1m/test[22;0m foo"; a "substitution" uses "%" characters, like 
  "[1m/test[22;0m %foo").  

#
  See: [1mcommands[22;0m, [1mmacros[22;0m, [1msubstitution[22;0m, [1m/if[22;0m, [1m/while[22;0m 

&expnonvis
&expnonvisusal
&experimental non-visual mode

experimental non-visual mode

  TF 5.0 beta 5 has a new experimental non-visual mode ("expnonvis") that 
  fixes design flaws in traditional [1mnon-visual[22;0m mode.  I may get rid of 
  traditional non-visual mode in the future, so if you use it, I suggest you 
  try expnonvis mode now and let me know if you don't like it.  To enable 
  expnonvis mode, "[1m/set[22;0m expnonvis=on" and "[1m/set[22;0m visual=off".  You may also 
  want to "[1m/set[22;0m [1mkecho[22;0m=on" (see below).  

  In the new expnonvis mode, input is only ever visible on the bottom line.  
  It scrolls your input buffer left and right as needed to display the part of 
  the input buffer in the neighborhood of the cursor.  The part of the line 
  that is "off the left edge" of the screen is simply not visible.  In 
  traditional non-visual mode, that part of the line would scroll up, 
  polluting the output region with partial input lines.  

  The "only on bottom line" rule applies even when you hit return to execute 
  the input line.  Your input is erased, and the command is executed; it does 
  not scroll up.  If you want to see the input text scroll up, you can "[1m/set[22;0m 
  [1mkecho[22;0m=on"; this will print the entire input, not just the last segment of it 
  that fit within the screen width.  You may also want to set [1m%kecho_attr[22;0m so 
  that the echoed input is easily distinguishable from regular output.  

  The minimum amount of scrolling is determined by the %sidescroll variable, 
  which defaults to 1.  For slow terminals, you may wish to increase this.  
  Any movement that would exceed half the screen width does not use the 
  terminal's scrolling, but instead redraws the line.  

  The current implementation probably has a few bugs; if the screen display 
  ever appears incorrect, use ^R or ^L to redraw it.  I don't think there are 
  any fatal bugs, but it is possible that some remain, so don't try expnonvis 
  unless you don't mind crashing tf.  Terminals without the delete character 
  capability are not yet supported, but will be in the future.  

&logic
&math
&strings
&arithmetic
&expression
&expressions

expressions

  [1mExpressions[22;0m apply operators to numeric and string operands, and return a 
  result.  They can be used in [1m$[...] expression subs[22;0m, the condition of [1m/if[22;0m 
  and [1m/while[22;0m statements, the condition of [1m/def -E[22;0m, and as arguments to 
  [1m/return[22;0m, [1m/result[22;0m, and [1m/test[22;0m commands.  

#float
#real
#integer
#string
#dtime
#atime
#hours:minutes:seconds
#hours:minutes
#hh:mm
#hh:mm:ss
#types
#scalar
#scalars
#operands

Operands

  Operands can be any of: 

    * Integer constants (e.g., 42).  
    * Real decimal point constants ("reals", for short) containing a 
      decimal point (e.g., 12.3456789) or exponent (e.g., 1e-2) or both (e.g., 
      1.23e4).  
    * Time duration ("dtime") values of the form <[4mhours[24m>:<[4mminutes[24m>, 
      <[4mhours[24m>:<[4mminutes[24m>:<[4mseconds[24m>, or <[4mseconds[24m> (where <[4mseconds[24m> may contain a 
      decimal point followed by up to 6 digits), will be interpreted as real 
      seconds (e.g., 0:01:02.3 == 62.3), and can be used anywhere a number is 
      expected.  
    * Absolute time ("atime") values, in the form of a number with up to 6 
      decimal places.  On most systems, this represents the number of seconds 
      since 1970-01-01 00:00:00 UTC.  
    * Strings of characters, surrounded with quotes (", ', or `, with the 
      same kind of quote on each end), like "hello world".  
    * [1mVariable[22;0m references (see below) like visual.  
    * [1mVariable substitutions[22;0m (see below) like {visual} and {1}.  
    * [1mMacro substitutions[22;0m like ${COMPRESS_SUFFIX}.  
    * [1mCommand substitutions[22;0m like $([1m/listworlds[22;0m -s).  

  Named [1mvariables[22;0m may be accessed by simply using their name (with no leading 
  '%').  This is called a [1mvariable[22;0m reference, and is the preferred way of 
  using a [1mvariable[22;0m in an expression.  The special substitutions ([1m*[22;0m, [1m?[22;0m, [1m#[22;0m, [1m<[4mn[24m>[22;0m, 
  [1mL<[4mn[24m>[22;0m, [1mP<[4mn[24m>[22;0m, [1mR[22;0m) may not be used this way.  

  [1mVariable substitutions[22;0m of the form "[1m{selector}[22;0m" and "[1m{selector-default}[22;0m" may 
  be used.  They follow the same rules as [1mvariable substitution[22;0m in macros, 
  except that there is no leading '%', and the '{' and '}' are required.  The 
  special substitutions ([1m*[22;0m, [1m?[22;0m, [1m#[22;0m, [1m<[4mn[24m>[22;0m, [1mL<[4mn[24m>[22;0m, [1mP<[4mn[24m>[22;0m, [1mR[22;0m) are allowed.  

  Macro-style [1mvariable substitutions[22;0m beginning with '%' may also be used, but 
  are not recommended, since the multiple '%'s required in nested [1mmacros[22;0m can 
  quickly get confusing.  It always easier to use one of the above methods.  

#operators

Operators

  In the following list, operators are listed in groups, from highest to 
  lowest precedence.  Operators listed together have equal precedence.  The 
  letters in the table below correspond to the type of objects acted on by the 
  operators: [4mn[24m for numeric (integer or real); [4ms[24m for string; [4me[24m for any 
  expression.  All operators group left-to-right except assignment, which 
  groups right-to-left.  If any binary numeric operator is applied to two 
  integers, the result will be an integer, unless the result would overflow, 
  in which case it is converted to real.  If either operand is a real, the 
  other will be converted to real if it is not already a real, and the result 
  will be a real.  

  ([4me[24m)         Parentheses, for grouping.  

  [4mfunc[24m([4margs[24m)  Perform [1mfunction[22;0m <[4mfunc[24m> on arguments <[4margs[24m>.  (see: [1mfunctions[22;0m).  

  ![4mn[24m          Boolean NOT (1 if [4mn[24m==0, otherwise 0).  
  +[4mn[24m          Unary positive (useful for converting a string to a number).  
  -[4mn[24m          Unary negative.  
  ++[4mv[24m         Equivalent to ([4mv[24m := [4mv[24m + 1).  
  --[4mv[24m         Equivalent to ([4mv[24m := [4mv[24m - 1).  

  [4mn1[24m * [4mn2[24m     Numeric multiplication.  
  [4mn1[24m / [4mn2[24m     Numeric division.  Remember, if both operands are type integer, 
              the result will be truncated to integer.  

  [4mn1[24m + [4mn2[24m     Numeric addition.  
  [4mn1[24m - [4mn2[24m     Numeric subtraction.  

  [4mn1[24m = [4mn2[24m     Numeric equality (but easily confused with assignment; you are 
              advised to use == instead).  
  [4mn1[24m == [4mn2[24m    Numeric equality.  
  [4mn1[24m != [4mn2[24m    Numeric inequality.  
  [4ms1[24m =~ [4ms2[24m    String equality (case sensitive, [1mattribute[22;0m insensitive).  
  [4ms1[24m !~ [4ms2[24m    String inequality (case sensitive, [1mattribute[22;0m insensitive).  
  [4ms1[24m =/ [4ms2[24m    String [4ms1[24m matches [1mglob[22;0m pattern [4ms2[24m.  
  [4ms1[24m !/ [4ms2[24m    String [4ms1[24m does not match [1mglob[22;0m pattern [4ms2[24m.  
  [4mn1[24m < [4mn2[24m     Numeric less than.  
  [4mn1[24m <= [4mn2[24m    Numeric less than or equal.  
  [4mn1[24m > [4mn2[24m     Numeric greater than.  
  [4mn1[24m >= [4mn2[24m    Numeric greater than or equal.  

  [4mn1[24m & [4mn2[24m     Boolean AND.  [4mn2[24m will be evaluated if and only if [4mn1[24m is nonzero. 

  [4mn1[24m | [4mn2[24m     Boolean OR.  [4mn2[24m will be evaluated if and only if [4mn1[24m is zero.  

  [4mn[24m ? [4me1[24m : [4me2[24m 
  [4mn[24m ? : [4me2[24m    Conditional.  If [4mn[24m is nonzero, the result is the value of 
              [1mexpression[22;0m [4me1[24m; otherwise it is the value of [1mexpression[22;0m [4me2[24m.  If 
              [4me1[24m is omitted, the value of [4mn[24m is used in its place.  Note that 
              digits followed by a colon is interpreted as a dtime value, so 
              if the [4me2[24m operand of the ?: operator is an integer, you must 
              separate it from the colon (with a space or parenthesis, for 
              example).  

  [4mv[24m := [4me[24m      Assignment.  The identifier "[4mv[24m" refers to the [1mvariable[22;0m in the 
              nearest scope.  If not found, a new [1mvariable[22;0m is created at the 
              global level, as if by [1m/set[22;0m.  If [4mv[24m is a [1mspecial variable[22;0m, the 
              value of [4me[24m may need to be converted to the type of [4mv[24m, or the 
              assignment may fail altogther if the value is not legal for [4mv[24m.  
              The value of the assignment expression is the new value of [4mv[24m.  
  [4mv[24m += [4mn[24m      Equivalent to [4mv[24m := [4mv[24m + ([4mn[24m).  
  [4mv[24m -= [4mn[24m      Equivalent to [4mv[24m := [4mv[24m - ([4mn[24m).  
  [4mv[24m *= [4mn[24m      Equivalent to [4mv[24m := [4mv[24m * ([4mn[24m).  
  [4mv[24m /= [4mn[24m      Equivalent to [4mv[24m := [4mv[24m / ([4mn[24m).  

  [4me1[24m , [4me2[24m     Comma.  [1mExpressions[22;0m [4me1[24m and [4me2[24m are evaluated; the result is the 
              value of [4me2[24m.  Only useful if [4me1[24m has some side effect.  

  The comparison operators return 0 for false, nonzero for true.  The boolean 
  operators (& and |) stop evaluating as soon as the value of the [1mexpression[22;0m 
  is known ("short-circuit"), and return the value of the last operand 
  evaluated.  This does not affect the value of the [1mexpression[22;0m, but is 
  important when the second operand performs side effects.  

  Normal (non-[1menumerated[22;0m) [1mVariables[22;0m set with any of the assignment operators 
  keep the type of the [1mexpression[22;0m assigned to them.  This is different than 
  [1m/set[22;0m and [1m/let[22;0m, which always assign a string value to the [1mvariables[22;0m.  This 
  distinction is important for real numeric values, which lose precision if 
  converted to a string and back.  
#conversion

  All operands will be automatically converted to the type expected by the 
  operator.  

    * String to numeric: leading signs, digits, colons, and exponents are 
      interpreted as an integer, decimal (real), or dtime (real) value; e.g., 
      "12abc" becomes 12, "12.3junk" becomes 12.3, "0:01:02.3" becomes 
      0:01:02.3, and "xyz" becomes 0.  
    * Integer to real: straightforward.  
    * Real to integer: the fractional part is truncated.  
    * [1mEnumerated variable[22;0m to string: straightforward string value.  
    * [1mEnumerated variable[22;0m to numeric: one integer stands for each of the 
      allowed values.  "Off" is always 0, "on" is always 1, etc.  This makes 
      (![1mvisual[22;0m) and ([1mvisual[22;0m == 0) the same as ([1mvisual[22;0m =~ 'off').  
    * Integer to string: straightforward.  
    * Real to string: decimal notation if the exponent is greater than -5 
      and less than [1m%sigfigs[22;0m, otherwise exponential notation.  
    * Normal (non-[1menumerated[22;0m) [1mvariables[22;0m are treated as whatever type their 
      value has.  

#

Examples

  Given the [1mvariables[22;0m 

      [1m/set[22;0m X=5
      [1m/set[22;0m name=Hawkeye
      [1m/set[22;0m [1mvisual[22;0m=1

  here are some [1mexpressions[22;0m and their values: 

      [1mExpression[22;0m             Value   Comments
      ----                   -----   --------
      3 + X * 2                 13   3 + (5 * 2) = 13.
      "foo" =~ "bar"             0   "foo" is not identical to "bar".
      name =/ 'hawk*'            1   "Hawkeye" matches the [1mglob[22;0m "hawk*".
      X =~ "+5"                  0   X is interpreted as string "5".
      X == "+5"                  1   string "+5" is converted to integer 5.
      visual & (X > 0)           1   visual is nonzero, AND %X is positive.

  See: [1mfunctions[22;0m, [1m/test[22;0m, [1mevaluation[22;0m, [1mpatterns[22;0m 

&file
&files
&filenames
&filename expansion

filename expansion

  Certain strings are treated as filenames in tf ([1m%{TFHELP}[22;0m; [1m%{TFLIBDIR}[22;0m; 
  [1m%{TFLIBRARY}[22;0m; arguments to [1m/load[22;0m, [1mfwrite()[22;0m; etc.).  Those strings undergo 
  filename expansion as described below.  

  If <[4mfile[24m> begins with '~', all characters after the '~' up to the first '/' 
  or end of string are treated as a user name, and the '~' and user name are 
  replaced with the name of the home directory of that user.  If the user name 
  is empty, [1m%{HOME}[22;0m is substituted.  

  For example, if bob's home directory is /users/bob, then the command "[1m/load[22;0m 
  ~bob/macros.tf" will attempt to load the file /users/bob/macros.tf.  

  "~user" expansion is not supported on systems that do not have the 
  getpwnam() function.  

&function
&functions

functions

#macro
#function syntax

  In an [1mexpression[22;0m, a function operates on 0 or more arguments and returns a 
  result.  A function call is made with a function name, followed by a 
  parenthesized list of comma-separated arguments: "[4mname[24m([4marg1[24m, [4marg2[24m, ...  
  [4margN[24m)".  

  There are three kinds of objects that can be called as functions: [1mbuiltin 
  functions[22;0m, [1mmacros[22;0m, and builtin commands.  They are searched in that order, 
  so if a builtin function and a macro have the same name, using that name in 
  a function call will invoke the builtin function.  

  A macro called as a function can be called with any number of arguments; 
  each argument corresponds to a [1mpositional parameter[22;0m ([1m%1[22;0m, [1m%2[22;0m, etc.).  For 
  example, if "spam" is a macro, the function call 
  spam("foo", "bar", "baz")

  will set the parameters the same as in the command invocation 
  /spam foo bar baz

  The function call syntax allows [1mpositional parameters[22;0m to contain spaces, 
  which is not possible in the command syntax.  (Note: prior to version 4.0, a 
  macro called as a function could only take 0 or 1 arguments, and a single 
  argument was broken into positional parameters at whitespace.) A macro can 
  set its return value using [1m/return[22;0m or [1m/result[22;0m.  

  A builtin command called as a function can have 0 or 1 arguments; the 
  argument is treated as a command line.  For example, the function call 
  def("-t'{*} has arrived.' greet = :waves.")

  is the same as the command invocation 
  /def -t'{*} has arrived.' greet = :waves. 

  To evaluate a function for its "side effect" only, you can call it from 
  [1m/test[22;0m and ignore the return value (e.g., "[1m/test[22;0m [1mkbdel[22;0m(0)").  

#builtin
Builtin functions

  In the following list of builtin functions, the first letter of each 
  argument indicates its type: <[4ms[24m> for string, <[4mi[24m> for integer, <[4mr[24m> for real, 
  <[4mn[24m> for any numeric type, or <[4mf[24m> for flag (0 or "off"; or, 1 or "on").  

Mathematical functions

  Angles are in radians.  
#abs
#abs()
  [1mabs[22m([4mn[24m)  Absolute value of <[4mn[24m>.  Result has the same numeric type as <[4mn[24m>.  
#sin
#sin()
  [1msin[22m([4mr[24m)  (real) Sine of <[4mr[24m>.  
#cos
#cos()
  [1mcos[22m([4mr[24m)  (real) Cosine of <[4mr[24m>.  
#tan
#tan()
  [1mtan[22m([4mr[24m)  (real) Tangent of <[4mr[24m>.  
#asin
#asin()
  [1masin[22m([4mr[24m) 
          (real) Arcsine of <[4mr[24m>, in the range [-pi/2, pi/2].  <[4mr[24m> must be in 
          the domain [-1, 1].  
#acos
#acos()
  [1macos[22m([4mr[24m) 
          (real) Arccosine of <[4mr[24m>, in the range [0, pi].  <[4mr[24m> must be in the 
          domain [-1, 1].  
#atan
#atan()
  [1matan[22m([4mr[24m) 
          (real) Arctangent of <[4mr[24m>, in the range [-pi/2, pi/2].  
#exp
#exp()
  [1mexp[22m([4mr[24m)  (real) [4me[24m raised to the power <[4mr[24m>.  
#pow
#pow()
  [1mpow[22m([4mn1[24m, [4mn2[24m) 
          (real) <[4mn1[24m> raised to the power <[4mn2[24m>.  If <[4mn1[24m> is negative, <[4mn2[24m> 
          must be an integer.  
#sqrt
#sqrt()
  [1msqrt[22m([4mn[24m) 
          (real) Square root of <[4mn[24m> (same as [1mpow[22;0m(<[4mn[24m>, 0.5)).  
#log
#log()
#ln
#ln()
#log10
#log10()
  [1mln[22m([4mn[24m)   (real) Natural logarithm of <[4mn[24m>.  <[4mn[24m> must be positive.  The base B 
          logarithm of any number N can be found with the expression [1mln[22;0m(N) / 
          [1mln[22;0m(B).  
  [1mlog10[22m([4mn[24m) 
          (real) Base 10 logarithm of <[4mn[24m>.  <[4mn[24m> must be positive.  
#mod
#mod()
  [1mmod[22m([4mi1[24m,[4mi2[24m) 
          (int) Remainder of <[4mi1[24m> divided by <[4mi2[24m>.  
#trunc
#trunc()
  [1mtrunc[22m([4mr[24m) 
          (int) Integer part of <[4mr[24m>.  
#random
#rand
#rand()
  [1mrand[22m()  (int) Random integer in the range [0, system maximum].  
  [1mrand[22m([4mi[24m) 
          (int) Random integer in the range [0, <[4mi[24m> - 1].  
  [1mrand[22m([4mi1[24m,[4mi2[24m) 
          (int) Random integer in the range [<[4mi1[24m>, <[4mi2[24m>].  
#

Input/output functions

#
  [1mecho[22m([4ms1[24m [,[4mattrs[24m [,[4minline[24m [,[4mdest[24m]]]) 
          (int) Echoes <[4ms1[24m> to the screen or <[4mdest[24m> with [1mattributes[22;0m <[4mattrs[24m>, 
          interpreting inline [1mattribute[22;0m codes if the flag <[4minline[24m> is 1 or 
          "on".  See: "[1mecho()[22;0m".  
#
  [1msend[22m([4ms1[24m[, [4mworld[24m[, [4mflags[24m]]) 
          (int) Sends string <[4ms1[24m> to <[4mworld [24m>.  See [1msend()[22;0m.  
#fwrite
#fwrite()
  [1mfwrite[22m([4ms1[24m,[4ms2[24m) 
          Writes string <[4ms2[24m> to the end of file <[4ms1[24m>.  [1mfwrite()[22;0m is good for 
          writing a single line, but when writing multiple lines it is more 
          efficient to use [1mtfopen()[22;0m, a series of [1mtfwrite()[22;0m, and a [1mtfclose()[22;0m.  
          [1mDisplay attributes[22;0m in <[4ms2[24m> are not written.  
#tfopen
#tfopen()
  [1mtfopen[22m([4ms1[24m, [4ms2[24m) 
  [1mtfopen[22m() 
          (int) Open a [1mtfio stream[22;0m using file <[4ms1[24m> and mode <[4ms2[24m>.  See [1mtfio[22;0m.  
#tfclose
#tfclose()
  [1mtfclose[22m([4mi[24m) 
          (int) Close the [1mstream[22;0m indicated by handle <[4mi[24m>.  See [1mtfio[22;0m.  
#tfread
#tfread()
  [1mtfread[22m([4mi[24m, [4mv[24m) 
  [1mtfread[22m([4mv[24m) 
          (int) Read into variable <[4mv[24m> from the [1mstream[22;0m indicated by handle 
          <[4mi[24m>.  See [1mtfio[22;0m.  
#tfwrite
#tfwrite()
  [1mtfwrite[22m([4mi[24m, [4ms[24m) 
  [1mtfwrite[22m([4ms[24m) 
          (int) Write <[4ms[24m> to the [1mstream[22;0m indicated by handle <[4mi[24m>.  See [1mtfio[22;0m.  
#tfflush
#tfflush()
  [1mtfflush[22m([4mi[24m) 
          Flushes the [1mstream[22;0m indicated by handle <[4mi[24m>.  
  [1mtfflush[22m([4mi[24m, [4mf[24m) 
          Disables (if <[4mf[24m> is 0 or "off") or enables (if <[4mf[24m> is 1 or "on") 
          automatic flushing for the [1mstream[22;0m indicated by handle <[4mi[24m>.  See 
          [1mtfio[22;0m.  
#read
#read()
  [1mread[22m()  Obsolete.  Use [1mtfread()[22;0m instead.  
#

String functions

  String positions are always counted from 0.  Therefore the first character 
  of a string <[4ms[24m> is [1msubstr[22;0m(s, 0, 1), and the last character is [1msubstr[22;0m(s, 
  [1mstrlen[22;0m(s)-1).  

  Range checking is done on string positions.  Any position given outside the 
  allowed range will be silently forced to the closest value that is in the 
  range.  
#ascii
#ascii()
  [1mascii[22m([4ms[24m) 
          (int) Integer code of the first character of <[4ms[24m>, The character does 
          not have to be ASCII, but may be any character allowed by your 
          [1mlocale[22;0m.  
#char
#char()
  [1mchar[22m([4mi[24m) 
          (str) character with integer code <[4mi[24m>.  If <[4mi[24m> is outside the range 
          allowed by your [1mlocale[22;0m, it will be silently forced into the allowed 
          range.  
#tolower
#tolower()
  [1mtolower[22m([4ms[24m) 
  [1mtolower[22m([4ms[24m, [4mi[24m) 
          (str) Convert the first <[4mi[24m> (default all) characters in <[4ms[24m> to lower 
          case.  
#toupper
#toupper()
  [1mtoupper[22m([4ms[24m) 
  [1mtoupper[22m([4ms[24m, [4mi[24m) 
          (str) Convert the first <[4mi[24m> (default all) characters in <[4ms[24m> to upper 
          case.  
#pad
#pad()
  [1mpad[22m([[4ms[24m, [4mi[24m]...) 
          (str) There may be any number of (<[4ms[24m>, <[4mi[24m>) pairs.  For each pair, 
          <[4ms[24m> is padded with spaces to a length equal to the absolute value of 
          <[4mi[24m>.  If <[4mi[24m> is positive, <[4ms[24m> is right-justified (left-padded); If 
          <[4mi[24m> is negative, <[4ms[24m> is left-justified (right-padded).  The result 
          is the concatenation of all the padded strings.  
#regmatch
#regmatch()
  [1mregmatch[22m([4ms1[24m, [4ms2[24m) 
          (int) If string <[4ms2[24m> matches [1mregexp[22;0m <[4ms1[24m>, regmatch() returns a 
          positive integer indicating the number of captured substrings 
          (including [1m%P0[22;0m).  regmatch() returns 0 if string <[4ms2[24m> does not match 
          [1mregexp[22;0m <[4ms1[24m>.  After a successful match, captured substrings can 
          later be extracted using the P[4mn[24m [1mvariables[22;0m or [1m%P[4mn[24m[22;0m substitutions.  
          (See also: [1mregexp[22;0m) 
#
#replace()
  [1mreplace[22m([4ms1[24m, [4ms2[24m, [4ms3[24m) 
          (int) Returns <[4ms3[24m> with every occurance of <[4ms1[24m> replaced with <[4ms2[24m>.  
          See: "[1m/replace[22;0m".  
#strcat
#strcat()
  [1mstrcat[22m([4ms[24m...) 
          (str) Returns the concatenation of all string arguments.  
#strchr
#strchr()
  [1mstrchr[22m([4ms1[24m, [4ms2[24m) 
  [1mstrchr[22m([4ms1[24m, [4ms2[24m, [4mi[24m) 
          (int) Searches for any character of <[4ms2[24m> in <[4ms1[24m> starting at 
          position <[4mi[24m> (default 0), and returns the position if found, or -1 
          if not found.  If <[4mi[24m> is negative, it is counted as an absolute 
          value from the end of <[4ms[24m>.  
#strcmp
#strcmp()
  [1mstrcmp[22m([4ms1[24m, [4ms2[24m) 
          (int) Returns an integer less than, equal to, or greater than 0 if 
          <[4ms1[24m> is lexicographically less than, equal to, or greater than <[4ms2[24m>, 
          respectively.  
#strcmpattr
#strcmpattr()
  [1mstrcmpattr[22m([4ms1[24m, [4ms2[24m) 
          (int) Like [1mstrcmp()[22;0m, except that in order for the strings to be 
          considered equal, both their text and their attributes must be 
          equal.  In other words, [1mstrcmp[22;0m([1mencode_attr[22;0m(<[4ms1[24m>), [1mencode_attr[22;0m(<[4ms2[24m>)) 
          The ordering of attributes is not documented, and may change between 
          versions of tf.  
#strlen
#strlen()
  [1mstrlen[22m([4ms[24m) 
          (int) Length of string <[4ms[24m>.  
#strncmp
#strncmp()
  [1mstrncmp[22m([4ms1[24m, [4ms2[24m, [4mi[24m) 
          (int) Like [1mstrcmp()[22;0m, but compares only the first <[4mi[24m> characters of 
          <[4ms1[24m> and <[4ms2[24m>.  
#strrchr
#strrchr()
  [1mstrrchr[22m([4ms1[24m, [4ms2[24m) 
  [1mstrrchr[22m([4ms1[24m, [4ms2[24m, [4mi[24m) 
          (int) Searches backward in <[4ms1[24m> starting at position <[4mi[24m> (default: 
          end of <[4ms1[24m>) for any character of <[4ms2[24m>, and returns the position if 
          found, or -1 if not found.  If <[4mi[24m> is negative, it is counted as an 
          absolute value from the end of <[4ms[24m>.  
#strrep
#strrep()
  [1mstrrep[22m([4ms[24m, [4mi[24m) 
          (str) Returns a string containing <[4mi[24m> repetitions of <[4ms[24m>.  
#strstr
#strstr()
  [1mstrstr[22m([4ms1[24m, [4ms2[24m) 
  [1mstrstr[22m([4ms1[24m, [4ms2[24m, [4mi[24m) 
          (int) Searches for <[4ms2[24m> in <[4ms1[24m> starting at position <[4mi[24m> (default 
          0), and returns the position if found, or -1 if not found.  
#substr
#substr()
  [1msubstr[22m([4ms[24m, [4mi1[24m) 
  [1msubstr[22m([4ms[24m, [4mi1[24m, [4mi2[24m) 
          (str) Substring of <[4ms[24m>, starting at position <[4mi1[24m>, with length <[4mi2[24m>. 
          If <[4mi2[24m> is omitted, it defaults to the remaining length of <[4ms[24m>.  If 
          <[4mi1[24m> or <[4mi2[24m> is negative, they are counted as absolute values from 
          the end of <[4ms[24m>.  
#strip_attr
#strip_attr()
  [1mstrip_attr[22m([4ms[24m) 
          (str) Returns <[4ms[24m> with all display [1mattributes[22;0m removed.  
#inline_attr
#inline_attr()
#decode_attr
#decode_attr()
  [1mdecode_attr[22m([4ms1[24m [, [4ms2[24m]) 
          (str) Returns <[4ms1[24m> with "@{<[4mattr[24m>}" codes interpeted as display 
          [1mattributes[22;0m, as in [1m/echo[22;0m -p.  If present, <[4ms2[24m> is a string of 
          [1mattributes[22;0m that will be applied to the entire string (as in [1m/echo[22;0m 
          -a<[4ms2[24m>).  
#encode_attr
#encode_attr()
  [1mencode_attr[22m([4ms[24m) 
          (str) Returns <[4ms[24m> with display [1mattributes[22;0m encoded in "@{<[4mattr[24m>}" 
          form.  
#decode_ansi
#decode_ansi()
  [1mdecode_ansi[22m([4ms[24m) 
          (str) Returns <[4ms[24m> with attribute control codes interpeted as display 
          [1mattributes[22;0m, and, if [1m%expand_tabs[22;0m is on, tabs are expanded to spaces 
          according to [1m%tabsize[22;0m.  Any attributes originally on <[4ms[24m> are [4mnot[24m 
          copied to the result.  The attribute control codes recognzied 
          include ANSI codes, ISO 6429 16-color extension codes, and xterm 
          256-color extension codes.  
#encode_ansi
#encode_ansi()
  [1mencode_ansi[22m([4ms[24m) 
          (str) Returns <[4ms[24m> with display [1mattributes[22;0m encoded in terminal 
          control code form.  The control codes generated include ANSI codes, 
          ISO 6429 16-color extension codes, and xterm 256-color extension 
          codes.  
#
  [1mtextencode[22m([4ms[24m) 
          (str) Returns <[4ms[24m> converted to a form containing only letters, 
          digits, and underscores.  See [1mtextencode()[22;0m.  
#
  [1mtextdecode[22m([4ms[24m) 
          (str) Converts <[4ms[24m>, the result of [1mtextencode()[22;0m, back to its original 
          form.  See [1mtextencode()[22;0m.  
#

Keyboard buffer functions

#kbdel
#kbdel()
  [1mkbdel[22m([4mi[24m) 
          (int) Delete from the cursor to position <[4mi[24m> in the input buffer.  
          Returns the new position.  
#kbgoto
#kbgoto()
  [1mkbgoto[22m([4mi[24m) 
          (int) Move the cursor to position <[4mi[24m> in the input buffer.  Returns 
          the new position (which may be different than <[4mi[24m> if <[4mi[24m> would put 
          the cursor outside the buffer).  
#kbhead
#kbhead()
  [1mkbhead[22m() 
          (str) Return the current input up to the cursor.  
#kblen
#kblen()
  [1mkblen[22m() 
          (int) Length of current input line.  
#kbmatch
#kbmatch()
  [1mkbmatch[22m() 
  [1mkbmatch[22m([4mi[24m) 
          (int) Finds one of "()[]{}" under or to the right of the position 
          <[4mi[24m> (default: cursor position), and returns the position of its 
          match, or -1 if not found.  (See also: [1mkeybindings[22;0m) 
#kbpoint
#kbpoint()
  [1mkbpoint[22m() 
          (int) Return the current position of the cursor in input.  
#kbtail
#kbtail()
  [1mkbtail[22m() 
          (str) Return the current input after the cursor.  
#kbwordleft
#kbwordleft()
  [1mkbwordleft[22m() 
  [1mkbwordleft[22m([4mi[24m) 
          (int) Position of the beginning of the word left of <[4mi[24m> within the 
          input buffer.  <[4mi[24m> defaults to the current cursor position.  (See 
          also: [1m%wordpunct[22;0m) 
#kbwordright
#kbwordright()
  [1mkbwordright[22m() 
  [1mkbwordright[22m([4mi[24m) 
          (int) Position just past the end of the word right of <[4mi[24m> within the 
          input buffer.  <[4mi[24m> defaults to the current cursor position.  (See 
          also: [1m%wordpunct[22;0m) 
#keycode
#keycode()
  [1mkeycode[22m([4ms[24m) 
          (str) String generated by typing the key labeled <[4ms[24m>, as defined in 
          the termcap entry corresponding to the value of [1m%TERM[22;0m.  See also: 
          [1mkeybindings[22;0m.  
#

Information functions

#time
#time()
  [1mtime[22m()  (atime) Absolute system time in seconds, to the nearest microsecond 
          (typically measured since 1970-01-01 00:00:00 UTC).  See also: 
          [1mcputime()[22;0m, [1mmktime()[22;0m, [1midle()[22;0m, [1msidle()[22;0m, [1m/time[22;0m, [1mftime()[22;0m.  
#cputime
#cputime()
  [1mcputime[22m() 
          (real) CPU time used by tf, or -1 if not available.  The resolution 
          depends on the operating system.  See also: [1m/runtime[22;0m, [1mtime()[22;0m, [1m/time[22;0m. 
#columns
#columns()
  [1mcolumns[22m() 
          (int) Number of columns on the screen.  See also: [1mhooks (RESIZE)[22;0m, 
          [1mlines()[22;0m, [1mwinlines()[22;0m, [1m%COLUMNS[22;0m.  
#lines
#lines()
  [1mlines[22m() 
          (int) Number of lines on the screen.  To get the number of lines in 
          the output window, use [1mwinlines()[22;0m.  See also: [1mhooks (RESIZE)[22;0m, 
          [1mwinlines()[22;0m, [1mcolumns()[22;0m, [1m%LINES[22;0m.  
#winlines
#winlines()
  [1mwinlines[22m() 
          (int) Number of lines in the output window.  See also: [1mhooks 
          (RESIZE)[22;0m, [1mlines()[22;0m, [1mcolumns()[22;0m.  
#morepaused
#morepaused()
  [1mmorepaused[22m([[4ms1[24m]) 
          (int) Returns 1 if output of world <[4ms1[24m> is paused (by [1mmore[22;0m or ([1mdokey[22;0m 
          pause).  If omitted, <[4ms1[24m> defaults to the current world.  See also: 
          [1mmoresize()[22;0m.  
#morescroll
#morescroll()
  [1mmorescroll[22m([4mi[24m) 
          (int) If <[4mi[24m> is positive, this function scrolls <[4mi[24m> lines of text 
          from the window buffer into the window from the bottom.  If <[4mi[24m> is 
          negative, it reverse-scrolls abs(<[4mi[24m>) lines of text from the window 
          buffer into the window from the top.  If abs(<[4mi[24m>) is larger than one 
          screenful, the actual scrolling is skipped, and only the end result 
          is displayed.  Returns the number of lines actually scrolled.  
#moresize
#moresize()
  [1mmoresize[22m([[4ms1[24m [, [4ms2[24m]]) 
          (int) Returns a line count for world <[4ms2[24m>, or the current world if 
          <[4ms2[24m> is omitted.  If <[4ms1[24m> is omitted or blank, the count is the 
          number of lines below the bottom of the output window (i.e., queued 
          at a [1mmore[22;0m prompt).  If <[4ms1[24m> contains "n", it counts only new lines 
          that have never been seen, not lines that had been displayed and 
          then reverse scrolled off.  If <[4ms1[24m> contains "l", it counts only 
          lines that match the current [1m/limit[22;0m.  "n" and "l" may be combined.  
          If all lines that would be counted have the "A" (noactivity) 
          [1mattribute[22;0m, the result will normally be 0.  But if <[4ms1[24m> contains "a", 
          lines with "A" [1mattributes[22;0m are counted anyway.  In all cases, the 
          count is the number of physical (after wrapping) lines.  Note that a 
          return value of 0 does not necessarily indicate that output is not 
          paused; it may be the case that output is paused and there are just 
          0 lines below the bottom of the window, or that all the lines have 
          the "A" [1mattribute[22;0m.  Use [1mmorepaused()[22;0m, to tell if output is paused.  
          See also: [1mmorepaused()[22;0m, [1mnactive()[22;0m.  
#nactive
#nactive()
  [1mnactive[22m() 
          (int) Number of active worlds (ie, worlds with unseen text).  
  [1mnactive[22m([4ms[24m) 
          (int) Number of unseen lines in world <[4ms[24m>.  
          Note: when [1mnactive()[22;0m (with or without arguments) is called from a 
          [1mtrigger[22;0m, the line that caused the [1mtrigger[22;0m is not counted by 
          [1mnactive()[22;0m because it has not yet been fully processed (for example, 
          a lower [1mpriority[22;0m [1mtrigger[22;0m might [1mgag[22;0m the line).  [1mnactive[22;0m(<[4ms[24m>) is 
          equivalent to [1mmoresize[22;0m("n", <[4ms[24m>).  See also: [1mmoresize()[22;0m.  
#world_info
#world_info()
  [1mworld_info[22m([4ms1[24m, [4ms2[24m) 
          (str) Return the value of field <[4ms2[24m> of world <[4ms1[24m>, 
  [1mworld_info[22m([4ms2[24m) 
          (str) Return the value of field <[4ms2[24m> of the [1mcurrent world[22;0m.  
  [1mworld_info[22m() 
          (str) Return the name of the [1mcurrent world[22;0m.  See [1mworlds[22;0m.  
#fg_world
#fg_world()
  [1mfg_world[22m() 
          (str) Returns the name of the [1mworld[22;0m associated with the [1mforeground[22;0m 
          [1msocket[22;0m.  
#is_connected
#is_connected()
  [1mis_connected[22m() 
          (int) Returns 1 if the [1mcurrent[22;0m [1msocket[22;0m is connected, 0 otherwise.  
  [1mis_connected[22m([4ms[24m) 
          (int) Returns 1 if [1mworld[22;0m <[4ms[24m> is connected, 0 otherwise.  See also 
          [1mis_open()[22;0m.  
#is_open
#is_open()
  [1mis_open[22m() 
          (int) Returns 1 if the [1mcurrent[22;0m [1msocket[22;0m is open, 0 otherwise.  
  [1mis_open[22m([4ms[24m) 
          (int) Returns 1 if [1mworld[22;0m <[4ms[24m> is open, 0 otherwise.  
#idle
#idle()
  [1midle[22m()  (dtime) Number of seconds (to the nearest microsecond) since the 
          last keypress.  
  [1midle[22m([4ms[24m) 
          (dtime) Number of seconds (to the nearest microsecond) since the 
          last text was received on the [1msocket[22;0m connected to [1mworld[22;0m <[4ms[24m>, or -1 
          on error.  
#sidle
#sidle()
  [1msidle[22m() 
  [1msidle[22m([4ms[24m) 
          (dtime) Number of seconds (to the nearest microsecond) since the 
          last text was sent on the [1mcurrent socket[22;0m or the [1msocket[22;0m connected to 
          [1mworld[22;0m <[4ms[24m>, or -1 on error.  
#nlog
#nlog()
  [1mnlog[22m()  (int) Number of open log files.  
#nmail
#nmail()
  [1mnmail[22m() 
          (int) Number of monitored mail files containing unread mail.  See 
          [1mmail[22;0m.  
#nread
#nread()
  [1mnread[22m() 
          (int) Returns a positive number if a [1mread[22;0m from the keyboard is in 
          progress, 0 otherwise.  
#getpid
#getpid()
  [1mgetpid[22m() 
          (int) The operating system's process id for tf.  
#systype
#systype()
  [1msystype[22m() 
          (str) System type: "unix" (includes MacOS X), "os/2", or "cygwin32". 
#

Other functions

#
  [1maddworld[22m([4mname[24m, [4mtype[24m, [4mhost[24m, [4mport[24m, [4mchar[24m, [4mpass[24m, [4mfile[24m, [4muse_proxy[24m) 
          Defines or redefines a [1mworld[22;0m.  See "[1maddworld()[22;0m".  
#
  [1meval[22m([4ms1[24m [, [4ms2[24m]) 
          (str) Evaluates <[4ms1[24m> as a [1mmacro body[22;0m.  See: [1m/eval[22;0m.  
#filename
#filename()
  [1mfilename[22m([4ms[24m) 
          (str) Performs filename expansion on <[4ms[24m> as described under 
          "[1mfilenames[22;0m".  
#
  [1mftime[22m([4ms[24m,[4mn[24m) 
  [1mftime[22m([4ms[24m) 
  [1mftime[22m() 
          (str) Formats a system time <[4mn[24m> (obtained from [1mtime()[22;0m) according to 
          format <[4ms[24m>, or prints an error message and returns an empty string 
          if <[4mn[24m> is out of range.  See: [1mftime()[22;0m.  
#mktime
#mktime()
  [1mmktime[22m([4myear[24m [, [4mmonth[24m [, [4mday[24m [, [4mhour[24m [, [4mminute[24m [, [4msecond[24m [, 
  [4mmicrosecond[24m]]]]]]) 
          (atime) Returns the system time in seconds of the date in the local 
          [1mtime zone[22;0m represented by the arguments.  Returns -1 if the arguments 
          do not represent a valid date.  Omitted [4mmonth[24m or day arguments 
          default to 1; other omitted arguments default to 0.  See: [1m%TZ[22;0m, 
          [1mftime()[22;0m, [1m/time[22;0m, 
#
  [1mgetopts[22m(s1, s2) 
          (int) Parse macro options according to format <s1>.  See 
          "[1mgetopts()[22;0m".  
#test()
  [1mtest[22m(s) 
          Interprets the contents of the string s as an expression and returns 
          the result.  See also: [1m/test[22;0m, [1m/expr[22;0m.  
#status_fields()
  [1mstatus_fields[22m([i]) 
          Returns the list of fields of status row i, or row 0 if i is 
          omitted.  [1mstatus area[22;0m.  
#
  [1msubstitute[22m(s [,attrs [,inline]]) 
          (int) Replaces trigger text.  See "[1m/substitute[22;0m".  
#

  Examples: 

  Capitalize first letter of string <s>: 

        [1mstrcat[22;0m([1mtoupper[22;0m([1msubstr[22;0m(s, 0, 1)), [1msubstr[22;0m(s, 1))

  Extract the number from a string <dbref> of the form "(#123PML)": 

        0 + [1msubstr[22;0m(dbref, [1mstrchr[22;0m(dbref, "#") + 1)

  See: [1mexpressions[22;0m 

&getopts
&getopts()

getopts()

  Usage: 

  getopts(<[4moptions[24m> [, <[4minit[24m>])
  ____________________________________________________________________________

  [1mgetopts()[22;0m is a [1mfunction[22;0m that parses and validates [1mmacro[22;0m options according to 
  the format described by <[4moptions[24m>.  <[4mOptions[24m> is a list of letters that 
  [1mgetopts()[22;0m will accept.  If a letter is followed by ":", the option will be 
  expected to have a string argument; if a letter is followed by "#", the 
  option will be expected to have a [1mexpression[22;0m argument that evaluates to a 
  (possibly signed) integer; if a letter is followed by "@", the option will 
  be expected to have a time argument.  The option syntax accepted by 
  [1mgetopts()[22;0m is a subset of that accepted by builtin tf commands, as described 
  under "[1moptions[22;0m".  

  When an option is found, [1mgetopts()[22;0m creates a new local [1mvariable[22;0m named 
  "opt_X", where "X" is the letter of the option.  If an argument is expected, 
  the [1mvariable[22;0m will get that argument as its value; otherwise, the [1mvariable[22;0m 
  will have a value of "1".  

  If <[4minit[24m> is given, the [1mvariables[22;0m corresponding to each letter of <[4moptions[24m> 
  are initialized to <[4minit[24m> before processing the command line options.  If 
  <[4minit[24m> is omitted, the [1mvariables[22;0m are not initialized, so if [1mvariables[22;0m with 
  the same names already exist and are not set by [1mgetopts()[22;0m, they will be 
  unchanged.  You can use this to set the [1mvariables[22;0m to some default value 
  before calling [1mgetopts()[22;0m.  

  The argument list will be shifted to discard the options that have been 
  parsed, so [1m%{*}[22;0m will contain the remainder of the arguments, without the 
  options.  

  If [1mgetopts()[22;0m encounters an error, it will print an error message and return 
  0; otherwise, it returns nonzero.  

  Using [1mgetopts()[22;0m, [1m/escape[22;0m, and [1m/split[22;0m, it is possible to write [1mmacros[22;0m that 
  behave just like builtin tf commands.  

  Here's a contrived example to illustrate how [1mgetopts()[22;0m works: 


    [1m/def[22;0m foo = \
        [1m/if[22;0m (!getopts("abn#s:", "")) [1m/return[22;0m 0%; [1m/endif[22;0m%; \
        [1m/echo[22;0m option a:  %{opt_a}%;\
        [1m/echo[22;0m option b:  %{opt_b}%;\
        [1m/echo[22;0m option n:  %{opt_n}%;\
        [1m/echo[22;0m option s:  %{opt_s}%;\
        [1m/echo[22;0m args: [1m%{*}[22;0m%;\
        [1m/split[22;0m [1m%{*}[22;0m%;\
        [1m/echo[22;0m name: [1m%{P1}[22;0m%;\
        [1m/echo[22;0m body: [1m%{P2}[22;0m

  Now, all of these commands are equivalent: 

        /foo -a -b -n5 -s"can't stop" -- whiz = bang biff
        /foo -a -b -n5 -s'can\'t stop' whiz = bang biff
        /foo -n5 -ba -s`can't stop` whiz = bang biff
        /foo -as"can't stop" -bn5 whiz = bang biff

  and produce this output: 

        option a:  1
        option b:  1
        option n:  5
        option s:  can't stop
        args: whiz = bang biff
        name: whiz
        body: bang biff

  But the command: 

        /foo -a -x whiz = bang biff

  produces the error: 

        % foo: invalid option 'x'
        % foo: options: -ab -n<integer> -s<string>

  See: [1mexpressions[22;0m, [1mfunctions[22;0m, [1moptions[22;0m, [1m/escape[22;0m, [1m/split[22;0m 

&style
&tips
&hints

hints

  Some hints and style tips: 

    * Use a high-[1mpriority[22;0m [1mtrigger[22;0m on yourself to prevent loops.  Say I 
      want to throw a tomato at anyone who says the word "tomato", and I write 
      the following [1mtrigger[22;0m: 

        [1m/def[22;0m -t"*tomato*" tomato = :throws a tomato at [1m%1[22;0m.

      If Ben uses the word tomato, I will [1mtrigger[22;0m, and then see the text 
      "Hawkeye throws a tomato at Ben." That text contains the word tomato, 
      which will [1mtrigger[22;0m me again, creating an infinite loop.  One way to 
      prevent this is by creating a high-[1mpriority[22;0m [1mtrigger[22;0m on myself which does 
      nothing: 

        [1m/def[22;0m -p99999 -t"{Hawkeye|You}*" anti_loop

      Now, when I see "Hawkeye throws a tomato at Ben", the /anti_loop [1mtrigger[22;0m 
      will catch it before /tomato does, so I won't loop.  

    * Use multiple lines, spacing, and indentation in [1m/load[22;0m files.  
      Normally, commands must be on one line.  But in files read with [1m/load[22;0m, 
      if a line ends in '\', the following line will have leading whitespace 
      stripped and the two lines will be joined.  This makes it much easier 
      (for humans) to read complex [1mmacros[22;0m.  Compare the two identical [1mmacros[22;0m 
      below, and see which is easier to read.  


        [1m/def[22;0m count=[1m/let[22;0m i=1%;[1m/while[22;0m (i<=[1m%1[22;0m) say %i%;[1m/let[22;0m i=$[i+1]%;[1m/done[22;0m


        [1m/def[22;0m count = \
            [1m/let[22;0m i=1%; \
            [1m/while[22;0m ( i <= [1m%1[22;0m ) \
                say %i%; \
                [1m/let[22;0m i=$[i + 1]%; \
            [1m/done[22;0m

    * Use comments in [1m/load[22;0m files.  Complicated [1mmacros[22;0m are much easier to 
      read if you include a short comment describing the arguments to the 
      [1mmacro[22;0m and what it does.  Lines beginning with ';' or '#' are comments, 
      and are ignored during [1m/load[22;0m.  

    * Name all [1mtriggers[22;0m and [1mhooks[22;0m.  If you ever need to [1m/load[22;0m a file a 
      second time, [1mtriggers[22;0m, [1mhilite[22;0ms, [1mhooks[22;0m, and [1mgag[22;0ms without names may be 
      duplicated.  But if they are named, old copies of [1mmacros[22;0m will be 
      replaced with new copies of [1mmacros[22;0m with the same name.  Naming [1mmacros[22;0m 
      also makes them easier to manipulate with commands like [1m/list[22;0m and 
      [1m/undef[22;0m.  

    * Don't use "weird" characters in [1mmacro[22;0m names.  Although any [1mmacro[22;0m 
      name is legal, some characters can have unwanted [1mexpansion[22;0m effects.  
      Weird characters are also harder to read.  You should stick to letters, 
      numbers, and '_' characters.  In particular, avoid '~' characters, since 
      they are used in library [1mmacros[22;0m.  

    * Use local [1mvariables[22;0m instead of global [1mvariables[22;0m if possible.  This 
      avoids conflicts when two [1mmacros[22;0m use a [1mvariable[22;0m with the same name.  If 
      you're using a [1mvariable[22;0m in an [1mexpression[22;0m, use [1m/let[22;0m first to initialize 
      the [1mvariable[22;0m in the local scope.  But remember, when you use a [1mvariable[22;0m 
      reference (by name, as opposed to a [1mvariable[22;0m substitution using "%"), TF 
      uses dynamic scoping (see: [1mscope[22;0m).  

    * Use [1mvariable[22;0m references instead of %-substitutions in [1mexpressions[22;0m.  
      Because [1mmacro[22;0m bodies are [1mexpanded[22;0m, something like "[1m/test[22;0m [1m%1[22;0m" is prone to 
      problems if [1m%1[22;0m contains any special characters.  But by using a [1mvariable[22;0m 
      reference you can avoid this problem; for example, "[1m/test[22;0m {1}".  

    * "[1m/set[22;0m [1mpedantic[22;0m=on" to make tf generate warnings about some potential 
      problems.  

    * "[1m/set[22;0m [1mdefcompile[22;0m=on" to see syntax errors in a [1mmacro[22;0m when you define 
      it, instead of waiting until you first run it.  

    * "[1m/set[22;0m [1mmecho[22;0m=on" to see what commands are being executed, or [1m/connect[22;0m 
      to a normal or [1mconnectionless[22;0m [1msocket[22;0m defined with "[1m/addworld[22;0m -e" to see 
      what you're sending to the [1msocket[22;0m.  

    * "[1m/set[22;0m [1memulation[22;0m=debug" and "[1mtelopt[22;0m=on" to see exactly what the 
      socket is sending to tf.  

    * Use the -n or -l option of [1m/trigger[22;0m to see a list of [1mtrigger[22;0m [1mmacros[22;0m 
      that would match a given line.  

  See also [1mdebugging[22;0m.  

&history

history

  Associated topics: 

  [1mscrollback[22;0m
  [1m/recall[22;0m
  [1m/quote[22;0m
  [1m/histsize[22;0m
  [1m/recordline[22;0m
  ^<[4mstring1[24m>^<[4mstring2[24m>
  Recall previous/next keys ([1mRECALLB[22;0m/[1mRECALLF[22;0m, default ^P and ^N)
  Recall beginning/end keys ([1mRECALLBEG[22;0m/[1mRECALLEND[22;0m, default ^[< and ^[>)
  Search backward/forward keys ([1mSEARCHB[22;0m/[1mSEARCHF[22;0m, default ^[p and ^[n)

  TinyFugue stores lines in 4 different types of [1mhistory[22;0m lists.  Input [1mhistory[22;0m 
  records the last 100 non-repeated commands from the keyboard, including the 
  current line.  Each world has a world [1mhistory[22;0m, which stores 1000 lines of 
  output from that world.  Local history stores 100 lines of output generated 
  by TF, i.e.  anything that didn't come from a world.  Global [1mhistory[22;0m is an 
  integrated list of 1000 lines from TF and every world.  The [1mhistory[22;0m sizes 
  can be changed with the [1m/histsize[22;0m command and the [1m%{histsize}[22;0m [1mvariable[22;0m.  

  [1m/recall[22;0m is used to display text from any of the [1mhistory[22;0m lists.  The [1m/quote[22;0m 
  command may be used to quote out of any [1mhistory[22;0m list using the [1m/quote[22;0m # 
  feature.  

#^^
#^
  Typing ^<[4mstring1[24m>^<[4mstring2[24m> finds the last command in the input [1mhistory[22;0m 
  containing <[4mstring1[24m>, replaces <[4mstring1[24m> with <[4mstring2[24m>, and executes the 
  modified line.  

#
  The recall keys replace the current input with a line from the input [1mhistory[22;0m 
  list.  See [1m/dokey[22;0m for details.  

  See also [1m/log[22;0m.  
&hook
&hooks

hooks

  Associated commands: 
  [1m/def[22;0m    define a [1mmacro[22;0m with any fields 
  [1m/hook[22;0m   define a [1mhook[22;0m [1mmacro[22;0m 
  [1m/unhook[22;0m 
          undefine a [1mhook[22;0m [1mmacro[22;0m 
  [1m/trigger -h[22;0m 
          call a [1mhook[22;0m [1mmacro[22;0m 

  [1mHooks[22;0m are a method of calling a [1mmacro[22;0m based on special events within TF, in 
  much the same way as [1mtriggers[22;0m call [1mmacros[22;0m based on text received from a 
  [1msocket[22;0m.  [1mHooks[22;0m allow the user to customize the behavior of TinyFugue and 
  automate special functions.  

  A [1mhook[22;0m definition has two parts: an <[4mevent[24m> and a <[4mpattern[24m>.  When the event 
  occurs, the [1mmacro[22;0m will be executed if the arguments supplied by the event 
  match the [1mmacro[22;0m's <[4mpattern[24m> (see the section on "[1mpatterns[22;0m").  

  If multiple [1mhooks[22;0m match the same event and pattern, one or more are selected 
  as described under "[1mpriority[22;0m".  

  Most [1mhooks[22;0m have a default message associated with them, which will be 
  displayed with the [1mattributes[22;0m of the [1mhook[22;0m if one is defined.  Thus a [1mhook[22;0m 
  with a [1mgag[22;0m [1mattribute[22;0m will suppress the display of the message.  

  [1mHook[22;0m may have [1mmulti-shots[22;0m, in which case it and the [1mmacro[22;0m it is associated 
  with is removed after executing a specified number of times.  

  In the table below, 'A' or 'W' in the message column indicates the location 
  of the message display: 
  A       the message is printed to the the [1malert stream[22;0m (i.e., the status 
          line).  
  W       the message is printed to the appropriate [1mworld's stream[22;0m; if that 
          world is not the foreground world, the message is also printed to 
          the [1malert stream[22;0m.  
  Otherwise, the message is sent to the the [1mtferr stream[22;0m (i.e., the screen).  

    Event Name  Arguments       Default Message or Action
    ----------  ---------       -------------------------
#ACTIVITY
    ACTIVITY    world           A '% Activity in world <[4mworld[24m>'
                                  (called only the first time activity
                                  occurs on a given [1msocket[22;0m.)
#BAMF
    BAMF        world           W '% [1mBamfing[22;0m to <[4mworld[24m>'
#BGTEXT
    BGTEXT      world             Text was printed in background world <[4mworld[24m>
#BACKGROUND
#BGTRIG
    BGTRIG      world           A '% [1mTrigger[22;0m in world <[4mworld[24m>'
#CONFAIL
    CONFAIL  world, reason      W '% [1mConnection[22;0m to <[4mworld[24m> failed: <[4mreason[24m>'
#CONFAIL
    CONFAIL     world, reason   W '% Unable to [1mconnect[22;0m to <[4mworld[24m>: <[4mreason[24m>'
#CONFLICT
    CONFLICT    [1mmacro[22;0m             '% <[4mmacro[24m> conflicts with builtin command.'
#CONNECT
    CONNECT     world, cipher   W '% [1mConnected[22;0m to <[4mworld[24m>[ using <[4mcipher[24m>].'
#ICONFAIL
    ICONFAIL  world, reason     W '% [1mIntermediate connection[22;0m to <[4mworld[24m> failed: <[4mreason[24m>'
#DISCONNECT
    DISCONNECT  world, reason   W '% [1mConnection[22;0m to <[4mworld[24m> closed: <[4mreason[24m>.'
                                  (Called if you send the server's disconnect
                                  command (e.g., "QUIT") or [1msocket[22;0m closes, but
                                  not if you use [1m/dc[22;0m.)
#KILL
    KILL        pid               ([1mprocess[22;0m ends)
#LOAD
    LOAD        file              '% [1mLoading[22;0m commands from file <[4mfile[24m>'
#LOADFAIL
    LOADFAIL    file, reason      '% <[4mfile[24m>: <[4mreason[24m>'
#LOG
    LOG         file              '% [1mLogging[22;0m to file <[4mfile[24m>'
#LOGIN
    LOGIN       world             ([1mautomatic login[22;0m)
#MAIL
    MAIL        file            A '% You have new mail in <[4mfile[24m>.'
                                  (See: [1mmail[22;0m).
#MORE
    MORE                          '[1m--More--[22;0m' (reverse bold)
#NOMACRO
    NOMACRO     name              '% <[4mname[24m>: No such command or macro'
#PENDING
    PENDING     world           W '% Hostname lookup for <[4mworld[24m> in progress'
    PENDING     world, address  A '% Trying to [1mconnect[22;0m to <[4mworld[24m>: <[4maddress[24m>'
#PREACTIVITY
    PREACTIVITY world             (Activity in world <[4mworld[24m>)
                                  (called only the first time activity
                                  occurs on a given [1msocket[22;0m.)
#PROCESS
    PROCESS     pid               [1mprocess[22;0m starts
#PROMPT
    PROMPT      text              <[4mtext[24m> is a partial (unterminated) line
                                  from the server.  See "[1mprompts[22;0m"
#PROXY
    PROXY       world             ([1mproxy[22;0m connection to <[4mworld[24m> has completed)
#REDEF
    REDEF       obj_type, name    '% Redefined <[4mobj_type[24m> <[4mname[24m>'
#RESIZE
    RESIZE      columns, lines    (window was resized)
                                  (see also: [1mcolumns()[22;0m, [1mlines()[22;0m)
#SEND
    SEND        text              (text sent to [1mcurrent[22;0m [1msocket[22;0m)
                                  (see note below ("[1mhooks[22;0m"))
#SHADOW
    SHADOW      var_name          '% Variable <[4mvar_name[24m> overshadows global'
#SHELL
    SHELL       type, command     '% Executing <[4mtype[24m>: <[4mcommand[24m>'
#SIGHUP
    SIGHUP                        (SIGHUP [1msignal[22;0m caught; tf may terminate)
#SIGTERM
    SIGTERM                       (SIGTERM [1msignal[22;0m caught; tf terminates)
#SIGUSR1
    SIGUSR1                       (SIGUSR1 [1msignal[22;0m caught; no effect)
#SIGUSR2
    SIGUSR2                       (SIGUSR2 [1msignal[22;0m caught; no effect)
#WORLD
    WORLD       world           W ([1mforeground socket[22;0m changes)

#
  Notes: 

  The -w and -T options to [1m/def[22;0m can be used to restrict [1mhooks[22;0m to matching only 
  when the [1mcurrent[22;0m world matches the world or world type.  

  When a [1mmacro[22;0m is defined with the same name as an existing [1mmacro[22;0m, the REDEF 
  [1mhook[22;0m will be called, [4munless[24m the new [1mmacro[22;0m is identical to the original.  

  BGTRIG used to be called BACKGROUND, and the old name still works.  Its "% 
  Trigger in world " message can be quieted for individual triggers by 
  defining them with [1m/def[22;0m [1m-q[22;0m, or for all triggers with "/def -ag -hBGTRIG".  

  The SEND [1mhook[22;0m is called whenever text would be sent to the [1mcurrent[22;0m [1msocket[22;0m.  
  If a SEND [1mhook[22;0m matches the text that would be sent, the text is not sent 
  (unless the hook was defined with [1m/def -q[22;0m), and the [1mhook[22;0m is executed 
  instead.  By default, SEND [1mhooks[22;0m are not invoked from [1msend()[22;0m or [1m/send[22;0m, but 
  there is an option to do so; SEND [1mhooks[22;0m are invoked from any [1mmacro[22;0m or 
  command line that sends plain text.  

  When successfully connected to a new [1msocket[22;0m, these events occur: 1) If this 
  is a [1mproxy[22;0m connection, the PROXY [1mhook[22;0m is called; 2) If there is a file 
  associated with the world, the file will be loaded (and the LOAD [1mhook[22;0m will 
  be called).  3) If this is not a [1mproxy[22;0m connection, the CONNECT [1mhook[22;0m is 
  called; 4) If [1m%{login}[22;0m is on, a character and password are defined, and this 
  is not a [1mproxy[22;0m connection, the [1mLOGIN[22;0m [1mhook[22;0m is called.  

  When a (non-[1mgag[22;0mged) line is displayed in a background world, the PREACTIVITY 
  hook is called immediately before the line is displayed, and the ACTIVITY 
  hook is called immediately after.  Thus, functions like [1mmoresize()[22;0m and 
  [1mnactive()[22;0m will give different results in the two hooks.  Any activity 
  generated by a PREACTIVITY hook will not recursively cause another 
  PREACTIVITY or ACTIVITY event.  

  The SIGHUP, SIGTERM, SIGUSR1, and SIGUSR2 [1mhooks[22;0m are called when the 
  corresponding [1msignal[22;0m is received.  If SIGHUP is received and SIGHUP was not 
  ignored when tf was started, or SIGTERM was received, TF will terminate 
  immediately after executing the [1mhook[22;0m; if the [1mhook[22;0m calls any commands with 
  delayed effects (a [1m/repeat[22;0m or [1m/quote[22;0m without -S, a nonblocking [1m/connect[22;0m, 
  etc), those effects will not occur before termination.  

  A hook's message, if any, is displayed (with its [1mattributes[22;0m) before any of 
  the hooked [1mmacros[22;0m are executed.  Prior to version 5.0, the message was 
  displayed after executing hooked [1mmacros[22;0m, which may have generated their own 
  output, which was sometimes confusing.  

  Examples: 


      [1m/hook[22;0m ACTIVITY|DISCONNECT {TT|SM}* = [1m/world[22;0m [1m%1[22;0m

  will cause TF to automatically switch to TT or SM if either becomes active 
  or disconnected.  

      [1m/def[22;0m -T'tiny.mush' -hSEND mush_escape = [1m/send[22;0m - $([1m/escape[22;0m \%[ [1m%*[22;0m)

  will catch any line sent to a world of type 'tiny.mush', escape all 
  occurrences of '%', '[' and '\' within that line, and send the new line 
  instead of the original.  This is useful for avoiding unwanted 
  interpretation of '%', '[', and '\' on TinyMUSH servers.  

      [1m/hook[22;0m SIGHUP = [1m/log[22;0m on%; [1m/recall[22;0m /10

  will [1mlog[22;0m the last 10 lines of output if you are unexpectedly disconnected 
  from your tf session.  

#CONNETFAIL
  The CONNETFAIL hook, which existed in versions 5.0 alpha 13 through 5.0 beta 
  6, has been replaced with the [1mICONFAIL[22;0m hook.  
#

  See also: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mpriority[22;0m, [1msignals[22;0m.  

&topics

topics

  Topics marked with + are new; those marked with * have changed since the 
  last version.  Many topics also have subtopics that are not listed here 
  (e.g., individual [1mvariables[22;0m, [1mhooks[22;0m, and functions).  


   *[1mcopying[22;0m       copyright; no warranty
    [1mintro[22;0m         introduction to tf
    [1mstartup[22;0m       how to start tf
    [1minterface[22;0m     how input works
    [1mtfrc[22;0m          personal config file
   *[1mvisual[22;0m        split-screen mode
   *[1mcommands[22;0m      list of commands
   *[1mworlds[22;0m        defining worlds
   *[1mpatterns[22;0m      glob and regexp pattern matching
   *[1mvariables[22;0m     state and environment
   *[1mglobals[22;0m       special tf variables
    [1mattributes[22;0m    special text display
    [1mprompts[22;0m       using LP/Diku prompts
    [1mproblems[22;0m      bugs, core dumps, etc.
   *[1mevaluation[22;0m    macro body execution
    [1mmacros[22;0m        user-defined commands
   *[1msockets[22;0m       world connections
    [1mhistory[22;0m       recall and logging
    [1mpriority[22;0m      trigger/hook selection
   *[1mkeybindings[22;0m   keyboard operations
    [1mcolor[22;0m         terminal color codes
   *[1mprotocols[22;0m     protocols supported by TF
    [1mexpressions[22;0m   math and string operations
    [1mtriggers[22;0m      automatic command execution based on incoming text
   *[1mhooks[22;0m         automatic command execution based on tf events
   +[1mmail[22;0m          mail checking
    [1mlibrary[22;0m       macros and variables in stdlib.tf
   *[1mtools[22;0m         extra commands in tools.tf
    [1mutilities[22;0m     useful extra command files
   *[1mprocesses[22;0m     timed commands and command quoting
   *[1msubs[22;0m          arithmetic, command, [1mmacro[22;0m, and variable substitutions
   *[1mfunctions[22;0m     special [1mexpression[22;0m operations
   *[1mhints[22;0m         some hints and style tips for [1mmacro[22;0m programming
   +[1mdebugging[22;0m     debugging your [1mmacros[22;0m
   *[1mtfio[22;0m          output, error, and world streams
   *[1mproxy[22;0m         connecting to outside hosts via a proxy server (firewall)
   +[1mlocale[22;0m        multi-language support
    

&typing
&user
&interface

interface

  Any input line that does not begin with '/' will be sent directly to the 
  [1mforeground[22;0m world, if there is one.  A line starting with more than one '/' 
  will be sent to the forground [1msocket[22;0m after having the first '/' removed.  
  (Exception: lines may be caught with a SEND [1mhook[22;0m before being sent; see 
  "[1mhooks[22;0m").  

  Any input line beginning with a single '/' is a TF command, which will be 
  interpreted as described in "[1mevaluation[22;0m".  

  Input lines of the form "^old^new" will cause TF to search backward in the 
  input [1mhistory[22;0m for a line containing "old", replace that text with "new", and 
  execute the modified command.  See: [1mhistory[22;0m.  

  Many special functions, such as backspace, can be performed by special keys 
  or sequences of keys.  See "[1mdokey[22;0m" for a complete list.  You can also define 
  your own commands and bind them to key sequences.  See [1mbind[22;0m.  

  Normally, user input does not undergo the [1mexpansion[22;0m that [1mmacro[22;0m bodies 
  undergo.  The [1m/eval[22;0m command can be used to [1mexpand[22;0m text before executing it.  
  If the [1m%{sub}[22;0m flag is on (it is off by default), user input undergoes [1mmacro[22;0m 
  body [1mexpansion[22;0m without the [1m%{sub}[22;0m flag.  The [1m%{sub}[22;0m flag also applies to 
  text generated by "^old^new" history commands.  See: [1mhistory[22;0m, [1m/sub[22;0m, 
  [1mvariables[22;0m 

  Control characters may be input literally.  A literal control character will 
  be displayed in the input window in printable form in bold reverse.  Note 
  that since most control keys are also parts of the default keybindings, it 
  will usually be necessary to type ^V ([1m/dokey[22;0m LNEXT) to avoid invoking the 
  keybinding.  

  International characters may be input if your [1mlocale[22;0m is set to a locale that 
  supports them and your system supports locales.  Any input character that is 
  not valid in your locale and has the high bit set (normally generated by 
  holding the "meta" key) will be translated to ESC plus that character with 
  the high bit stripped (assuming [1m%meta_esc[22;0m is on).  This allows M-x and ^[x 
  to invoke the same ^[x keybinding.  See [1mlocale[22;0m, [1m%meta_esc[22;0m, [1m%istrip[22;0m.  

  If standard input is not a terminal, [1mvisual[22;0m mode will not be allowed, and tf 
  will continue to operate even after EOF is read, until /quit or something 
  else terminates it.  

  See also: [1mvisual[22;0m, [1moptions[22;0m 

&intro
&me
&newbie
&tinyfugue
&introduction

introduction

  TinyFugue is a MUD client.  It helps you connect to a MUD, in a much more 
  convenient manner than telnet.  You can connect to a mud world using the 
  same syntax as you would with telnet: "[1mtf[22;0m <[4mhost[24m> <[4mport[24m>".  Or, while running 
  tf, you can use "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>".  To make things easier, you can 
  give names to worlds, using [1m/addworld[22;0m, and then use "[1mtf[22;0m <[4mname[24m>" and 
  "[1m/connect[22;0m <[4mname[24m>".  If you store a set of [1m/addworld[22;0m commands in a file, TF 
  can read them automatically when it starts.  You can even connect to more 
  than one world at the same time, and switch between them.  See: [1m/connect[22;0m, 
  [1m/fg[22;0m, [1m/addworld[22;0m, [1mworlds[22;0m, [1mtfrc[22;0m.  

  Normally, TF will split the screen into two windows: one for input, and one 
  for output.  TF will display useful information on the line separating the 
  two windows, such as the name of the [1mforeground[22;0m world.  See: [1mwindows[22;0m.  

  Any line you type that starts with a single '/' is a tf command.  Anything 
  else you type will be sent to the mud.  See: [1minterface[22;0m, [1mcommands[22;0m.  

  You can define your own tf commands, called [1mmacros[22;0m.  The simplest type of 
  [1mmacro[22;0m is just an abbreviation or alias for a longer command or commands.  
  But [1mmacros[22;0m can also perform much more powerful tasks.  See: [1mmacros[22;0m, [1m/def[22;0m.  

  You can tell tf to watch for certain patterns in the text from the mud, and 
  then do special things when it sees that pattern: display the text in a 
  special way ([1mhilite[22;0m); not display the text at all ([1mgag[22;0m); execute a [1mmacro[22;0m 
  command ([1mtrigger[22;0m); or do any combination of these.  See: [1mattributes[22;0m, 
  [1mtriggers[22;0m, [1m/hilite[22;0m, [1m/gag[22;0m, [1m/trig[22;0m, [1m/def[22;0m.  

  TF keeps a [1mhistory[22;0m of every line it prints, every line sent by the mud, and 
  every command you enter.  You can see those histories using [1m/recall[22;0m.  You 
  can also have this text saved in a file using [1m/log[22;0m.  See: [1mhistory[22;0m, [1m/recall[22;0m, 
  [1m/log[22;0m.  

  See also: [1mtopics[22;0m 

&keys
&key
&kbbind
&kbfunc
&kbfunc.tf
&kbbind.tf
&keybindings

keybindings

Default keybindings

  TF's default command line editing keys are similar to those in emacs and 
  bash.  In addition, several features may be invoked by more than one 
  keybinding, and TF has keybindings for unique features like switching the 
  [1mforeground[22;0m [1msocket[22;0m.  

  Here, and throughout the TF documentation, the notation "^X" means the 
  character generated by typing the X key while holding the CTRL key.  Also, 
  "^[" can be more easily typed just by pressing the ESC key.  [1m/Def -b[22;0m and 
  [1m/bind[22;0m accept the ^X notation as well as "\<[4mnumber[24m>" notation, where <[4mnumber[24m> 
  is the octal, hexadecimal, or decimal number of the character's ascii value. 
  For example, the escape character can be given in any of these forms: ^[, 
  \033, \0x1B, or \27.  

  In the tables below, keys with "*" in the "Meaning" column make use of [1mkbnum[22;0m 
  (see [1mbelow[22;0m).  

#named keys
Named keys
  To redefine the named keys, see the section titled "[1mMapping Named Keys to 
  functions[22;0m".  

  Key         Command                 Meaning
  ---         -------                 -------
  Up          /kb_up_or_recallb       *cursor up or recall bkwd input [1mhistory[22;0m
  Down        /kb_down_or_recallf     *cursor down or recall fwd input [1mhistory[22;0m
  Right       [1m/dokey[22;0m RIGHT            *cursor right
  Left        [1m/dokey[22;0m LEFT             *cursor left
  Center      (none)

  Esc_Left    [1m/fg[22;0m -<                  *[1mforeground[22;0m previous [1msocket[22;0m
  Esc_Right   [1m/fg[22;0m ->                  *[1mforeground[22;0m next [1msocket[22;0m

  Ctrl_Up     [1m/dokey_recallb[22;0m          *recall backward input
  Ctrl_Down   [1m/dokey_recallf[22;0m          *recall forward input
  Ctrl_Right  [1m/dokey_wright[22;0m           *word right
  Ctrl_Left   [1m/dokey_wleft[22;0m            *word left

  Insert      [1m/test[22;0m [1minsert[22;0m:=![1minsert[22;0m    toggle [1minsert[22;0m mode
  Delete      [1m/dokey[22;0m dch              *delete character
  Home        [1m/dokey_home[22;0m              cursor to beginning of line
  End         [1m/dokey_end[22;0m               cursor to end of line
  PgDn        [1m/dokey_pgdn[22;0m             *scroll forward a screenful
  PgUp        [1m/dokey_pgup[22;0m             *scroll back a screenful
  Tab         [1m/dokey page[22;0m             *scroll forward a screenful

  Ctrl_Home   [1m/dokey_recallbeg[22;0m         recall first line of input
  Ctrl_End    [1m/dokey_recallend[22;0m         recall last line of input
  Ctrl_PgDn   [1m/dokey_flush[22;0m             scroll forward to last screenful
  Ctrl_PgUp   (reserved for future use)

  F1          [1m/help[22;0m                    help
  F2          (none)                   (function key F1)
  ...
  F20         (none)                   (function key F20)

  nkpTab      (none)                   (see "[1mkeypad[22;0m" section below)
  nkpEnt      (none)                   (see "[1mkeypad[22;0m" section below)
  nkp*        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp+        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp,        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp-        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp.        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp/        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp0        (none)                   (see "[1mkeypad[22;0m" section below)
  ...
  nkp9        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp=        (none)                   (see "[1mkeypad[22;0m" section below)

#unnamed keys
Unnamed key sequences

  String  Command                 Meaning
  ------  -------                 -------
  "^A"    [1m/dokey_home[22;0m              cursor to beginning of line
  "^B"    [1m/dokey[22;0m LEFT             *cursor left
  "^D"    [1m/dokey_dch[22;0m              *delete character to the right
  "^E"    [1m/dokey_end[22;0m               cursor to end of line
  "^F"    [1m/dokey[22;0m RIGHT            *cursor right
  "^G"    [1m/beep[22;0m 1                  beep
  "^H"    (internal)              *backspace
  "^I"    [1m/key_tab[22;0m                 perform the function assigned to the TAB key
  "^J"    (internal)               execute current line
  "^K"    [1m/dokey_deol[22;0m              delete to end of line
  "^L"    [1m/dokey[22;0m redraw            redraw (not clear) screen
  "^M"    (internal)               execute current line
  "^N"    [1m/dokey[22;0m recallf          *recall forward input [1mhistory[22;0m
  "^P"    [1m/dokey[22;0m recallb          *recall backward input [1mhistory[22;0m
  "^Q"    [1m/dokey[22;0m LNEXT             input next key literally (may be overridden
                                   by [1mterminal[22;0m)
  "^R"    [1m/dokey[22;0m REFRESH           refresh line
  "^S"    [1m/dokey[22;0m PAUSE             pause screen
  "^T"    [1m/kb_transpose_chars[22;0m     *transpose characters
  "^U"    [1m/kb_backward_kill_line[22;0m   delete to beginning of line
  "^V"    [1m/dokey[22;0m LNEXT             input next key literally
  "^W"    [1m/dokey[22;0m BWORD            *delete backward word (space-delimited)
  "^?"    (internal)              *backspace
  "^X^R"  [1m/load[22;0m [1m~/.tfrc[22;0m            reload personal config file
  "^X^V"  [1m/version[22;0m                 display version information
  "^X^?"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^X["   [1m/dokey[22;0m_hpageback        *scroll back a half screenful
  "^X]"   [1m/dokey[22;0m_hpage            *scroll forward a half screenful
  "^X{"   [1m/dokey[22;0m_pageback         *scroll back a screenful
  "^X}"   [1m/dokey[22;0m_page             *scroll forward a screenful
  "^[^E"  [1m/kb_expand_line[22;0m          [1mexpand[22;0m current input line in place
  "^[^H"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^[^I"  [1m/complete[22;0m                complete current word, depending on context
  "^[^L"  [1m/dokey[22;0m clear             clear screen (can be refilled with [1mscrollback[22;0m)
  "^[^N"  [1m/dokey[22;0m line             *scroll forward one line
  "^[^P"  [1m/dokey[22;0m lineback         *scroll back one line
  "^[^W"  [1m/complete worldname[22;0m      complete TF world name
  "^[$"   [1m/complete macroname[22;0m      complete TF macro name
  "^[%"   [1m/complete variable[22;0m       complete TF variable name
  "^[/"   [1m/complete filename[22;0m       complete file name (unix only)
  "^[ "   [1m/kb_collapse_space[22;0m       change multiple spaces to a single space
  "^[-"   [1m/set[22;0m [1mkbnum[22;0m=-             start [1mkbnum[22;0m entry with -
  "^[0"   [1m/set[22;0m [1mkbnum[22;0m=+0            start [1mkbnum[22;0m entry with 0
  ...
  "^[9"   [1m/set[22;0m [1mkbnum[22;0m=+9            start [1mkbnum[22;0m entry with 9
  "^[;"   [1m/complete user_defined[22;0m   complete from [1m%{completion_list}[22;0m
  "^[="   [1m/kb_goto_match[22;0m           move cursor to matching parenthesis/bracket
  "^[."   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[<"   [1m/dokey[22;0m recallbeg         go to beginning of input history
  "^[>"   [1m/dokey[22;0m recallend         go to end of input history
  "^[J"   [1m/dokey[22;0m selflush          selective flush (similar to "[1m/dokey[22;0m flush"
                                   followed by "[1m/limit[22;0m -a")
  "^[L"   [1m/kb_toggle_limit[22;0m         toggle between [1m/unlimit[22;0m and [1m/relimit[22;0m
  "^[_"   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[b"   [1m/dokey_wleft[22;0m            *cursor to beginning of word
  "^[c"   [1m/kb_capitalize_word[22;0m     *capitalize word
  "^[d"   [1m/kb_kill_word[22;0m           *delete forward word
  "^[fult keybindings
 type 'tiny.mush', escape all 
  occurrences of '%', '[' and '\' within that line, and send the new line 
  instead of the original.  This is useful for avoiding unwanted 
  interpretation of '%', '[', and '\' on TinyMUSH servers.  

      [1m/hook[22;0m SIGHUP = [1m/log[22;0m on%; [1m/recall[22;0m /10

  will [1mlog[22;0m the last 10 lines of output if you are unexpectedly disconnected 
  from your tf session.  

#CONNETFAIL
  The CONNETFAIL hook, which existed in versions 5.0 alpha 13 through 5.0 beta 
  6, has been replaced with the [1mICONFAIL[22;0m hook.  
#

  See also: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mpriority[22;0m, [1msignals[22;0m.  

&topics

topics

  Topics marked with + are new; those marked with * have changed since the 
  last version.  Many topics also have subtopics that are not listed here 
  (e.g., individual [1mvariables[22;0m, [1mhooks[22;0m, and functions).  


   *[1mcopying[22;0m       copyright; no warranty
    [1mintro[22;0m         introduction to tf
    [1mstartup[22;0m       how to start tf
    [1minterface[22;0m     how input works
    [1mtfrc[22;0m          personal config file
   *[1mvisual[22;0m        split-screen mode
   *[1mcommands[22;0m      list of commands
   *[1mworlds[22;0m        defining worlds
   *[1mpatterns[22;0m      glob and regexp pattern matching
   *[1mvariables[22;0m     state and environment
   *[1mglobals[22;0m       special tf variables
    [1mattributes[22;0m    special text display
    [1mprompts[22;0m       using LP/Diku prompts
    [1mproblems[22;0m      bugs, core dumps, etc.
   *[1mevaluation[22;0m    macro body execution
    [1mmacros[22;0m        user-defined commands
   *[1msockets[22;0m       world connections
    [1mhistory[22;0m       recall and logging
    [1mpriority[22;0m      trigger/hook selection
   *[1mkeybindings[22;0m   keyboard operations
    [1mcolor[22;0m         terminal color codes
   *[1mprotocols[22;0m     protocols supported by TF
    [1mexpressions[22;0m   math and string operations
    [1mtriggers[22;0m      automatic command execution based on incoming text
   *[1mhooks[22;0m         automatic command execution based on tf events
   +[1mmail[22;0m          mail checking
    [1mlibrary[22;0m       macros and variables in stdlib.tf
   *[1mtools[22;0m         extra commands in tools.tf
    [1mutilities[22;0m     useful extra command files
   *[1mprocesses[22;0m     timed commands and command quoting
   *[1msubs[22;0m          arithmetic, command, [1mmacro[22;0m, and variable substitutions
   *[1mfunctions[22;0m     special [1mexpression[22;0m operations
   *[1mhints[22;0m         some hints and style tips for [1mmacro[22;0m programming
   +[1mdebugging[22;0m     debugging your [1mmacros[22;0m
   *[1mtfio[22;0m          output, error, and world streams
   *[1mproxy[22;0m         connecting to outside hosts via a proxy server (firewall)
   +[1mlocale[22;0m        multi-language support
    

&typing
&user
&interface

interface

  Any input line that does not begin with '/' will be sent directly to the 
  [1mforeground[22;0m world, if there is one.  A line starting with more than one '/' 
  will be sent to the forground [1msocket[22;0m after having the first '/' removed.  
  (Exception: lines may be caught with a SEND [1mhook[22;0m before being sent; see 
  "[1mhooks[22;0m").  

  Any input line beginning with a single '/' is a TF command, which will be 
  interpreted as described in "[1mevaluation[22;0m".  

  Input lines of the form "^old^new" will cause TF to search backward in the 
  input [1mhistory[22;0m for a line containing "old", replace that text with "new", and 
  execute the modified command.  See: [1mhistory[22;0m.  

  Many special functions, such as backspace, can be performed by special keys 
  or sequences of keys.  See "[1mdokey[22;0m" for a complete list.  You can also define 
  your own commands and bind them to key sequences.  See [1mbind[22;0m.  

  Normally, user input does not undergo the [1mexpansion[22;0m that [1mmacro[22;0m bodies 
  undergo.  The [1m/eval[22;0m command can be used to [1mexpand[22;0m text before executing it.  
  If the [1m%{sub}[22;0m flag is on (it is off by default), user input undergoes [1mmacro[22;0m 
  body [1mexpansion[22;0m without the [1m%{sub}[22;0m flag.  The [1m%{sub}[22;0m flag also applies to 
  text generated by "^old^new" history commands.  See: [1mhistory[22;0m, [1m/sub[22;0m, 
  [1mvariables[22;0m 

  Control characters may be input literally.  A literal control character will 
  be displayed in the input window in printable form in bold reverse.  Note 
  that since most control keys are also parts of the default keybindings, it 
  will usually be necessary to type ^V ([1m/dokey[22;0m LNEXT) to avoid invoking the 
  keybinding.  

  International characters may be input if your [1mlocale[22;0m is set to a locale that 
  supports them and your system supports locales.  Any input character that is 
  not valid in your locale and has the high bit set (normally generated by 
  holding the "meta" key) will be translated to ESC plus that character with 
  the high bit stripped (assuming [1m%meta_esc[22;0m is on).  This allows M-x and ^[x 
  to invoke the same ^[x keybinding.  See [1mlocale[22;0m, [1m%meta_esc[22;0m, [1m%istrip[22;0m.  

  If standard input is not a terminal, [1mvisual[22;0m mode will not be allowed, and tf 
  will continue to operate even after EOF is read, until /quit or something 
  else terminates it.  

  See also: [1mvisual[22;0m, [1moptions[22;0m 

&intro
&me
&newbie
&tinyfugue
&introduction

introduction

  TinyFugue is a MUD client.  It helps you connect to a MUD, in a much more 
  convenient manner than telnet.  You can connect to a mud world using the 
  same syntax as you would with telnet: "[1mtf[22;0m <[4mhost[24m> <[4mport[24m>".  Or, while running 
  tf, you can use "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>".  To make things easier, you can 
  give names to worlds, using [1m/addworld[22;0m, and then use "[1mtf[22;0m <[4mname[24m>" and 
  "[1m/connect[22;0m <[4mname[24m>".  If you store a set of [1m/addworld[22;0m commands in a file, TF 
  can read them automatically when it starts.  You can even connect to more 
  than one world at the same time, and switch between them.  See: [1m/connect[22;0m, 
  [1m/fg[22;0m, [1m/addworld[22;0m, [1mworlds[22;0m, [1mtfrc[22;0m.  

  Normally, TF will split the screen into two windows: one for input, and one 
  for output.  TF will display useful information on the line separating the 
  two windows, such as the name of the [1mforeground[22;0m world.  See: [1mwindows[22;0m.  

  Any line you type that starts with a single '/' is a tf command.  Anything 
  else you type will be sent to the mud.  See: [1minterface[22;0m, [1mcommands[22;0m.  

  You can define your own tf commands, called [1mmacros[22;0m.  The simplest type of 
  [1mmacro[22;0m is just an abbreviation or alias for a longer command or commands.  
  But [1mmacros[22;0m can also perform much more powerful tasks.  See: [1mmacros[22;0m, [1m/def[22;0m.  

  You can tell tf to watch for certain patterns in the text from the mud, and 
  then do special things when it sees that pattern: display the text in a 
  special way ([1mhilite[22;0m); not display the text at all ([1mgag[22;0m); execute a [1mmacro[22;0m 
  command ([1mtrigger[22;0m); or do any combination of these.  See: [1mattributes[22;0m, 
  [1mtriggers[22;0m, [1m/hilite[22;0m, [1m/gag[22;0m, [1m/trig[22;0m, [1m/def[22;0m.  

  TF keeps a [1mhistory[22;0m of every line it prints, every line sent by the mud, and 
  every command you enter.  You can see those histories using [1m/recall[22;0m.  You 
  can also have this text saved in a file using [1m/log[22;0m.  See: [1mhistory[22;0m, [1m/recall[22;0m, 
  [1m/log[22;0m.  

  See also: [1mtopics[22;0m 

&keys
&key
&kbbind
&kbfunc
&kbfunc.tf
&kbbind.tf
&keybindings

keybindings

Default keybindings

  TF's default command line editing keys are similar to those in emacs and 
  bash.  In addition, several features may be invoked by more than one 
  keybinding, and TF has keybindings for unique features like switching the 
  [1mforeground[22;0m [1msocket[22;0m.  

  Here, and throughout the TF documentation, the notation "^X" means the 
  character generated by typing the X key while holding the CTRL key.  Also, 
  "^[" can be more easily typed just by pressing the ESC key.  [1m/Def -b[22;0m and 
  [1m/bind[22;0m accept the ^X notation as well as "\<[4mnumber[24m>" notation, where <[4mnumber[24m> 
  is the octal, hexadecimal, or decimal number of the character's ascii value. 
  For example, the escape character can be given in any of these forms: ^[, 
  \033, \0x1B, or \27.  

  In the tables below, keys with "*" in the "Meaning" column make use of [1mkbnum[22;0m 
  (see [1mbelow[22;0m).  

#named keys
Named keys
  To redefine the named keys, see the section titled "[1mMapping Named Keys to 
  functions[22;0m".  

  Key         Command                 Meaning
  ---         -------                 -------
  Up          /kb_up_or_recallb       *cursor up or recall bkwd input [1mhistory[22;0m
  Down        /kb_down_or_recallf     *cursor down or recall fwd input [1mhistory[22;0m
  Right       [1m/dokey[22;0m RIGHT            *cursor right
  Left        [1m/dokey[22;0m LEFT             *cursor left
  Center      (none)

  Esc_Left    [1m/fg[22;0m -<                  *[1mforeground[22;0m previous [1msocket[22;0m
  Esc_Right   [1m/fg[22;0m ->                  *[1mforeground[22;0m next [1msocket[22;0m

  Ctrl_Up     [1m/dokey_recallb[22;0m          *recall backward input
  Ctrl_Down   [1m/dokey_recallf[22;0m          *recall forward input
  Ctrl_Right  [1m/dokey_wright[22;0m           *word right
  Ctrl_Left   [1m/dokey_wleft[22;0m            *word left

  Insert      [1m/test[22;0m [1minsert[22;0m:=![1minsert[22;0m    toggle [1minsert[22;0m mode
  Delete      [1m/dokey[22;0m dch              *delete character
  Home        [1m/dokey_home[22;0m              cursor to beginning of line
  End         [1m/dokey_end[22;0m               cursor to end of line
  PgDn        [1m/dokey_pgdn[22;0m             *scroll forward a screenful
  PgUp        [1m/dokey_pgup[22;0m             *scroll back a screenful
  Tab         [1m/dokey page[22;0m             *scroll forward a screenful

  Ctrl_Home   [1m/dokey_recallbeg[22;0m         recall first line of input
  Ctrl_End    [1m/dokey_recallend[22;0m         recall last line of input
  Ctrl_PgDn   [1m/dokey_flush[22;0m             scroll forward to last screenful
  Ctrl_PgUp   (reserved for future use)

  F1          [1m/help[22;0m                    help
  F2          (none)                   (function key F1)
  ...
  F20         (none)                   (function key F20)

  nkpTab      (none)                   (see "[1mkeypad[22;0m" section below)
  nkpEnt      (none)                   (see "[1mkeypad[22;0m" section below)
  nkp*        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp+        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp,        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp-        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp.        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp/        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp0        (none)                   (see "[1mkeypad[22;0m" section below)
  ...
  nkp9        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp=        (none)                   (see "[1mkeypad[22;0m" section below)

#unnamed keys
Unnamed key sequences

  String  Command                 Meaning
  ------  -------                 -------
  "^A"    [1m/dokey_home[22;0m              cursor to beginning of line
  "^B"    [1m/dokey[22;0m LEFT             *cursor left
  "^D"    [1m/dokey_dch[22;0m              *delete character to the right
  "^E"    [1m/dokey_end[22;0m               cursor to end of line
  "^F"    [1m/dokey[22;0m RIGHT            *cursor right
  "^G"    [1m/beep[22;0m 1                  beep
  "^H"    (internal)              *backspace
  "^I"    [1m/key_tab[22;0m                 perform the function assigned to the TAB key
  "^J"    (internal)               execute current line
  "^K"    [1m/dokey_deol[22;0m              delete to end of line
  "^L"    [1m/dokey[22;0m redraw            redraw (not clear) screen
  "^M"    (internal)               execute current line
  "^N"    [1m/dokey[22;0m recallf          *recall forward input [1mhistory[22;0m
  "^P"    [1m/dokey[22;0m recallb          *recall backward input [1mhistory[22;0m
  "^Q"    [1m/dokey[22;0m LNEXT             input next key literally (may be overridden
                                   by [1mterminal[22;0m)
  "^R"    [1m/dokey[22;0m REFRESH           refresh line
  "^S"    [1m/dokey[22;0m PAUSE             pause screen
  "^T"    [1m/kb_transpose_chars[22;0m     *transpose characters
  "^U"    [1m/kb_backward_kill_line[22;0m   delete to beginning of line
  "^V"    [1m/dokey[22;0m LNEXT             input next key literally
  "^W"    [1m/dokey[22;0m BWORD            *delete backward word (space-delimited)
  "^?"    (internal)              *backspace
  "^X^R"  [1m/load[22;0m [1m~/.tfrc[22;0m            reload personal config file
  "^X^V"  [1m/version[22;0m                 display version information
  "^X^?"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^X["   [1m/dokey[22;0m_hpageback        *scroll back a half screenful
  "^X]"   [1m/dokey[22;0m_hpage            *scroll forward a half screenful
  "^X{"   [1m/dokey[22;0m_pageback         *scroll back a screenful
  "^X}"   [1m/dokey[22;0m_page             *scroll forward a screenful
  "^[^E"  [1m/kb_expand_line[22;0m          [1mexpand[22;0m current input line in place
  "^[^H"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^[^I"  [1m/complete[22;0m                complete current word, depending on context
  "^[^L"  [1m/dokey[22;0m clear             clear screen (can be refilled with [1mscrollback[22;0m)
  "^[^N"  [1m/dokey[22;0m line             *scroll forward one line
  "^[^P"  [1m/dokey[22;0m lineback         *scroll back one line
  "^[^W"  [1m/complete worldname[22;0m      complete TF world name
  "^[$"   [1m/complete macroname[22;0m      complete TF macro name
  "^[%"   [1m/complete variable[22;0m       complete TF variable name
  "^[/"   [1m/complete filename[22;0m       complete file name (unix only)
  "^[ "   [1m/kb_collapse_space[22;0m       change multiple spaces to a single space
  "^[-"   [1m/set[22;0m [1mkbnum[22;0m=-             start [1mkbnum[22;0m entry with -
  "^[0"   [1m/set[22;0m [1mkbnum[22;0m=+0            start [1mkbnum[22;0m entry with 0
  ...
  "^[9"   [1m/set[22;0m [1mkbnum[22;0m=+9            start [1mkbnum[22;0m entry with 9
  "^[;"   [1m/complete user_defined[22;0m   complete from [1m%{completion_list}[22;0m
  "^[="   [1m/kb_goto_match[22;0m           move cursor to matching parenthesis/bracket
  "^[."   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[<"   [1m/dokey[22;0m recallbeg         go to beginning of input history
  "^[>"   [1m/dokey[22;0m recallend         go to end of input history
  "^[J"   [1m/dokey[22;0m selflush          selective flush (similar to "[1m/dokey[22;0m flush"
                                   followed by "[1m/limit[22;0m -a")
  "^[L"   [1m/kb_toggle_limit[22;0m         toggle between [1m/unlimit[22;0m and [1m/relimit[22;0m
  "^[_"   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[b"   [1m/dokey_wleft[22;0m            *cursor to beginning of word
  "^[c"   [1m/kb_capitalize_word[22;0m     *capitalize word
  "^[d"   [1m/kb_kill_word[22;0m           *delete forward word
  "^[fult keybindings
 type 'tiny.mush', escape all 
  occurrences of '%', '[' and '\' within that line, and send the new line 
  instead of the original.  This is useful for avoiding unwanted 
  interpretation of '%', '[', and '\' on TinyMUSH servers.  

      [1m/hook[22;0m SIGHUP = [1m/log[22;0m on%; [1m/recall[22;0m /10

  will [1mlog[22;0m the last 10 lines of output if you are unexpectedly disconnected 
  from your tf session.  

#CONNETFAIL
  The CONNETFAIL hook, which existed in versions 5.0 alpha 13 through 5.0 beta 
  6, has been replaced with the [1mICONFAIL[22;0m hook.  
#

  See also: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mpriority[22;0m, [1msignals[22;0m.  

&topics

topics

  Topics marked with + are new; those marked with * have changed since the 
  last version.  Many topics also have subtopics that are not listed here 
  (e.g., individual [1mvariables[22;0m, [1mhooks[22;0m, and functions).  


   *[1mcopying[22;0m       copyright; no warranty
    [1mintro[22;0m         introduction to tf
    [1mstartup[22;0m       how to start tf
    [1minterface[22;0m     how input works
    [1mtfrc[22;0m          personal config file
   *[1mvisual[22;0m        split-screen mode
   *[1mcommands[22;0m      list of commands
   *[1mworlds[22;0m        defining worlds
   *[1mpatterns[22;0m      glob and regexp pattern matching
   *[1mvariables[22;0m     state and environment
   *[1mglobals[22;0m       special tf variables
    [1mattributes[22;0m    special text display
    [1mprompts[22;0m       using LP/Diku prompts
    [1mproblems[22;0m      bugs, core dumps, etc.
   *[1mevaluation[22;0m    macro body execution
    [1mmacros[22;0m        user-defined commands
   *[1msockets[22;0m       world connections
    [1mhistory[22;0m       recall and logging
    [1mpriority[22;0m      trigger/hook selection
   *[1mkeybindings[22;0m   keyboard operations
    [1mcolor[22;0m         terminal color codes
   *[1mprotocols[22;0m     protocols supported by TF
    [1mexpressions[22;0m   math and string operations
    [1mtriggers[22;0m      automatic command execution based on incoming text
   *[1mhooks[22;0m         automatic command execution based on tf events
   +[1mmail[22;0m          mail checking
    [1mlibrary[22;0m       macros and variables in stdlib.tf
   *[1mtools[22;0m         extra commands in tools.tf
    [1mutilities[22;0m     useful extra command files
   *[1mprocesses[22;0m     timed commands and command quoting
   *[1msubs[22;0m          arithmetic, command, [1mmacro[22;0m, and variable substitutions
   *[1mfunctions[22;0m     special [1mexpression[22;0m operations
   *[1mhints[22;0m         some hints and style tips for [1mmacro[22;0m programming
   +[1mdebugging[22;0m     debugging your [1mmacros[22;0m
   *[1mtfio[22;0m          output, error, and world streams
   *[1mproxy[22;0m         connecting to outside hosts via a proxy server (firewall)
   +[1mlocale[22;0m        multi-language support
    

&typing
&user
&interface

interface

  Any input line that does not begin with '/' will be sent directly to the 
  [1mforeground[22;0m world, if there is one.  A line starting with more than one '/' 
  will be sent to the forground [1msocket[22;0m after having the first '/' removed.  
  (Exception: lines may be caught with a SEND [1mhook[22;0m before being sent; see 
  "[1mhooks[22;0m").  

  Any input line beginning with a single '/' is a TF command, which will be 
  interpreted as described in "[1mevaluation[22;0m".  

  Input lines of the form "^old^new" will cause TF to search backward in the 
  input [1mhistory[22;0m for a line containing "old", replace that text with "new", and 
  execute the modified command.  See: [1mhistory[22;0m.  

  Many special functions, such as backspace, can be performed by special keys 
  or sequences of keys.  See "[1mdokey[22;0m" for a complete list.  You can also define 
  your own commands and bind them to key sequences.  See [1mbind[22;0m.  

  Normally, user input does not undergo the [1mexpansion[22;0m that [1mmacro[22;0m bodies 
  undergo.  The [1m/eval[22;0m command can be used to [1mexpand[22;0m text before executing it.  
  If the [1m%{sub}[22;0m flag is on (it is off by default), user input undergoes [1mmacro[22;0m 
  body [1mexpansion[22;0m without the [1m%{sub}[22;0m flag.  The [1m%{sub}[22;0m flag also applies to 
  text generated by "^old^new" history commands.  See: [1mhistory[22;0m, [1m/sub[22;0m, 
  [1mvariables[22;0m 

  Control characters may be input literally.  A literal control character will 
  be displayed in the input window in printable form in bold reverse.  Note 
  that since most control keys are also parts of the default keybindings, it 
  will usually be necessary to type ^V ([1m/dokey[22;0m LNEXT) to avoid invoking the 
  keybinding.  

  International characters may be input if your [1mlocale[22;0m is set to a locale that 
  supports them and your system supports locales.  Any input character that is 
  not valid in your locale and has the high bit set (normally generated by 
  holding the "meta" key) will be translated to ESC plus that character with 
  the high bit stripped (assuming [1m%meta_esc[22;0m is on).  This allows M-x and ^[x 
  to invoke the same ^[x keybinding.  See [1mlocale[22;0m, [1m%meta_esc[22;0m, [1m%istrip[22;0m.  

  If standard input is not a terminal, [1mvisual[22;0m mode will not be allowed, and tf 
  will continue to operate even after EOF is read, until /quit or something 
  else terminates it.  

  See also: [1mvisual[22;0m, [1moptions[22;0m 

&intro
&me
&newbie
&tinyfugue
&introduction

introduction

  TinyFugue is a MUD client.  It helps you connect to a MUD, in a much more 
  convenient manner than telnet.  You can connect to a mud world using the 
  same syntax as you would with telnet: "[1mtf[22;0m <[4mhost[24m> <[4mport[24m>".  Or, while running 
  tf, you can use "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>".  To make things easier, you can 
  give names to worlds, using [1m/addworld[22;0m, and then use "[1mtf[22;0m <[4mname[24m>" and 
  "[1m/connect[22;0m <[4mname[24m>".  If you store a set of [1m/addworld[22;0m commands in a file, TF 
  can read them automatically when it starts.  You can even connect to more 
  than one world at the same time, and switch between them.  See: [1m/connect[22;0m, 
  [1m/fg[22;0m, [1m/addworld[22;0m, [1mworlds[22;0m, [1mtfrc[22;0m.  

  Normally, TF will split the screen into two windows: one for input, and one 
  for output.  TF will display useful information on the line separating the 
  two windows, such as the name of the [1mforeground[22;0m world.  See: [1mwindows[22;0m.  

  Any line you type that starts with a single '/' is a tf command.  Anything 
  else you type will be sent to the mud.  See: [1minterface[22;0m, [1mcommands[22;0m.  

  You can define your own tf commands, called [1mmacros[22;0m.  The simplest type of 
  [1mmacro[22;0m is just an abbreviation or alias for a longer command or commands.  
  But [1mmacros[22;0m can also perform much more powerful tasks.  See: [1mmacros[22;0m, [1m/def[22;0m.  

  You can tell tf to watch for certain patterns in the text from the mud, and 
  then do special things when it sees that pattern: display the text in a 
  special way ([1mhilite[22;0m); not display the text at all ([1mgag[22;0m); execute a [1mmacro[22;0m 
  command ([1mtrigger[22;0m); or do any combination of these.  See: [1mattributes[22;0m, 
  [1mtriggers[22;0m, [1m/hilite[22;0m, [1m/gag[22;0m, [1m/trig[22;0m, [1m/def[22;0m.  

  TF keeps a [1mhistory[22;0m of every line it prints, every line sent by the mud, and 
  every command you enter.  You can see those histories using [1m/recall[22;0m.  You 
  can also have this text saved in a file using [1m/log[22;0m.  See: [1mhistory[22;0m, [1m/recall[22;0m, 
  [1m/log[22;0m.  

  See also: [1mtopics[22;0m 

&keys
&key
&kbbind
&kbfunc
&kbfunc.tf
&kbbind.tf
&keybindings

keybindings

Default keybindings

  TF's default command line editing keys are similar to those in emacs and 
  bash.  In addition, several features may be invoked by more than one 
  keybinding, and TF has keybindings for unique features like switching the 
  [1mforeground[22;0m [1msocket[22;0m.  

  Here, and throughout the TF documentation, the notation "^X" means the 
  character generated by typing the X key while holding the CTRL key.  Also, 
  "^[" can be more easily typed just by pressing the ESC key.  [1m/Def -b[22;0m and 
  [1m/bind[22;0m accept the ^X notation as well as "\<[4mnumber[24m>" notation, where <[4mnumber[24m> 
  is the octal, hexadecimal, or decimal number of the character's ascii value. 
  For example, the escape character can be given in any of these forms: ^[, 
  \033, \0x1B, or \27.  

  In the tables below, keys with "*" in the "Meaning" column make use of [1mkbnum[22;0m 
  (see [1mbelow[22;0m).  

#named keys
Named keys
  To redefine the named keys, see the section titled "[1mMapping Named Keys to 
  functions[22;0m".  

  Key         Command                 Meaning
  ---         -------                 -------
  Up          /kb_up_or_recallb       *cursor up or recall bkwd input [1mhistory[22;0m
  Down        /kb_down_or_recallf     *cursor down or recall fwd input [1mhistory[22;0m
  Right       [1m/dokey[22;0m RIGHT            *cursor right
  Left        [1m/dokey[22;0m LEFT             *cursor left
  Center      (none)

  Esc_Left    [1m/fg[22;0m -<                  *[1mforeground[22;0m previous [1msocket[22;0m
  Esc_Right   [1m/fg[22;0m ->                  *[1mforeground[22;0m next [1msocket[22;0m

  Ctrl_Up     [1m/dokey_recallb[22;0m          *recall backward input
  Ctrl_Down   [1m/dokey_recallf[22;0m          *recall forward input
  Ctrl_Right  [1m/dokey_wright[22;0m           *word right
  Ctrl_Left   [1m/dokey_wleft[22;0m            *word left

  Insert      [1m/test[22;0m [1minsert[22;0m:=![1minsert[22;0m    toggle [1minsert[22;0m mode
  Delete      [1m/dokey[22;0m dch              *delete character
  Home        [1m/dokey_home[22;0m              cursor to beginning of line
  End         [1m/dokey_end[22;0m               cursor to end of line
  PgDn        [1m/dokey_pgdn[22;0m             *scroll forward a screenful
  PgUp        [1m/dokey_pgup[22;0m             *scroll back a screenful
  Tab         [1m/dokey page[22;0m             *scroll forward a screenful

  Ctrl_Home   [1m/dokey_recallbeg[22;0m         recall first line of input
  Ctrl_End    [1m/dokey_recallend[22;0m         recall last line of input
  Ctrl_PgDn   [1m/dokey_flush[22;0m             scroll forward to last screenful
  Ctrl_PgUp   (reserved for future use)

  F1          [1m/help[22;0m                    help
  F2          (none)                   (function key F1)
  ...
  F20         (none)                   (function key F20)

  nkpTab      (none)                   (see "[1mkeypad[22;0m" section below)
  nkpEnt      (none)                   (see "[1mkeypad[22;0m" section below)
  nkp*        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp+        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp,        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp-        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp.        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp/        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp0        (none)                   (see "[1mkeypad[22;0m" section below)
  ...
  nkp9        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp=        (none)                   (see "[1mkeypad[22;0m" section below)

#unnamed keys
Unnamed key sequences

  String  Command                 Meaning
  ------  -------                 -------
  "^A"    [1m/dokey_home[22;0m              cursor to beginning of line
  "^B"    [1m/dokey[22;0m LEFT             *cursor left
  "^D"    [1m/dokey_dch[22;0m              *delete character to the right
  "^E"    [1m/dokey_end[22;0m               cursor to end of line
  "^F"    [1m/dokey[22;0m RIGHT            *cursor right
  "^G"    [1m/beep[22;0m 1                  beep
  "^H"    (internal)              *backspace
  "^I"    [1m/key_tab[22;0m                 perform the function assigned to the TAB key
  "^J"    (internal)               execute current line
  "^K"    [1m/dokey_deol[22;0m              delete to end of line
  "^L"    [1m/dokey[22;0m redraw            redraw (not clear) screen
  "^M"    (internal)               execute current line
  "^N"    [1m/dokey[22;0m recallf          *recall forward input [1mhistory[22;0m
  "^P"    [1m/dokey[22;0m recallb          *recall backward input [1mhistory[22;0m
  "^Q"    [1m/dokey[22;0m LNEXT             input next key literally (may be overridden
                                   by [1mterminal[22;0m)
  "^R"    [1m/dokey[22;0m REFRESH           refresh line
  "^S"    [1m/dokey[22;0m PAUSE             pause screen
  "^T"    [1m/kb_transpose_chars[22;0m     *transpose characters
  "^U"    [1m/kb_backward_kill_line[22;0m   delete to beginning of line
  "^V"    [1m/dokey[22;0m LNEXT             input next key literally
  "^W"    [1m/dokey[22;0m BWORD            *delete backward word (space-delimited)
  "^?"    (internal)              *backspace
  "^X^R"  [1m/load[22;0m [1m~/.tfrc[22;0m            reload personal config file
  "^X^V"  [1m/version[22;0m                 display version information
  "^X^?"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^X["   [1m/dokey[22;0m_hpageback        *scroll back a half screenful
  "^X]"   [1m/dokey[22;0m_hpage            *scroll forward a half screenful
  "^X{"   [1m/dokey[22;0m_pageback         *scroll back a screenful
  "^X}"   [1m/dokey[22;0m_page             *scroll forward a screenful
  "^[^E"  [1m/kb_expand_line[22;0m          [1mexpand[22;0m current input line in place
  "^[^H"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^[^I"  [1m/complete[22;0m                complete current word, depending on context
  "^[^L"  [1m/dokey[22;0m clear             clear screen (can be refilled with [1mscrollback[22;0m)
  "^[^N"  [1m/dokey[22;0m line             *scroll forward one line
  "^[^P"  [1m/dokey[22;0m lineback         *scroll back one line
  "^[^W"  [1m/complete worldname[22;0m      complete TF world name
  "^[$"   [1m/complete macroname[22;0m      complete TF macro name
  "^[%"   [1m/complete variable[22;0m       complete TF variable name
  "^[/"   [1m/complete filename[22;0m       complete file name (unix only)
  "^[ "   [1m/kb_collapse_space[22;0m       change multiple spaces to a single space
  "^[-"   [1m/set[22;0m [1mkbnum[22;0m=-             start [1mkbnum[22;0m entry with -
  "^[0"   [1m/set[22;0m [1mkbnum[22;0m=+0            start [1mkbnum[22;0m entry with 0
  ...
  "^[9"   [1m/set[22;0m [1mkbnum[22;0m=+9            start [1mkbnum[22;0m entry with 9
  "^[;"   [1m/complete user_defined[22;0m   complete from [1m%{completion_list}[22;0m
  "^[="   [1m/kb_goto_match[22;0m           move cursor to matching parenthesis/bracket
  "^[."   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[<"   [1m/dokey[22;0m recallbeg         go to beginning of input history
  "^[>"   [1m/dokey[22;0m recallend         go to end of input history
  "^[J"   [1m/dokey[22;0m selflush          selective flush (similar to "[1m/dokey[22;0m flush"
                                   followed by "[1m/limit[22;0m -a")
  "^[L"   [1m/kb_toggle_limit[22;0m         toggle between [1m/unlimit[22;0m and [1m/relimit[22;0m
  "^[_"   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[b"   [1m/dokey_wleft[22;0m            *cursor to beginning of word
  "^[c"   [1m/kb_capitalize_word[22;0m     *capitalize word
  "^[d"   [1m/kb_kill_word[22;0m           *delete forward word
  "^[fult keybindings
 type 'tiny.mush', escape all 
  occurrences of '%', '[' and '\' within that line, and send the new line 
  instead of the original.  This is useful for avoiding unwanted 
  interpretation of '%', '[', and '\' on TinyMUSH servers.  

      [1m/hook[22;0m SIGHUP = [1m/log[22;0m on%; [1m/recall[22;0m /10

  will [1mlog[22;0m the last 10 lines of output if you are unexpectedly disconnected 
  from your tf session.  

#CONNETFAIL
  The CONNETFAIL hook, which existed in versions 5.0 alpha 13 through 5.0 beta 
  6, has been replaced with the [1mICONFAIL[22;0m hook.  
#

  See also: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mpriority[22;0m, [1msignals[22;0m.  

&topics

topics

  Topics marked with + are new; those marked with * have changed since the 
  last version.  Many topics also have subtopics that are not listed here 
  (e.g., individual [1mvariables[22;0m, [1mhooks[22;0m, and functions).  


   *[1mcopying[22;0m       copyright; no warranty
    [1mintro[22;0m         introduction to tf
    [1mstartup[22;0m       how to start tf
    [1minterface[22;0m     how input works
    [1mtfrc[22;0m          personal config file
   *[1mvisual[22;0m        split-screen mode
   *[1mcommands[22;0m      list of commands
   *[1mworlds[22;0m        defining worlds
   *[1mpatterns[22;0m      glob and regexp pattern matching
   *[1mvariables[22;0m     state and environment
   *[1mglobals[22;0m       special tf variables
    [1mattributes[22;0m    special text display
    [1mprompts[22;0m       using LP/Diku prompts
    [1mproblems[22;0m      bugs, core dumps, etc.
   *[1mevaluation[22;0m    macro body execution
    [1mmacros[22;0m        user-defined commands
   *[1msockets[22;0m       world connections
    [1mhistory[22;0m       recall and logging
    [1mpriority[22;0m      trigger/hook selection
   *[1mkeybindings[22;0m   keyboard operations
    [1mcolor[22;0m         terminal color codes
   *[1mprotocols[22;0m     protocols supported by TF
    [1mexpressions[22;0m   math and string operations
    [1mtriggers[22;0m      automatic command execution based on incoming text
   *[1mhooks[22;0m         automatic command execution based on tf events
   +[1mmail[22;0m          mail checking
    [1mlibrary[22;0m       macros and variables in stdlib.tf
   *[1mtools[22;0m         extra commands in tools.tf
    [1mutilities[22;0m     useful extra command files
   *[1mprocesses[22;0m     timed commands and command quoting
   *[1msubs[22;0m          arithmetic, command, [1mmacro[22;0m, and variable substitutions
   *[1mfunctions[22;0m     special [1mexpression[22;0m operations
   *[1mhints[22;0m         some hints and style tips for [1mmacro[22;0m programming
   +[1mdebugging[22;0m     debugging your [1mmacros[22;0m
   *[1mtfio[22;0m          output, error, and world streams
   *[1mproxy[22;0m         connecting to outside hosts via a proxy server (firewall)
   +[1mlocale[22;0m        multi-language support
    

&typing
&user
&interface

interface

  Any input line that does not begin with '/' will be sent directly to the 
  [1mforeground[22;0m world, if there is one.  A line starting with more than one '/' 
  will be sent to the forground [1msocket[22;0m after having the first '/' removed.  
  (Exception: lines may be caught with a SEND [1mhook[22;0m before being sent; see 
  "[1mhooks[22;0m").  

  Any input line beginning with a single '/' is a TF command, which will be 
  interpreted as described in "[1mevaluation[22;0m".  

  Input lines of the form "^old^new" will cause TF to search backward in the 
  input [1mhistory[22;0m for a line containing "old", replace that text with "new", and 
  execute the modified command.  See: [1mhistory[22;0m.  

  Many special functions, such as backspace, can be performed by special keys 
  or sequences of keys.  See "[1mdokey[22;0m" for a complete list.  You can also define 
  your own commands and bind them to key sequences.  See [1mbind[22;0m.  

  Normally, user input does not undergo the [1mexpansion[22;0m that [1mmacro[22;0m bodies 
  undergo.  The [1m/eval[22;0m command can be used to [1mexpand[22;0m text before executing it.  
  If the [1m%{sub}[22;0m flag is on (it is off by default), user input undergoes [1mmacro[22;0m 
  body [1mexpansion[22;0m without the [1m%{sub}[22;0m flag.  The [1m%{sub}[22;0m flag also applies to 
  text generated by "^old^new" history commands.  See: [1mhistory[22;0m, [1m/sub[22;0m, 
  [1mvariables[22;0m 

  Control characters may be input literally.  A literal control character will 
  be displayed in the input window in printable form in bold reverse.  Note 
  that since most control keys are also parts of the default keybindings, it 
  will usually be necessary to type ^V ([1m/dokey[22;0m LNEXT) to avoid invoking the 
  keybinding.  

  International characters may be input if your [1mlocale[22;0m is set to a locale that 
  supports them and your system supports locales.  Any input character that is 
  not valid in your locale and has the high bit set (normally generated by 
  holding the "meta" key) will be translated to ESC plus that character with 
  the high bit stripped (assuming [1m%meta_esc[22;0m is on).  This allows M-x and ^[x 
  to invoke the same ^[x keybinding.  See [1mlocale[22;0m, [1m%meta_esc[22;0m, [1m%istrip[22;0m.  

  If standard input is not a terminal, [1mvisual[22;0m mode will not be allowed, and tf 
  will continue to operate even after EOF is read, until /quit or something 
  else terminates it.  

  See also: [1mvisual[22;0m, [1moptions[22;0m 

&intro
&me
&newbie
&tinyfugue
&introduction

introduction

  TinyFugue is a MUD client.  It helps you connect to a MUD, in a much more 
  convenient manner than telnet.  You can connect to a mud world using the 
  same syntax as you would with telnet: "[1mtf[22;0m <[4mhost[24m> <[4mport[24m>".  Or, while running 
  tf, you can use "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>".  To make things easier, you can 
  give names to worlds, using [1m/addworld[22;0m, and then use "[1mtf[22;0m <[4mname[24m>" and 
  "[1m/connect[22;0m <[4mname[24m>".  If you store a set of [1m/addworld[22;0m commands in a file, TF 
  can read them automatically when it starts.  You can even connect to more 
  than one world at the same time, and switch between them.  See: [1m/connect[22;0m, 
  [1m/fg[22;0m, [1m/addworld[22;0m, [1mworlds[22;0m, [1mtfrc[22;0m.  

  Normally, TF will split the screen into two windows: one for input, and one 
  for output.  TF will display useful information on the line separating the 
  two windows, such as the name of the [1mforeground[22;0m world.  See: [1mwindows[22;0m.  

  Any line you type that starts with a single '/' is a tf command.  Anything 
  else you type will be sent to the mud.  See: [1minterface[22;0m, [1mcommands[22;0m.  

  You can define your own tf commands, called [1mmacros[22;0m.  The simplest type of 
  [1mmacro[22;0m is just an abbreviation or alias for a longer command or commands.  
  But [1mmacros[22;0m can also perform much more powerful tasks.  See: [1mmacros[22;0m, [1m/def[22;0m.  

  You can tell tf to watch for certain patterns in the text from the mud, and 
  then do special things when it sees that pattern: display the text in a 
  special way ([1mhilite[22;0m); not display the text at all ([1mgag[22;0m); execute a [1mmacro[22;0m 
  command ([1mtrigger[22;0m); or do any combination of these.  See: [1mattributes[22;0m, 
  [1mtriggers[22;0m, [1m/hilite[22;0m, [1m/gag[22;0m, [1m/trig[22;0m, [1m/def[22;0m.  

  TF keeps a [1mhistory[22;0m of every line it prints, every line sent by the mud, and 
  every command you enter.  You can see those histories using [1m/recall[22;0m.  You 
  can also have this text saved in a file using [1m/log[22;0m.  See: [1mhistory[22;0m, [1m/recall[22;0m, 
  [1m/log[22;0m.  

  See also: [1mtopics[22;0m 

&keys
&key
&kbbind
&kbfunc
&kbfunc.tf
&kbbind.tf
&keybindings

keybindings

Default keybindings

  TF's default command line editing keys are similar to those in emacs and 
  bash.  In addition, several features may be invoked by more than one 
  keybinding, and TF has keybindings for unique features like switching the 
  [1mforeground[22;0m [1msocket[22;0m.  

  Here, and throughout the TF documentation, the notation "^X" means the 
  character generated by typing the X key while holding the CTRL key.  Also, 
  "^[" can be more easily typed just by pressing the ESC key.  [1m/Def -b[22;0m and 
  [1m/bind[22;0m accept the ^X notation as well as "\<[4mnumber[24m>" notation, where <[4mnumber[24m> 
  is the octal, hexadecimal, or decimal number of the character's ascii value. 
  For example, the escape character can be given in any of these forms: ^[, 
  \033, \0x1B, or \27.  

  In the tables below, keys with "*" in the "Meaning" column make use of [1mkbnum[22;0m 
  (see [1mbelow[22;0m).  

#named keys
Named keys
  To redefine the named keys, see the section titled "[1mMapping Named Keys to 
  functions[22;0m".  

  Key         Command                 Meaning
  ---         -------                 -------
  Up          /kb_up_or_recallb       *cursor up or recall bkwd input [1mhistory[22;0m
  Down        /kb_down_or_recallf     *cursor down or recall fwd input [1mhistory[22;0m
  Right       [1m/dokey[22;0m RIGHT            *cursor right
  Left        [1m/dokey[22;0m LEFT             *cursor left
  Center      (none)

  Esc_Left    [1m/fg[22;0m -<                  *[1mforeground[22;0m previous [1msocket[22;0m
  Esc_Right   [1m/fg[22;0m ->                  *[1mforeground[22;0m next [1msocket[22;0m

  Ctrl_Up     [1m/dokey_recallb[22;0m          *recall backward input
  Ctrl_Down   [1m/dokey_recallf[22;0m          *recall forward input
  Ctrl_Right  [1m/dokey_wright[22;0m           *word right
  Ctrl_Left   [1m/dokey_wleft[22;0m            *word left

  Insert      [1m/test[22;0m [1minsert[22;0m:=![1minsert[22;0m    toggle [1minsert[22;0m mode
  Delete      [1m/dokey[22;0m dch              *delete character
  Home        [1m/dokey_home[22;0m              cursor to beginning of line
  End         [1m/dokey_end[22;0m               cursor to end of line
  PgDn        [1m/dokey_pgdn[22;0m             *scroll forward a screenful
  PgUp        [1m/dokey_pgup[22;0m             *scroll back a screenful
  Tab         [1m/dokey page[22;0m             *scroll forward a screenful

  Ctrl_Home   [1m/dokey_recallbeg[22;0m         recall first line of input
  Ctrl_End    [1m/dokey_recallend[22;0m         recall last line of input
  Ctrl_PgDn   [1m/dokey_flush[22;0m             scroll forward to last screenful
  Ctrl_PgUp   (reserved for future use)

  F1          [1m/help[22;0m                    help
  F2          (none)                   (function key F1)
  ...
  F20         (none)                   (function key F20)

  nkpTab      (none)                   (see "[1mkeypad[22;0m" section below)
  nkpEnt      (none)                   (see "[1mkeypad[22;0m" section below)
  nkp*        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp+        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp,        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp-        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp.        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp/        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp0        (none)                   (see "[1mkeypad[22;0m" section below)
  ...
  nkp9        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp=        (none)                   (see "[1mkeypad[22;0m" section below)

#unnamed keys
Unnamed key sequences

  String  Command                 Meaning
  ------  -------                 -------
  "^A"    [1m/dokey_home[22;0m              cursor to beginning of line
  "^B"    [1m/dokey[22;0m LEFT             *cursor left
  "^D"    [1m/dokey_dch[22;0m              *delete character to the right
  "^E"    [1m/dokey_end[22;0m               cursor to end of line
  "^F"    [1m/dokey[22;0m RIGHT            *cursor right
  "^G"    [1m/beep[22;0m 1                  beep
  "^H"    (internal)              *backspace
  "^I"    [1m/key_tab[22;0m                 perform the function assigned to the TAB key
  "^J"    (internal)               execute current line
  "^K"    [1m/dokey_deol[22;0m              delete to end of line
  "^L"    [1m/dokey[22;0m redraw            redraw (not clear) screen
  "^M"    (internal)               execute current line
  "^N"    [1m/dokey[22;0m recallf          *recall forward input [1mhistory[22;0m
  "^P"    [1m/dokey[22;0m recallb          *recall backward input [1mhistory[22;0m
  "^Q"    [1m/dokey[22;0m LNEXT             input next key literally (may be overridden
                                   by [1mterminal[22;0m)
  "^R"    [1m/dokey[22;0m REFRESH           refresh line
  "^S"    [1m/dokey[22;0m PAUSE             pause screen
  "^T"    [1m/kb_transpose_chars[22;0m     *transpose characters
  "^U"    [1m/kb_backward_kill_line[22;0m   delete to beginning of line
  "^V"    [1m/dokey[22;0m LNEXT             input next key literally
  "^W"    [1m/dokey[22;0m BWORD            *delete backward word (space-delimited)
  "^?"    (internal)              *backspace
  "^X^R"  [1m/load[22;0m [1m~/.tfrc[22;0m            reload personal config file
  "^X^V"  [1m/version[22;0m                 display version information
  "^X^?"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^X["   [1m/dokey[22;0m_hpageback        *scroll back a half screenful
  "^X]"   [1m/dokey[22;0m_hpage            *scroll forward a half screenful
  "^X{"   [1m/dokey[22;0m_pageback         *scroll back a screenful
  "^X}"   [1m/dokey[22;0m_page             *scroll forward a screenful
  "^[^E"  [1m/kb_expand_line[22;0m          [1mexpand[22;0m current input line in place
  "^[^H"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^[^I"  [1m/complete[22;0m                complete current word, depending on context
  "^[^L"  [1m/dokey[22;0m clear             clear screen (can be refilled with [1mscrollback[22;0m)
  "^[^N"  [1m/dokey[22;0m line             *scroll forward one line
  "^[^P"  [1m/dokey[22;0m lineback         *scroll back one line
  "^[^W"  [1m/complete worldname[22;0m      complete TF world name
  "^[$"   [1m/complete macroname[22;0m      complete TF macro name
  "^[%"   [1m/complete variable[22;0m       complete TF variable name
  "^[/"   [1m/complete filename[22;0m       complete file name (unix only)
  "^[ "   [1m/kb_collapse_space[22;0m       change multiple spaces to a single space
  "^[-"   [1m/set[22;0m [1mkbnum[22;0m=-             start [1mkbnum[22;0m entry with -
  "^[0"   [1m/set[22;0m [1mkbnum[22;0m=+0            start [1mkbnum[22;0m entry with 0
  ...
  "^[9"   [1m/set[22;0m [1mkbnum[22;0m=+9            start [1mkbnum[22;0m entry with 9
  "^[;"   [1m/complete user_defined[22;0m   complete from [1m%{completion_list}[22;0m
  "^[="   [1m/kb_goto_match[22;0m           move cursor to matching parenthesis/bracket
  "^[."   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[<"   [1m/dokey[22;0m recallbeg         go to beginning of input history
  "^[>"   [1m/dokey[22;0m recallend         go to end of input history
  "^[J"   [1m/dokey[22;0m selflush          selective flush (similar to "[1m/dokey[22;0m flush"
                                   followed by "[1m/limit[22;0m -a")
  "^[L"   [1m/kb_toggle_limit[22;0m         toggle between [1m/unlimit[22;0m and [1m/relimit[22;0m
  "^[_"   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[b"   [1m/dokey_wleft[22;0m            *cursor to beginning of word
  "^[c"   [1m/kb_capitalize_word[22;0m     *capitalize word
  "^[d"   [1m/kb_kill_word[22;0m           *delete forward word
  "^[fult keybindings
 type 'tiny.mush', escape all 
  occurrences of '%', '[' and '\' within that line, and send the new line 
  instead of the original.  This is useful for avoiding unwanted 
  interpretation of '%', '[', and '\' on TinyMUSH servers.  

      [1m/hook[22;0m SIGHUP = [1m/log[22;0m on%; [1m/recall[22;0m /10

  will [1mlog[22;0m the last 10 lines of output if you are unexpectedly disconnected 
  from your tf session.  

#CONNETFAIL
  The CONNETFAIL hook, which existed in versions 5.0 alpha 13 through 5.0 beta 
  6, has been replaced with the [1mICONFAIL[22;0m hook.  
#

  See also: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mpriority[22;0m, [1msignals[22;0m.  

&topics

topics

  Topics marked with + are new; those marked with * have changed since the 
  last version.  Many topics also have subtopics that are not listed here 
  (e.g., individual [1mvariables[22;0m, [1mhooks[22;0m, and functions).  


   *[1mcopying[22;0m       copyright; no warranty
    [1mintro[22;0m         introduction to tf
    [1mstartup[22;0m       how to start tf
    [1minterface[22;0m     how input works
    [1mtfrc[22;0m          personal config file
   *[1mvisual[22;0m        split-screen mode
   *[1mcommands[22;0m      list of commands
   *[1mworlds[22;0m        defining worlds
   *[1mpatterns[22;0m      glob and regexp pattern matching
   *[1mvariables[22;0m     state and environment
   *[1mglobals[22;0m       special tf variables
    [1mattributes[22;0m    special text display
    [1mprompts[22;0m       using LP/Diku prompts
    [1mproblems[22;0m      bugs, core dumps, etc.
   *[1mevaluation[22;0m    macro body execution
    [1mmacros[22;0m        user-defined commands
   *[1msockets[22;0m       world connections
    [1mhistory[22;0m       recall and logging
    [1mpriority[22;0m      trigger/hook selection
   *[1mkeybindings[22;0m   keyboard operations
    [1mcolor[22;0m         terminal color codes
   *[1mprotocols[22;0m     protocols supported by TF
    [1mexpressions[22;0m   math and string operations
    [1mtriggers[22;0m      automatic command execution based on incoming text
   *[1mhooks[22;0m         automatic command execution based on tf events
   +[1mmail[22;0m          mail checking
    [1mlibrary[22;0m       macros and variables in stdlib.tf
   *[1mtools[22;0m         extra commands in tools.tf
    [1mutilities[22;0m     useful extra command files
   *[1mprocesses[22;0m     timed commands and command quoting
   *[1msubs[22;0m          arithmetic, command, [1mmacro[22;0m, and variable substitutions
   *[1mfunctions[22;0m     special [1mexpression[22;0m operations
   *[1mhints[22;0m         some hints and style tips for [1mmacro[22;0m programming
   +[1mdebugging[22;0m     debugging your [1mmacros[22;0m
   *[1mtfio[22;0m          output, error, and world streams
   *[1mproxy[22;0m         connecting to outside hosts via a proxy server (firewall)
   +[1mlocale[22;0m        multi-language support
    

&typing
&user
&interface

interface

  Any input line that does not begin with '/' will be sent directly to the 
  [1mforeground[22;0m world, if there is one.  A line starting with more than one '/' 
  will be sent to the forground [1msocket[22;0m after having the first '/' removed.  
  (Exception: lines may be caught with a SEND [1mhook[22;0m before being sent; see 
  "[1mhooks[22;0m").  

  Any input line beginning with a single '/' is a TF command, which will be 
  interpreted as described in "[1mevaluation[22;0m".  

  Input lines of the form "^old^new" will cause TF to search backward in the 
  input [1mhistory[22;0m for a line containing "old", replace that text with "new", and 
  execute the modified command.  See: [1mhistory[22;0m.  

  Many special functions, such as backspace, can be performed by special keys 
  or sequences of keys.  See "[1mdokey[22;0m" for a complete list.  You can also define 
  your own commands and bind them to key sequences.  See [1mbind[22;0m.  

  Normally, user input does not undergo the [1mexpansion[22;0m that [1mmacro[22;0m bodies 
  undergo.  The [1m/eval[22;0m command can be used to [1mexpand[22;0m text before executing it.  
  If the [1m%{sub}[22;0m flag is on (it is off by default), user input undergoes [1mmacro[22;0m 
  body [1mexpansion[22;0m without the [1m%{sub}[22;0m flag.  The [1m%{sub}[22;0m flag also applies to 
  text generated by "^old^new" history commands.  See: [1mhistory[22;0m, [1m/sub[22;0m, 
  [1mvariables[22;0m 

  Control characters may be input literally.  A literal control character will 
  be displayed in the input window in printable form in bold reverse.  Note 
  that since most control keys are also parts of the default keybindings, it 
  will usually be necessary to type ^V ([1m/dokey[22;0m LNEXT) to avoid invoking the 
  keybinding.  

  International characters may be input if your [1mlocale[22;0m is set to a locale that 
  supports them and your system supports locales.  Any input character that is 
  not valid in your locale and has the high bit set (normally generated by 
  holding the "meta" key) will be translated to ESC plus that character with 
  the high bit stripped (assuming [1m%meta_esc[22;0m is on).  This allows M-x and ^[x 
  to invoke the same ^[x keybinding.  See [1mlocale[22;0m, [1m%meta_esc[22;0m, [1m%istrip[22;0m.  

  If standard input is not a terminal, [1mvisual[22;0m mode will not be allowed, and tf 
  will continue to operate even after EOF is read, until /quit or something 
  else terminates it.  

  See also: [1mvisual[22;0m, [1moptions[22;0m 

&intro
&me
&newbie
&tinyfugue
&introduction

introduction

  TinyFugue is a MUD client.  It helps you connect to a MUD, in a much more 
  convenient manner than telnet.  You can connect to a mud world using the 
  same syntax as you would with telnet: "[1mtf[22;0m <[4mhost[24m> <[4mport[24m>".  Or, while running 
  tf, you can use "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>".  To make things easier, you can 
  give names to worlds, using [1m/addworld[22;0m, and then use "[1mtf[22;0m <[4mname[24m>" and 
  "[1m/connect[22;0m <[4mname[24m>".  If you store a set of [1m/addworld[22;0m commands in a file, TF 
  can read them automatically when it starts.  You can even connect to more 
  than one world at the same time, and switch between them.  See: [1m/connect[22;0m, 
  [1m/fg[22;0m, [1m/addworld[22;0m, [1mworlds[22;0m, [1mtfrc[22;0m.  

  Normally, TF will split the screen into two windows: one for input, and one 
  for output.  TF will display useful information on the line separating the 
  two windows, such as the name of the [1mforeground[22;0m world.  See: [1mwindows[22;0m.  

  Any line you type that starts with a single '/' is a tf command.  Anything 
  else you type will be sent to the mud.  See: [1minterface[22;0m, [1mcommands[22;0m.  

  You can define your own tf commands, called [1mmacros[22;0m.  The simplest type of 
  [1mmacro[22;0m is just an abbreviation or alias for a longer command or commands.  
  But [1mmacros[22;0m can also perform much more powerful tasks.  See: [1mmacros[22;0m, [1m/def[22;0m.  

  You can tell tf to watch for certain patterns in the text from the mud, and 
  then do special things when it sees that pattern: display the text in a 
  special way ([1mhilite[22;0m); not display the text at all ([1mgag[22;0m); execute a [1mmacro[22;0m 
  command ([1mtrigger[22;0m); or do any combination of these.  See: [1mattributes[22;0m, 
  [1mtriggers[22;0m, [1m/hilite[22;0m, [1m/gag[22;0m, [1m/trig[22;0m, [1m/def[22;0m.  

  TF keeps a [1mhistory[22;0m of every line it prints, every line sent by the mud, and 
  every command you enter.  You can see those histories using [1m/recall[22;0m.  You 
  can also have this text saved in a file using [1m/log[22;0m.  See: [1mhistory[22;0m, [1m/recall[22;0m, 
  [1m/log[22;0m.  

  See also: [1mtopics[22;0m 

&keys
&key
&kbbind
&kbfunc
&kbfunc.tf
&kbbind.tf
&keybindings

keybindings

Default keybindings

  TF's default command line editing keys are similar to those in emacs and 
  bash.  In addition, several features may be invoked by more than one 
  keybinding, and TF has keybindings for unique features like switching the 
  [1mforeground[22;0m [1msocket[22;0m.  

  Here, and throughout the TF documentation, the notation "^X" means the 
  character generated by typing the X key while holding the CTRL key.  Also, 
  "^[" can be more easily typed just by pressing the ESC key.  [1m/Def -b[22;0m and 
  [1m/bind[22;0m accept the ^X notation as well as "\<[4mnumber[24m>" notation, where <[4mnumber[24m> 
  is the octal, hexadecimal, or decimal number of the character's ascii value. 
  For example, the escape character can be given in any of these forms: ^[, 
  \033, \0x1B, or \27.  

  In the tables below, keys with "*" in the "Meaning" column make use of [1mkbnum[22;0m 
  (see [1mbelow[22;0m).  

#named keys
Named keys
  To redefine the named keys, see the section titled "[1mMapping Named Keys to 
  functions[22;0m".  

  Key         Command                 Meaning
  ---         -------                 -------
  Up          /kb_up_or_recallb       *cursor up or recall bkwd input [1mhistory[22;0m
  Down        /kb_down_or_recallf     *cursor down or recall fwd input [1mhistory[22;0m
  Right       [1m/dokey[22;0m RIGHT            *cursor right
  Left        [1m/dokey[22;0m LEFT             *cursor left
  Center      (none)

  Esc_Left    [1m/fg[22;0m -<                  *[1mforeground[22;0m previous [1msocket[22;0m
  Esc_Right   [1m/fg[22;0m ->                  *[1mforeground[22;0m next [1msocket[22;0m

  Ctrl_Up     [1m/dokey_recallb[22;0m          *recall backward input
  Ctrl_Down   [1m/dokey_recallf[22;0m          *recall forward input
  Ctrl_Right  [1m/dokey_wright[22;0m           *word right
  Ctrl_Left   [1m/dokey_wleft[22;0m            *word left

  Insert      [1m/test[22;0m [1minsert[22;0m:=![1minsert[22;0m    toggle [1minsert[22;0m mode
  Delete      [1m/dokey[22;0m dch              *delete character
  Home        [1m/dokey_home[22;0m              cursor to beginning of line
  End         [1m/dokey_end[22;0m               cursor to end of line
  PgDn        [1m/dokey_pgdn[22;0m             *scroll forward a screenful
  PgUp        [1m/dokey_pgup[22;0m             *scroll back a screenful
  Tab         [1m/dokey page[22;0m             *scroll forward a screenful

  Ctrl_Home   [1m/dokey_recallbeg[22;0m         recall first line of input
  Ctrl_End    [1m/dokey_recallend[22;0m         recall last line of input
  Ctrl_PgDn   [1m/dokey_flush[22;0m             scroll forward to last screenful
  Ctrl_PgUp   (reserved for future use)

  F1          [1m/help[22;0m                    help
  F2          (none)                   (function key F1)
  ...
  F20         (none)                   (function key F20)

  nkpTab      (none)                   (see "[1mkeypad[22;0m" section below)
  nkpEnt      (none)                   (see "[1mkeypad[22;0m" section below)
  nkp*        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp+        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp,        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp-        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp.        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp/        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp0        (none)                   (see "[1mkeypad[22;0m" section below)
  ...
  nkp9        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp=        (none)                   (see "[1mkeypad[22;0m" section below)

#unnamed keys
Unnamed key sequences

  String  Command                 Meaning
  ------  -------                 -------
  "^A"    [1m/dokey_home[22;0m              cursor to beginning of line
  "^B"    [1m/dokey[22;0m LEFT             *cursor left
  "^D"    [1m/dokey_dch[22;0m              *delete character to the right
  "^E"    [1m/dokey_end[22;0m               cursor to end of line
  "^F"    [1m/dokey[22;0m RIGHT            *cursor right
  "^G"    [1m/beep[22;0m 1                  beep
  "^H"    (internal)              *backspace
  "^I"    [1m/key_tab[22;0m                 perform the function assigned to the TAB key
  "^J"    (internal)               execute current line
  "^K"    [1m/dokey_deol[22;0m              delete to end of line
  "^L"    [1m/dokey[22;0m redraw            redraw (not clear) screen
  "^M"    (internal)               execute current line
  "^N"    [1m/dokey[22;0m recallf          *recall forward input [1mhistory[22;0m
  "^P"    [1m/dokey[22;0m recallb          *recall backward input [1mhistory[22;0m
  "^Q"    [1m/dokey[22;0m LNEXT             input next key literally (may be overridden
                                   by [1mterminal[22;0m)
  "^R"    [1m/dokey[22;0m REFRESH           refresh line
  "^S"    [1m/dokey[22;0m PAUSE             pause screen
  "^T"    [1m/kb_transpose_chars[22;0m     *transpose characters
  "^U"    [1m/kb_backward_kill_line[22;0m   delete to beginning of line
  "^V"    [1m/dokey[22;0m LNEXT             input next key literally
  "^W"    [1m/dokey[22;0m BWORD            *delete backward word (space-delimited)
  "^?"    (internal)              *backspace
  "^X^R"  [1m/load[22;0m [1m~/.tfrc[22;0m            reload personal config file
  "^X^V"  [1m/version[22;0m                 display version information
  "^X^?"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^X["   [1m/dokey[22;0m_hpageback        *scroll back a half screenful
  "^X]"   [1m/dokey[22;0m_hpage            *scroll forward a half screenful
  "^X{"   [1m/dokey[22;0m_pageback         *scroll back a screenful
  "^X}"   [1m/dokey[22;0m_page             *scroll forward a screenful
  "^[^E"  [1m/kb_expand_line[22;0m          [1mexpand[22;0m current input line in place
  "^[^H"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^[^I"  [1m/complete[22;0m                complete current word, depending on context
  "^[^L"  [1m/dokey[22;0m clear             clear screen (can be refilled with [1mscrollback[22;0m)
  "^[^N"  [1m/dokey[22;0m line             *scroll forward one line
  "^[^P"  [1m/dokey[22;0m lineback         *scroll back one line
  "^[^W"  [1m/complete worldname[22;0m      complete TF world name
  "^[$"   [1m/complete macroname[22;0m      complete TF macro name
  "^[%"   [1m/complete variable[22;0m       complete TF variable name
  "^[/"   [1m/complete filename[22;0m       complete file name (unix only)
  "^[ "   [1m/kb_collapse_space[22;0m       change multiple spaces to a single space
  "^[-"   [1m/set[22;0m [1mkbnum[22;0m=-             start [1mkbnum[22;0m entry with -
  "^[0"   [1m/set[22;0m [1mkbnum[22;0m=+0            start [1mkbnum[22;0m entry with 0
  ...
  "^[9"   [1m/set[22;0m [1mkbnum[22;0m=+9            start [1mkbnum[22;0m entry with 9
  "^[;"   [1m/complete user_defined[22;0m   complete from [1m%{completion_list}[22;0m
  "^[="   [1m/kb_goto_match[22;0m           move cursor to matching parenthesis/bracket
  "^[."   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[<"   [1m/dokey[22;0m recallbeg         go to beginning of input history
  "^[>"   [1m/dokey[22;0m recallend         go to end of input history
  "^[J"   [1m/dokey[22;0m selflush          selective flush (similar to "[1m/dokey[22;0m flush"
                                   followed by "[1m/limit[22;0m -a")
  "^[L"   [1m/kb_toggle_limit[22;0m         toggle between [1m/unlimit[22;0m and [1m/relimit[22;0m
  "^[_"   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[b"   [1m/dokey_wleft[22;0m            *cursor to beginning of word
  "^[c"   [1m/kb_capitalize_word[22;0m     *capitalize word
  "^[d"   [1m/kb_kill_word[22;0m           *delete forward word
  "^[fult keybindings
 type 'tiny.mush', escape all 
  occurrences of '%', '[' and '\' within that line, and send the new line 
  instead of the original.  This is useful for avoiding unwanted 
  interpretation of '%', '[', and '\' on TinyMUSH servers.  

      [1m/hook[22;0m SIGHUP = [1m/log[22;0m on%; [1m/recall[22;0m /10

  will [1mlog[22;0m the last 10 lines of output if you are unexpectedly disconnected 
  from your tf session.  

#CONNETFAIL
  The CONNETFAIL hook, which existed in versions 5.0 alpha 13 through 5.0 beta 
  6, has been replaced with the [1mICONFAIL[22;0m hook.  
#

  See also: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mpriority[22;0m, [1msignals[22;0m.  

&topics

topics

  Topics marked with + are new; those marked with * have changed since the 
  last version.  Many topics also have subtopics that are not listed here 
  (e.g., individual [1mvariables[22;0m, [1mhooks[22;0m, and functions).  


   *[1mcopying[22;0m       copyright; no warranty
    [1mintro[22;0m         introduction to tf
    [1mstartup[22;0m       how to start tf
    [1minterface[22;0m     how input works
    [1mtfrc[22;0m          personal config file
   *[1mvisual[22;0m        split-screen mode
   *[1mcommands[22;0m      list of commands
   *[1mworlds[22;0m        defining worlds
   *[1mpatterns[22;0m      glob and regexp pattern matching
   *[1mvariables[22;0m     state and environment
   *[1mglobals[22;0m       special tf variables
    [1mattributes[22;0m    special text display
    [1mprompts[22;0m       using LP/Diku prompts
    [1mproblems[22;0m      bugs, core dumps, etc.
   *[1mevaluation[22;0m    macro body execution
    [1mmacros[22;0m        user-defined commands
   *[1msockets[22;0m       world connections
    [1mhistory[22;0m       recall and logging
    [1mpriority[22;0m      trigger/hook selection
   *[1mkeybindings[22;0m   keyboard operations
    [1mcolor[22;0m         terminal color codes
   *[1mprotocols[22;0m     protocols supported by TF
    [1mexpressions[22;0m   math and string operations
    [1mtriggers[22;0m      automatic command execution based on incoming text
   *[1mhooks[22;0m         automatic command execution based on tf events
   +[1mmail[22;0m          mail checking
    [1mlibrary[22;0m       macros and variables in stdlib.tf
   *[1mtools[22;0m         extra commands in tools.tf
    [1mutilities[22;0m     useful extra command files
   *[1mprocesses[22;0m     timed commands and command quoting
   *[1msubs[22;0m          arithmetic, command, [1mmacro[22;0m, and variable substitutions
   *[1mfunctions[22;0m     special [1mexpression[22;0m operations
   *[1mhints[22;0m         some hints and style tips for [1mmacro[22;0m programming
   +[1mdebugging[22;0m     debugging your [1mmacros[22;0m
   *[1mtfio[22;0m          output, error, and world streams
   *[1mproxy[22;0m         connecting to outside hosts via a proxy server (firewall)
   +[1mlocale[22;0m        multi-language support
    

&typing
&user
&interface

interface

  Any input line that does not begin with '/' will be sent directly to the 
  [1mforeground[22;0m world, if there is one.  A line starting with more than one '/' 
  will be sent to the forground [1msocket[22;0m after having the first '/' removed.  
  (Exception: lines may be caught with a SEND [1mhook[22;0m before being sent; see 
  "[1mhooks[22;0m").  

  Any input line beginning with a single '/' is a TF command, which will be 
  interpreted as described in "[1mevaluation[22;0m".  

  Input lines of the form "^old^new" will cause TF to search backward in the 
  input [1mhistory[22;0m for a line containing "old", replace that text with "new", and 
  execute the modified command.  See: [1mhistory[22;0m.  

  Many special functions, such as backspace, can be performed by special keys 
  or sequences of keys.  See "[1mdokey[22;0m" for a complete list.  You can also define 
  your own commands and bind them to key sequences.  See [1mbind[22;0m.  

  Normally, user input does not undergo the [1mexpansion[22;0m that [1mmacro[22;0m bodies 
  undergo.  The [1m/eval[22;0m command can be used to [1mexpand[22;0m text before executing it.  
  If the [1m%{sub}[22;0m flag is on (it is off by default), user input undergoes [1mmacro[22;0m 
  body [1mexpansion[22;0m without the [1m%{sub}[22;0m flag.  The [1m%{sub}[22;0m flag also applies to 
  text generated by "^old^new" history commands.  See: [1mhistory[22;0m, [1m/sub[22;0m, 
  [1mvariables[22;0m 

  Control characters may be input literally.  A literal control character will 
  be displayed in the input window in printable form in bold reverse.  Note 
  that since most control keys are also parts of the default keybindings, it 
  will usually be necessary to type ^V ([1m/dokey[22;0m LNEXT) to avoid invoking the 
  keybinding.  

  International characters may be input if your [1mlocale[22;0m is set to a locale that 
  supports them and your system supports locales.  Any input character that is 
  not valid in your locale and has the high bit set (normally generated by 
  holding the "meta" key) will be translated to ESC plus that character with 
  the high bit stripped (assuming [1m%meta_esc[22;0m is on).  This allows M-x and ^[x 
  to invoke the same ^[x keybinding.  See [1mlocale[22;0m, [1m%meta_esc[22;0m, [1m%istrip[22;0m.  

  If standard input is not a terminal, [1mvisual[22;0m mode will not be allowed, and tf 
  will continue to operate even after EOF is read, until /quit or something 
  else terminates it.  

  See also: [1mvisual[22;0m, [1moptions[22;0m 

&intro
&me
&newbie
&tinyfugue
&introduction

introduction

  TinyFugue is a MUD client.  It helps you connect to a MUD, in a much more 
  convenient manner than telnet.  You can connect to a mud world using the 
  same syntax as you would with telnet: "[1mtf[22;0m <[4mhost[24m> <[4mport[24m>".  Or, while running 
  tf, you can use "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>".  To make things easier, you can 
  give names to worlds, using [1m/addworld[22;0m, and then use "[1mtf[22;0m <[4mname[24m>" and 
  "[1m/connect[22;0m <[4mname[24m>".  If you store a set of [1m/addworld[22;0m commands in a file, TF 
  can read them automatically when it starts.  You can even connect to more 
  than one world at the same time, and switch between them.  See: [1m/connect[22;0m, 
  [1m/fg[22;0m, [1m/addworld[22;0m, [1mworlds[22;0m, [1mtfrc[22;0m.  

  Normally, TF will split the screen into two windows: one for input, and one 
  for output.  TF will display useful information on the line separating the 
  two windows, such as the name of the [1mforeground[22;0m world.  See: [1mwindows[22;0m.  

  Any line you type that starts with a single '/' is a tf command.  Anything 
  else you type will be sent to the mud.  See: [1minterface[22;0m, [1mcommands[22;0m.  

  You can define your own tf commands, called [1mmacros[22;0m.  The simplest type of 
  [1mmacro[22;0m is just an abbreviation or alias for a longer command or commands.  
  But [1mmacros[22;0m can also perform much more powerful tasks.  See: [1mmacros[22;0m, [1m/def[22;0m.  

  You can tell tf to watch for certain patterns in the text from the mud, and 
  then do special things when it sees that pattern: display the text in a 
  special way ([1mhilite[22;0m); not display the text at all ([1mgag[22;0m); execute a [1mmacro[22;0m 
  command ([1mtrigger[22;0m); or do any combination of these.  See: [1mattributes[22;0m, 
  [1mtriggers[22;0m, [1m/hilite[22;0m, [1m/gag[22;0m, [1m/trig[22;0m, [1m/def[22;0m.  

  TF keeps a [1mhistory[22;0m of every line it prints, every line sent by the mud, and 
  every command you enter.  You can see those histories using [1m/recall[22;0m.  You 
  can also have this text saved in a file using [1m/log[22;0m.  See: [1mhistory[22;0m, [1m/recall[22;0m, 
  [1m/log[22;0m.  

  See also: [1mtopics[22;0m 

&keys
&key
&kbbind
&kbfunc
&kbfunc.tf
&kbbind.tf
&keybindings

keybindings

Default keybindings

  TF's default command line editing keys are similar to those in emacs and 
  bash.  In addition, several features may be invoked by more than one 
  keybinding, and TF has keybindings for unique features like switching the 
  [1mforeground[22;0m [1msocket[22;0m.  

  Here, and throughout the TF documentation, the notation "^X" means the 
  character generated by typing the X key while holding the CTRL key.  Also, 
  "^[" can be more easily typed just by pressing the ESC key.  [1m/Def -b[22;0m and 
  [1m/bind[22;0m accept the ^X notation as well as "\<[4mnumber[24m>" notation, where <[4mnumber[24m> 
  is the octal, hexadecimal, or decimal number of the character's ascii value. 
  For example, the escape character can be given in any of these forms: ^[, 
  \033, \0x1B, or \27.  

  In the tables below, keys with "*" in the "Meaning" column make use of [1mkbnum[22;0m 
  (see [1mbelow[22;0m).  

#named keys
Named keys
  To redefine the named keys, see the section titled "[1mMapping Named Keys to 
  functions[22;0m".  

  Key         Command                 Meaning
  ---         -------                 -------
  Up          /kb_up_or_recallb       *cursor up or recall bkwd input [1mhistory[22;0m
  Down        /kb_down_or_recallf     *cursor down or recall fwd input [1mhistory[22;0m
  Right       [1m/dokey[22;0m RIGHT            *cursor right
  Left        [1m/dokey[22;0m LEFT             *cursor left
  Center      (none)

  Esc_Left    [1m/fg[22;0m -<                  *[1mforeground[22;0m previous [1msocket[22;0m
  Esc_Right   [1m/fg[22;0m ->                  *[1mforeground[22;0m next [1msocket[22;0m

  Ctrl_Up     [1m/dokey_recallb[22;0m          *recall backward input
  Ctrl_Down   [1m/dokey_recallf[22;0m          *recall forward input
  Ctrl_Right  [1m/dokey_wright[22;0m           *word right
  Ctrl_Left   [1m/dokey_wleft[22;0m            *word left

  Insert      [1m/test[22;0m [1minsert[22;0m:=![1minsert[22;0m    toggle [1minsert[22;0m mode
  Delete      [1m/dokey[22;0m dch              *delete character
  Home        [1m/dokey_home[22;0m              cursor to beginning of line
  End         [1m/dokey_end[22;0m               cursor to end of line
  PgDn        [1m/dokey_pgdn[22;0m             *scroll forward a screenful
  PgUp        [1m/dokey_pgup[22;0m             *scroll back a screenful
  Tab         [1m/dokey page[22;0m             *scroll forward a screenful

  Ctrl_Home   [1m/dokey_recallbeg[22;0m         recall first line of input
  Ctrl_End    [1m/dokey_recallend[22;0m         recall last line of input
  Ctrl_PgDn   [1m/dokey_flush[22;0m             scroll forward to last screenful
  Ctrl_PgUp   (reserved for future use)

  F1          [1m/help[22;0m                    help
  F2          (none)                   (function key F1)
  ...
  F20         (none)                   (function key F20)

  nkpTab      (none)                   (see "[1mkeypad[22;0m" section below)
  nkpEnt      (none)                   (see "[1mkeypad[22;0m" section below)
  nkp*        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp+        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp,        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp-        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp.        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp/        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp0        (none)                   (see "[1mkeypad[22;0m" section below)
  ...
  nkp9        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp=        (none)                   (see "[1mkeypad[22;0m" section below)

#unnamed keys
Unnamed key sequences

  String  Command                 Meaning
  ------  -------                 -------
  "^A"    [1m/dokey_home[22;0m              cursor to beginning of line
  "^B"    [1m/dokey[22;0m LEFT             *cursor left
  "^D"    [1m/dokey_dch[22;0m              *delete character to the right
  "^E"    [1m/dokey_end[22;0m               cursor to end of line
  "^F"    [1m/dokey[22;0m RIGHT            *cursor right
  "^G"    [1m/beep[22;0m 1                  beep
  "^H"    (internal)              *backspace
  "^I"    [1m/key_tab[22;0m                 perform the function assigned to the TAB key
  "^J"    (internal)               execute current line
  "^K"    [1m/dokey_deol[22;0m              delete to end of line
  "^L"    [1m/dokey[22;0m redraw            redraw (not clear) screen
  "^M"    (internal)               execute current line
  "^N"    [1m/dokey[22;0m recallf          *recall forward input [1mhistory[22;0m
  "^P"    [1m/dokey[22;0m recallb          *recall backward input [1mhistory[22;0m
  "^Q"    [1m/dokey[22;0m LNEXT             input next key literally (may be overridden
                                   by [1mterminal[22;0m)
  "^R"    [1m/dokey[22;0m REFRESH           refresh line
  "^S"    [1m/dokey[22;0m PAUSE             pause screen
  "^T"    [1m/kb_transpose_chars[22;0m     *transpose characters
  "^U"    [1m/kb_backward_kill_line[22;0m   delete to beginning of line
  "^V"    [1m/dokey[22;0m LNEXT             input next key literally
  "^W"    [1m/dokey[22;0m BWORD            *delete backward word (space-delimited)
  "^?"    (internal)              *backspace
  "^X^R"  [1m/load[22;0m [1m~/.tfrc[22;0m            reload personal config file
  "^X^V"  [1m/version[22;0m                 display version information
  "^X^?"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^X["   [1m/dokey[22;0m_hpageback        *scroll back a half screenful
  "^X]"   [1m/dokey[22;0m_hpage            *scroll forward a half screenful
  "^X{"   [1m/dokey[22;0m_pageback         *scroll back a screenful
  "^X}"   [1m/dokey[22;0m_page             *scroll forward a screenful
  "^[^E"  [1m/kb_expand_line[22;0m          [1mexpand[22;0m current input line in place
  "^[^H"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^[^I"  [1m/complete[22;0m                complete current word, depending on context
  "^[^L"  [1m/dokey[22;0m clear             clear screen (can be refilled with [1mscrollback[22;0m)
  "^[^N"  [1m/dokey[22;0m line             *scroll forward one line
  "^[^P"  [1m/dokey[22;0m lineback         *scroll back one line
  "^[^W"  [1m/complete worldname[22;0m      complete TF world name
  "^[$"   [1m/complete macroname[22;0m      complete TF macro name
  "^[%"   [1m/complete variable[22;0m       complete TF variable name
  "^[/"   [1m/complete filename[22;0m       complete file name (unix only)
  "^[ "   [1m/kb_collapse_space[22;0m       change multiple spaces to a single space
  "^[-"   [1m/set[22;0m [1mkbnum[22;0m=-             start [1mkbnum[22;0m entry with -
  "^[0"   [1m/set[22;0m [1mkbnum[22;0m=+0            start [1mkbnum[22;0m entry with 0
  ...
  "^[9"   [1m/set[22;0m [1mkbnum[22;0m=+9            start [1mkbnum[22;0m entry with 9
  "^[;"   [1m/complete user_defined[22;0m   complete from [1m%{completion_list}[22;0m
  "^[="   [1m/kb_goto_match[22;0m           move cursor to matching parenthesis/bracket
  "^[."   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[<"   [1m/dokey[22;0m recallbeg         go to beginning of input history
  "^[>"   [1m/dokey[22;0m recallend         go to end of input history
  "^[J"   [1m/dokey[22;0m selflush          selective flush (similar to "[1m/dokey[22;0m flush"
                                   followed by "[1m/limit[22;0m -a")
  "^[L"   [1m/kb_toggle_limit[22;0m         toggle between [1m/unlimit[22;0m and [1m/relimit[22;0m
  "^[_"   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[b"   [1m/dokey_wleft[22;0m            *cursor to beginning of word
  "^[c"   [1m/kb_capitalize_word[22;0m     *capitalize word
  "^[d"   [1m/kb_kill_word[22;0m           *delete forward word
  "^[fult keybindings
 type 'tiny.mush', escape all 
  occurrences of '%', '[' and '\' within that line, and send the new line 
  instead of the original.  This is useful for avoiding unwanted 
  interpretation of '%', '[', and '\' on TinyMUSH servers.  

      [1m/hook[22;0m SIGHUP = [1m/log[22;0m on%; [1m/recall[22;0m /10

  will [1mlog[22;0m the last 10 lines of output if you are unexpectedly disconnected 
  from your tf session.  

#CONNETFAIL
  The CONNETFAIL hook, which existed in versions 5.0 alpha 13 through 5.0 beta 
  6, has been replaced with the [1mICONFAIL[22;0m hook.  
#

  See also: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mpriority[22;0m, [1msignals[22;0m.  

&topics

topics

  Topics marked with + are new; those marked with * have changed since the 
  last version.  Many topics also have subtopics that are not listed here 
  (e.g., individual [1mvariables[22;0m, [1mhooks[22;0m, and functions).  


   *[1mcopying[22;0m       copyright; no warranty
    [1mintro[22;0m         introduction to tf
    [1mstartup[22;0m       how to start tf
    [1minterface[22;0m     how input works
    [1mtfrc[22;0m          personal config file
   *[1mvisual[22;0m        split-screen mode
   *[1mcommands[22;0m      list of commands
   *[1mworlds[22;0m        defining worlds
   *[1mpatterns[22;0m      glob and regexp pattern matching
   *[1mvariables[22;0m     state and environment
   *[1mglobals[22;0m       special tf variables
    [1mattributes[22;0m    special text display
    [1mprompts[22;0m       using LP/Diku prompts
    [1mproblems[22;0m      bugs, core dumps, etc.
   *[1mevaluation[22;0m    macro body execution
    [1mmacros[22;0m        user-defined commands
   *[1msockets[22;0m       world connections
    [1mhistory[22;0m       recall and logging
    [1mpriority[22;0m      trigger/hook selection
   *[1mkeybindings[22;0m   keyboard operations
    [1mcolor[22;0m         terminal color codes
   *[1mprotocols[22;0m     protocols supported by TF
    [1mexpressions[22;0m   math and string operations
    [1mtriggers[22;0m      automatic command execution based on incoming text
   *[1mhooks[22;0m         automatic command execution based on tf events
   +[1mmail[22;0m          mail checking
    [1mlibrary[22;0m       macros and variables in stdlib.tf
   *[1mtools[22;0m         extra commands in tools.tf
    [1mutilities[22;0m     useful extra command files
   *[1mprocesses[22;0m     timed commands and command quoting
   *[1msubs[22;0m          arithmetic, command, [1mmacro[22;0m, and variable substitutions
   *[1mfunctions[22;0m     special [1mexpression[22;0m operations
   *[1mhints[22;0m         some hints and style tips for [1mmacro[22;0m programming
   +[1mdebugging[22;0m     debugging your [1mmacros[22;0m
   *[1mtfio[22;0m          output, error, and world streams
   *[1mproxy[22;0m         connecting to outside hosts via a proxy server (firewall)
   +[1mlocale[22;0m        multi-language support
    

&typing
&user
&interface

interface

  Any input line that does not begin with '/' will be sent directly to the 
  [1mforeground[22;0m world, if there is one.  A line starting with more than one '/' 
  will be sent to the forground [1msocket[22;0m after having the first '/' removed.  
  (Exception: lines may be caught with a SEND [1mhook[22;0m before being sent; see 
  "[1mhooks[22;0m").  

  Any input line beginning with a single '/' is a TF command, which will be 
  interpreted as described in "[1mevaluation[22;0m".  

  Input lines of the form "^old^new" will cause TF to search backward in the 
  input [1mhistory[22;0m for a line containing "old", replace that text with "new", and 
  execute the modified command.  See: [1mhistory[22;0m.  

  Many special functions, such as backspace, can be performed by special keys 
  or sequences of keys.  See "[1mdokey[22;0m" for a complete list.  You can also define 
  your own commands and bind them to key sequences.  See [1mbind[22;0m.  

  Normally, user input does not undergo the [1mexpansion[22;0m that [1mmacro[22;0m bodies 
  undergo.  The [1m/eval[22;0m command can be used to [1mexpand[22;0m text before executing it.  
  If the [1m%{sub}[22;0m flag is on (it is off by default), user input undergoes [1mmacro[22;0m 
  body [1mexpansion[22;0m without the [1m%{sub}[22;0m flag.  The [1m%{sub}[22;0m flag also applies to 
  text generated by "^old^new" history commands.  See: [1mhistory[22;0m, [1m/sub[22;0m, 
  [1mvariables[22;0m 

  Control characters may be input literally.  A literal control character will 
  be displayed in the input window in printable form in bold reverse.  Note 
  that since most control keys are also parts of the default keybindings, it 
  will usually be necessary to type ^V ([1m/dokey[22;0m LNEXT) to avoid invoking the 
  keybinding.  

  International characters may be input if your [1mlocale[22;0m is set to a locale that 
  supports them and your system supports locales.  Any input character that is 
  not valid in your locale and has the high bit set (normally generated by 
  holding the "meta" key) will be translated to ESC plus that character with 
  the high bit stripped (assuming [1m%meta_esc[22;0m is on).  This allows M-x and ^[x 
  to invoke the same ^[x keybinding.  See [1mlocale[22;0m, [1m%meta_esc[22;0m, [1m%istrip[22;0m.  

  If standard input is not a terminal, [1mvisual[22;0m mode will not be allowed, and tf 
  will continue to operate even after EOF is read, until /quit or something 
  else terminates it.  

  See also: [1mvisual[22;0m, [1moptions[22;0m 

&intro
&me
&newbie
&tinyfugue
&introduction

introduction

  TinyFugue is a MUD client.  It helps you connect to a MUD, in a much more 
  convenient manner than telnet.  You can connect to a mud world using the 
  same syntax as you would with telnet: "[1mtf[22;0m <[4mhost[24m> <[4mport[24m>".  Or, while running 
  tf, you can use "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>".  To make things easier, you can 
  give names to worlds, using [1m/addworld[22;0m, and then use "[1mtf[22;0m <[4mname[24m>" and 
  "[1m/connect[22;0m <[4mname[24m>".  If you store a set of [1m/addworld[22;0m commands in a file, TF 
  can read them automatically when it starts.  You can even connect to more 
  than one world at the same time, and switch between them.  See: [1m/connect[22;0m, 
  [1m/fg[22;0m, [1m/addworld[22;0m, [1mworlds[22;0m, [1mtfrc[22;0m.  

  Normally, TF will split the screen into two windows: one for input, and one 
  for output.  TF will display useful information on the line separating the 
  two windows, such as the name of the [1mforeground[22;0m world.  See: [1mwindows[22;0m.  

  Any line you type that starts with a single '/' is a tf command.  Anything 
  else you type will be sent to the mud.  See: [1minterface[22;0m, [1mcommands[22;0m.  

  You can define your own tf commands, called [1mmacros[22;0m.  The simplest type of 
  [1mmacro[22;0m is just an abbreviation or alias for a longer command or commands.  
  But [1mmacros[22;0m can also perform much more powerful tasks.  See: [1mmacros[22;0m, [1m/def[22;0m.  

  You can tell tf to watch for certain patterns in the text from the mud, and 
  then do special things when it sees that pattern: display the text in a 
  special way ([1mhilite[22;0m); not display the text at all ([1mgag[22;0m); execute a [1mmacro[22;0m 
  command ([1mtrigger[22;0m); or do any combination of these.  See: [1mattributes[22;0m, 
  [1mtriggers[22;0m, [1m/hilite[22;0m, [1m/gag[22;0m, [1m/trig[22;0m, [1m/def[22;0m.  

  TF keeps a [1mhistory[22;0m of every line it prints, every line sent by the mud, and 
  every command you enter.  You can see those histories using [1m/recall[22;0m.  You 
  can also have this text saved in a file using [1m/log[22;0m.  See: [1mhistory[22;0m, [1m/recall[22;0m, 
  [1m/log[22;0m.  

  See also: [1mtopics[22;0m 

&keys
&key
&kbbind
&kbfunc
&kbfunc.tf
&kbbind.tf
&keybindings

keybindings

Default keybindings

  TF's default command line editing keys are similar to those in emacs and 
  bash.  In addition, several features may be invoked by more than one 
  keybinding, and TF has keybindings for unique features like switching the 
  [1mforeground[22;0m [1msocket[22;0m.  

  Here, and throughout the TF documentation, the notation "^X" means the 
  character generated by typing the X key while holding the CTRL key.  Also, 
  "^[" can be more easily typed just by pressing the ESC key.  [1m/Def -b[22;0m and 
  [1m/bind[22;0m accept the ^X notation as well as "\<[4mnumber[24m>" notation, where <[4mnumber[24m> 
  is the octal, hexadecimal, or decimal number of the character's ascii value. 
  For example, the escape character can be given in any of these forms: ^[, 
  \033, \0x1B, or \27.  

  In the tables below, keys with "*" in the "Meaning" column make use of [1mkbnum[22;0m 
  (see [1mbelow[22;0m).  

#named keys
Named keys
  To redefine the named keys, see the section titled "[1mMapping Named Keys to 
  functions[22;0m".  

  Key         Command                 Meaning
  ---         -------                 -------
  Up          /kb_up_or_recallb       *cursor up or recall bkwd input [1mhistory[22;0m
  Down        /kb_down_or_recallf     *cursor down or recall fwd input [1mhistory[22;0m
  Right       [1m/dokey[22;0m RIGHT            *cursor right
  Left        [1m/dokey[22;0m LEFT             *cursor left
  Center      (none)

  Esc_Left    [1m/fg[22;0m -<                  *[1mforeground[22;0m previous [1msocket[22;0m
  Esc_Right   [1m/fg[22;0m ->                  *[1mforeground[22;0m next [1msocket[22;0m

  Ctrl_Up     [1m/dokey_recallb[22;0m          *recall backward input
  Ctrl_Down   [1m/dokey_recallf[22;0m          *recall forward input
  Ctrl_Right  [1m/dokey_wright[22;0m           *word right
  Ctrl_Left   [1m/dokey_wleft[22;0m            *word left

  Insert      [1m/test[22;0m [1minsert[22;0m:=![1minsert[22;0m    toggle [1minsert[22;0m mode
  Delete      [1m/dokey[22;0m dch              *delete character
  Home        [1m/dokey_home[22;0m              cursor to beginning of line
  End         [1m/dokey_end[22;0m               cursor to end of line
  PgDn        [1m/dokey_pgdn[22;0m             *scroll forward a screenful
  PgUp        [1m/dokey_pgup[22;0m             *scroll back a screenful
  Tab         [1m/dokey page[22;0m             *scroll forward a screenful

  Ctrl_Home   [1m/dokey_recallbeg[22;0m         recall first line of input
  Ctrl_End    [1m/dokey_recallend[22;0m         recall last line of input
  Ctrl_PgDn   [1m/dokey_flush[22;0m             scroll forward to last screenful
  Ctrl_PgUp   (reserved for future use)

  F1          [1m/help[22;0m                    help
  F2          (none)                   (function key F1)
  ...
  F20         (none)                   (function key F20)

  nkpTab      (none)                   (see "[1mkeypad[22;0m" section below)
  nkpEnt      (none)                   (see "[1mkeypad[22;0m" section below)
  nkp*        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp+        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp,        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp-        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp.        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp/        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp0        (none)                   (see "[1mkeypad[22;0m" section below)
  ...
  nkp9        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp=        (none)                   (see "[1mkeypad[22;0m" section below)

#unnamed keys
Unnamed key sequences

  String  Command                 Meaning
  ------  -------                 -------
  "^A"    [1m/dokey_home[22;0m              cursor to beginning of line
  "^B"    [1m/dokey[22;0m LEFT             *cursor left
  "^D"    [1m/dokey_dch[22;0m              *delete character to the right
  "^E"    [1m/dokey_end[22;0m               cursor to end of line
  "^F"    [1m/dokey[22;0m RIGHT            *cursor right
  "^G"    [1m/beep[22;0m 1                  beep
  "^H"    (internal)              *backspace
  "^I"    [1m/key_tab[22;0m                 perform the function assigned to the TAB key
  "^J"    (internal)               execute current line
  "^K"    [1m/dokey_deol[22;0m              delete to end of line
  "^L"    [1m/dokey[22;0m redraw            redraw (not clear) screen
  "^M"    (internal)               execute current line
  "^N"    [1m/dokey[22;0m recallf          *recall forward input [1mhistory[22;0m
  "^P"    [1m/dokey[22;0m recallb          *recall backward input [1mhistory[22;0m
  "^Q"    [1m/dokey[22;0m LNEXT             input next key literally (may be overridden
                                   by [1mterminal[22;0m)
  "^R"    [1m/dokey[22;0m REFRESH           refresh line
  "^S"    [1m/dokey[22;0m PAUSE             pause screen
  "^T"    [1m/kb_transpose_chars[22;0m     *transpose characters
  "^U"    [1m/kb_backward_kill_line[22;0m   delete to beginning of line
  "^V"    [1m/dokey[22;0m LNEXT             input next key literally
  "^W"    [1m/dokey[22;0m BWORD            *delete backward word (space-delimited)
  "^?"    (internal)              *backspace
  "^X^R"  [1m/load[22;0m [1m~/.tfrc[22;0m            reload personal config file
  "^X^V"  [1m/version[22;0m                 display version information
  "^X^?"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^X["   [1m/dokey[22;0m_hpageback        *scroll back a half screenful
  "^X]"   [1m/dokey[22;0m_hpage            *scroll forward a half screenful
  "^X{"   [1m/dokey[22;0m_pageback         *scroll back a screenful
  "^X}"   [1m/dokey[22;0m_page             *scroll forward a screenful
  "^[^E"  [1m/kb_expand_line[22;0m          [1mexpand[22;0m current input line in place
  "^[^H"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^[^I"  [1m/complete[22;0m                complete current word, depending on context
  "^[^L"  [1m/dokey[22;0m clear             clear screen (can be refilled with [1mscrollback[22;0m)
  "^[^N"  [1m/dokey[22;0m line             *scroll forward one line
  "^[^P"  [1m/dokey[22;0m lineback         *scroll back one line
  "^[^W"  [1m/complete worldname[22;0m      complete TF world name
  "^[$"   [1m/complete macroname[22;0m      complete TF macro name
  "^[%"   [1m/complete variable[22;0m       complete TF variable name
  "^[/"   [1m/complete filename[22;0m       complete file name (unix only)
  "^[ "   [1m/kb_collapse_space[22;0m       change multiple spaces to a single space
  "^[-"   [1m/set[22;0m [1mkbnum[22;0m=-             start [1mkbnum[22;0m entry with -
  "^[0"   [1m/set[22;0m [1mkbnum[22;0m=+0            start [1mkbnum[22;0m entry with 0
  ...
  "^[9"   [1m/set[22;0m [1mkbnum[22;0m=+9            start [1mkbnum[22;0m entry with 9
  "^[;"   [1m/complete user_defined[22;0m   complete from [1m%{completion_list}[22;0m
  "^[="   [1m/kb_goto_match[22;0m           move cursor to matching parenthesis/bracket
  "^[."   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[<"   [1m/dokey[22;0m recallbeg         go to beginning of input history
  "^[>"   [1m/dokey[22;0m recallend         go to end of input history
  "^[J"   [1m/dokey[22;0m selflush          selective flush (similar to "[1m/dokey[22;0m flush"
                                   followed by "[1m/limit[22;0m -a")
  "^[L"   [1m/kb_toggle_limit[22;0m         toggle between [1m/unlimit[22;0m and [1m/relimit[22;0m
  "^[_"   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[b"   [1m/dokey_wleft[22;0m            *cursor to beginning of word
  "^[c"   [1m/kb_capitalize_word[22;0m     *capitalize word
  "^[d"   [1m/kb_kill_word[22;0m           *delete forward word
  "^[fult keybindings
 type 'tiny.mush', escape all 
  occurrences of '%', '[' and '\' within that line, and send the new line 
  instead of the original.  This is useful for avoiding unwanted 
  interpretation of '%', '[', and '\' on TinyMUSH servers.  

      [1m/hook[22;0m SIGHUP = [1m/log[22;0m on%; [1m/recall[22;0m /10

  will [1mlog[22;0m the last 10 lines of output if you are unexpectedly disconnected 
  from your tf session.  

#CONNETFAIL
  The CONNETFAIL hook, which existed in versions 5.0 alpha 13 through 5.0 beta 
  6, has been replaced with the [1mICONFAIL[22;0m hook.  
#

  See also: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mpriority[22;0m, [1msignals[22;0m.  

&topics

topics

  Topics marked with + are new; those marked with * have changed since the 
  last version.  Many topics also have subtopics that are not listed here 
  (e.g., individual [1mvariables[22;0m, [1mhooks[22;0m, and functions).  


   *[1mcopying[22;0m       copyright; no warranty
    [1mintro[22;0m         introduction to tf
    [1mstartup[22;0m       how to start tf
    [1minterface[22;0m     how input works
    [1mtfrc[22;0m          personal config file
   *[1mvisual[22;0m        split-screen mode
   *[1mcommands[22;0m      list of commands
   *[1mworlds[22;0m        defining worlds
   *[1mpatterns[22;0m      glob and regexp pattern matching
   *[1mvariables[22;0m     state and environment
   *[1mglobals[22;0m       special tf variables
    [1mattributes[22;0m    special text display
    [1mprompts[22;0m       using LP/Diku prompts
    [1mproblems[22;0m      bugs, core dumps, etc.
   *[1mevaluation[22;0m    macro body execution
    [1mmacros[22;0m        user-defined commands
   *[1msockets[22;0m       world connections
    [1mhistory[22;0m       recall and logging
    [1mpriority[22;0m      trigger/hook selection
   *[1mkeybindings[22;0m   keyboard operations
    [1mcolor[22;0m         terminal color codes
   *[1mprotocols[22;0m     protocols supported by TF
    [1mexpressions[22;0m   math and string operations
    [1mtriggers[22;0m      automatic command execution based on incoming text
   *[1mhooks[22;0m         automatic command execution based on tf events
   +[1mmail[22;0m          mail checking
    [1mlibrary[22;0m       macros and variables in stdlib.tf
   *[1mtools[22;0m         extra commands in tools.tf
    [1mutilities[22;0m     useful extra command files
   *[1mprocesses[22;0m     timed commands and command quoting
   *[1msubs[22;0m          arithmetic, command, [1mmacro[22;0m, and variable substitutions
   *[1mfunctions[22;0m     special [1mexpression[22;0m operations
   *[1mhints[22;0m         some hints and style tips for [1mmacro[22;0m programming
   +[1mdebugging[22;0m     debugging your [1mmacros[22;0m
   *[1mtfio[22;0m          output, error, and world streams
   *[1mproxy[22;0m         connecting to outside hosts via a proxy server (firewall)
   +[1mlocale[22;0m        multi-language support
    

&typing
&user
&interface

interface

  Any input line that does not begin with '/' will be sent directly to the 
  [1mforeground[22;0m world, if there is one.  A line starting with more than one '/' 
  will be sent to the forground [1msocket[22;0m after having the first '/' removed.  
  (Exception: lines may be caught with a SEND [1mhook[22;0m before being sent; see 
  "[1mhooks[22;0m").  

  Any input line beginning with a single '/' is a TF command, which will be 
  interpreted as described in "[1mevaluation[22;0m".  

  Input lines of the form "^old^new" will cause TF to search backward in the 
  input [1mhistory[22;0m for a line containing "old", replace that text with "new", and 
  execute the modified command.  See: [1mhistory[22;0m.  

  Many special functions, such as backspace, can be performed by special keys 
  or sequences of keys.  See "[1mdokey[22;0m" for a complete list.  You can also define 
  your own commands and bind them to key sequences.  See [1mbind[22;0m.  

  Normally, user input does not undergo the [1mexpansion[22;0m that [1mmacro[22;0m bodies 
  undergo.  The [1m/eval[22;0m command can be used to [1mexpand[22;0m text before executing it.  
  If the [1m%{sub}[22;0m flag is on (it is off by default), user input undergoes [1mmacro[22;0m 
  body [1mexpansion[22;0m without the [1m%{sub}[22;0m flag.  The [1m%{sub}[22;0m flag also applies to 
  text generated by "^old^new" history commands.  See: [1mhistory[22;0m, [1m/sub[22;0m, 
  [1mvariables[22;0m 

  Control characters may be input literally.  A literal control character will 
  be displayed in the input window in printable form in bold reverse.  Note 
  that since most control keys are also parts of the default keybindings, it 
  will usually be necessary to type ^V ([1m/dokey[22;0m LNEXT) to avoid invoking the 
  keybinding.  

  International characters may be input if your [1mlocale[22;0m is set to a locale that 
  supports them and your system supports locales.  Any input character that is 
  not valid in your locale and has the high bit set (normally generated by 
  holding the "meta" key) will be translated to ESC plus that character with 
  the high bit stripped (assuming [1m%meta_esc[22;0m is on).  This allows M-x and ^[x 
  to invoke the same ^[x keybinding.  See [1mlocale[22;0m, [1m%meta_esc[22;0m, [1m%istrip[22;0m.  

  If standard input is not a terminal, [1mvisual[22;0m mode will not be allowed, and tf 
  will continue to operate even after EOF is read, until /quit or something 
  else terminates it.  

  See also: [1mvisual[22;0m, [1moptions[22;0m 

&intro
&me
&newbie
&tinyfugue
&introduction

introduction

  TinyFugue is a MUD client.  It helps you connect to a MUD, in a much more 
  convenient manner than telnet.  You can connect to a mud world using the 
  same syntax as you would with telnet: "[1mtf[22;0m <[4mhost[24m> <[4mport[24m>".  Or, while running 
  tf, you can use "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>".  To make things easier, you can 
  give names to worlds, using [1m/addworld[22;0m, and then use "[1mtf[22;0m <[4mname[24m>" and 
  "[1m/connect[22;0m <[4mname[24m>".  If you store a set of [1m/addworld[22;0m commands in a file, TF 
  can read them automatically when it starts.  You can even connect to more 
  than one world at the same time, and switch between them.  See: [1m/connect[22;0m, 
  [1m/fg[22;0m, [1m/addworld[22;0m, [1mworlds[22;0m, [1mtfrc[22;0m.  

  Normally, TF will split the screen into two windows: one for input, and one 
  for output.  TF will display useful information on the line separating the 
  two windows, such as the name of the [1mforeground[22;0m world.  See: [1mwindows[22;0m.  

  Any line you type that starts with a single '/' is a tf command.  Anything 
  else you type will be sent to the mud.  See: [1minterface[22;0m, [1mcommands[22;0m.  

  You can define your own tf commands, called [1mmacros[22;0m.  The simplest type of 
  [1mmacro[22;0m is just an abbreviation or alias for a longer command or commands.  
  But [1mmacros[22;0m can also perform much more powerful tasks.  See: [1mmacros[22;0m, [1m/def[22;0m.  

  You can tell tf to watch for certain patterns in the text from the mud, and 
  then do special things when it sees that pattern: display the text in a 
  special way ([1mhilite[22;0m); not display the text at all ([1mgag[22;0m); execute a [1mmacro[22;0m 
  command ([1mtrigger[22;0m); or do any combination of these.  See: [1mattributes[22;0m, 
  [1mtriggers[22;0m, [1m/hilite[22;0m, [1m/gag[22;0m, [1m/trig[22;0m, [1m/def[22;0m.  

  TF keeps a [1mhistory[22;0m of every line it prints, every line sent by the mud, and 
  every command you enter.  You can see those histories using [1m/recall[22;0m.  You 
  can also have this text saved in a file using [1m/log[22;0m.  See: [1mhistory[22;0m, [1m/recall[22;0m, 
  [1m/log[22;0m.  

  See also: [1mtopics[22;0m 

&keys
&key
&kbbind
&kbfunc
&kbfunc.tf
&kbbind.tf
&keybindings

keybindings

Default keybindings

  TF's default command line editing keys are similar to those in emacs and 
  bash.  In addition, several features may be invoked by more than one 
  keybinding, and TF has keybindings for unique features like switching the 
  [1mforeground[22;0m [1msocket[22;0m.  

  Here, and throughout the TF documentation, the notation "^X" means the 
  character generated by typing the X key while holding the CTRL key.  Also, 
  "^[" can be more easily typed just by pressing the ESC key.  [1m/Def -b[22;0m and 
  [1m/bind[22;0m accept the ^X notation as well as "\<[4mnumber[24m>" notation, where <[4mnumber[24m> 
  is the octal, hexadecimal, or decimal number of the character's ascii value. 
  For example, the escape character can be given in any of these forms: ^[, 
  \033, \0x1B, or \27.  

  In the tables below, keys with "*" in the "Meaning" column make use of [1mkbnum[22;0m 
  (see [1mbelow[22;0m).  

#named keys
Named keys
  To redefine the named keys, see the section titled "[1mMapping Named Keys to 
  functions[22;0m".  

  Key         Command                 Meaning
  ---         -------                 -------
  Up          /kb_up_or_recallb       *cursor up or recall bkwd input [1mhistory[22;0m
  Down        /kb_down_or_recallf     *cursor down or recall fwd input [1mhistory[22;0m
  Right       [1m/dokey[22;0m RIGHT            *cursor right
  Left        [1m/dokey[22;0m LEFT             *cursor left
  Center      (none)

  Esc_Left    [1m/fg[22;0m -<                  *[1mforeground[22;0m previous [1msocket[22;0m
  Esc_Right   [1m/fg[22;0m ->                  *[1mforeground[22;0m next [1msocket[22;0m

  Ctrl_Up     [1m/dokey_recallb[22;0m          *recall backward input
  Ctrl_Down   [1m/dokey_recallf[22;0m          *recall forward input
  Ctrl_Right  [1m/dokey_wright[22;0m           *word right
  Ctrl_Left   [1m/dokey_wleft[22;0m            *word left

  Insert      [1m/test[22;0m [1minsert[22;0m:=![1minsert[22;0m    toggle [1minsert[22;0m mode
  Delete      [1m/dokey[22;0m dch              *delete character
  Home        [1m/dokey_home[22;0m              cursor to beginning of line
  End         [1m/dokey_end[22;0m               cursor to end of line
  PgDn        [1m/dokey_pgdn[22;0m             *scroll forward a screenful
  PgUp        [1m/dokey_pgup[22;0m             *scroll back a screenful
  Tab         [1m/dokey page[22;0m             *scroll forward a screenful

  Ctrl_Home   [1m/dokey_recallbeg[22;0m         recall first line of input
  Ctrl_End    [1m/dokey_recallend[22;0m         recall last line of input
  Ctrl_PgDn   [1m/dokey_flush[22;0m             scroll forward to last screenful
  Ctrl_PgUp   (reserved for future use)

  F1          [1m/help[22;0m                    help
  F2          (none)                   (function key F1)
  ...
  F20         (none)                   (function key F20)

  nkpTab      (none)                   (see "[1mkeypad[22;0m" section below)
  nkpEnt      (none)                   (see "[1mkeypad[22;0m" section below)
  nkp*        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp+        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp,        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp-        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp.        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp/        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp0        (none)                   (see "[1mkeypad[22;0m" section below)
  ...
  nkp9        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp=        (none)                   (see "[1mkeypad[22;0m" section below)

#unnamed keys
Unnamed key sequences

  String  Command                 Meaning
  ------  -------                 -------
  "^A"    [1m/dokey_home[22;0m              cursor to beginning of line
  "^B"    [1m/dokey[22;0m LEFT             *cursor left
  "^D"    [1m/dokey_dch[22;0m              *delete character to the right
  "^E"    [1m/dokey_end[22;0m               cursor to end of line
  "^F"    [1m/dokey[22;0m RIGHT            *cursor right
  "^G"    [1m/beep[22;0m 1                  beep
  "^H"    (internal)              *backspace
  "^I"    [1m/key_tab[22;0m                 perform the function assigned to the TAB key
  "^J"    (internal)               execute current line
  "^K"    [1m/dokey_deol[22;0m              delete to end of line
  "^L"    [1m/dokey[22;0m redraw            redraw (not clear) screen
  "^M"    (internal)               execute current line
  "^N"    [1m/dokey[22;0m recallf          *recall forward input [1mhistory[22;0m
  "^P"    [1m/dokey[22;0m recallb          *recall backward input [1mhistory[22;0m
  "^Q"    [1m/dokey[22;0m LNEXT             input next key literally (may be overridden
                                   by [1mterminal[22;0m)
  "^R"    [1m/dokey[22;0m REFRESH           refresh line
  "^S"    [1m/dokey[22;0m PAUSE             pause screen
  "^T"    [1m/kb_transpose_chars[22;0m     *transpose characters
  "^U"    [1m/kb_backward_kill_line[22;0m   delete to beginning of line
  "^V"    [1m/dokey[22;0m LNEXT             input next key literally
  "^W"    [1m/dokey[22;0m BWORD            *delete backward word (space-delimited)
  "^?"    (internal)              *backspace
  "^X^R"  [1m/load[22;0m [1m~/.tfrc[22;0m            reload personal config file
  "^X^V"  [1m/version[22;0m                 display version information
  "^X^?"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^X["   [1m/dokey[22;0m_hpageback        *scroll back a half screenful
  "^X]"   [1m/dokey[22;0m_hpage            *scroll forward a half screenful
  "^X{"   [1m/dokey[22;0m_pageback         *scroll back a screenful
  "^X}"   [1m/dokey[22;0m_page             *scroll forward a screenful
  "^[^E"  [1m/kb_expand_line[22;0m          [1mexpand[22;0m current input line in place
  "^[^H"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^[^I"  [1m/complete[22;0m                complete current word, depending on context
  "^[^L"  [1m/dokey[22;0m clear             clear screen (can be refilled with [1mscrollback[22;0m)
  "^[^N"  [1m/dokey[22;0m line             *scroll forward one line
  "^[^P"  [1m/dokey[22;0m lineback         *scroll back one line
  "^[^W"  [1m/complete worldname[22;0m      complete TF world name
  "^[$"   [1m/complete macroname[22;0m      complete TF macro name
  "^[%"   [1m/complete variable[22;0m       complete TF variable name
  "^[/"   [1m/complete filename[22;0m       complete file name (unix only)
  "^[ "   [1m/kb_collapse_space[22;0m       change multiple spaces to a single space
  "^[-"   [1m/set[22;0m [1mkbnum[22;0m=-             start [1mkbnum[22;0m entry with -
  "^[0"   [1m/set[22;0m [1mkbnum[22;0m=+0            start [1mkbnum[22;0m entry with 0
  ...
  "^[9"   [1m/set[22;0m [1mkbnum[22;0m=+9            start [1mkbnum[22;0m entry with 9
  "^[;"   [1m/complete user_defined[22;0m   complete from [1m%{completion_list}[22;0m
  "^[="   [1m/kb_goto_match[22;0m           move cursor to matching parenthesis/bracket
  "^[."   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[<"   [1m/dokey[22;0m recallbeg         go to beginning of input history
  "^[>"   [1m/dokey[22;0m recallend         go to end of input history
  "^[J"   [1m/dokey[22;0m selflush          selective flush (similar to "[1m/dokey[22;0m flush"
                                   followed by "[1m/limit[22;0m -a")
  "^[L"   [1m/kb_toggle_limit[22;0m         toggle between [1m/unlimit[22;0m and [1m/relimit[22;0m
  "^[_"   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[b"   [1m/dokey_wleft[22;0m            *cursor to beginning of word
  "^[c"   [1m/kb_capitalize_word[22;0m     *capitalize word
  "^[d"   [1m/kb_kill_word[22;0m           *delete forward word
  "^[fult keybindings
 type 'tiny.mush', escape all 
  occurrences of '%', '[' and '\' within that line, and send the new line 
  instead of the original.  This is useful for avoiding unwanted 
  interpretation of '%', '[', and '\' on TinyMUSH servers.  

      [1m/hook[22;0m SIGHUP = [1m/log[22;0m on%; [1m/recall[22;0m /10

  will [1mlog[22;0m the last 10 lines of output if you are unexpectedly disconnected 
  from your tf session.  

#CONNETFAIL
  The CONNETFAIL hook, which existed in versions 5.0 alpha 13 through 5.0 beta 
  6, has been replaced with the [1mICONFAIL[22;0m hook.  
#

  See also: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mpriority[22;0m, [1msignals[22;0m.  

&topics

topics

  Topics marked with + are new; those marked with * have changed since the 
  last version.  Many topics also have subtopics that are not listed here 
  (e.g., individual [1mvariables[22;0m, [1mhooks[22;0m, and functions).  


   *[1mcopying[22;0m       copyright; no warranty
    [1mintro[22;0m         introduction to tf
    [1mstartup[22;0m       how to start tf
    [1minterface[22;0m     how input works
    [1mtfrc[22;0m          personal config file
   *[1mvisual[22;0m        split-screen mode
   *[1mcommands[22;0m      list of commands
   *[1mworlds[22;0m        defining worlds
   *[1mpatterns[22;0m      glob and regexp pattern matching
   *[1mvariables[22;0m     state and environment
   *[1mglobals[22;0m       special tf variables
    [1mattributes[22;0m    special text display
    [1mprompts[22;0m       using LP/Diku prompts
    [1mproblems[22;0m      bugs, core dumps, etc.
   *[1mevaluation[22;0m    macro body execution
    [1mmacros[22;0m        user-defined commands
   *[1msockets[22;0m       world connections
    [1mhistory[22;0m       recall and logging
    [1mpriority[22;0m      trigger/hook selection
   *[1mkeybindings[22;0m   keyboard operations
    [1mcolor[22;0m         terminal color codes
   *[1mprotocols[22;0m     protocols supported by TF
    [1mexpressions[22;0m   math and string operations
    [1mtriggers[22;0m      automatic command execution based on incoming text
   *[1mhooks[22;0m         automatic command execution based on tf events
   +[1mmail[22;0m          mail checking
    [1mlibrary[22;0m       macros and variables in stdlib.tf
   *[1mtools[22;0m         extra commands in tools.tf
    [1mutilities[22;0m     useful extra command files
   *[1mprocesses[22;0m     timed commands and command quoting
   *[1msubs[22;0m          arithmetic, command, [1mmacro[22;0m, and variable substitutions
   *[1mfunctions[22;0m     special [1mexpression[22;0m operations
   *[1mhints[22;0m         some hints and style tips for [1mmacro[22;0m programming
   +[1mdebugging[22;0m     debugging your [1mmacros[22;0m
   *[1mtfio[22;0m          output, error, and world streams
   *[1mproxy[22;0m         connecting to outside hosts via a proxy server (firewall)
   +[1mlocale[22;0m        multi-language support
    

&typing
&user
&interface

interface

  Any input line that does not begin with '/' will be sent directly to the 
  [1mforeground[22;0m world, if there is one.  A line starting with more than one '/' 
  will be sent to the forground [1msocket[22;0m after having the first '/' removed.  
  (Exception: lines may be caught with a SEND [1mhook[22;0m before being sent; see 
  "[1mhooks[22;0m").  

  Any input line beginning with a single '/' is a TF command, which will be 
  interpreted as described in "[1mevaluation[22;0m".  

  Input lines of the form "^old^new" will cause TF to search backward in the 
  input [1mhistory[22;0m for a line containing "old", replace that text with "new", and 
  execute the modified command.  See: [1mhistory[22;0m.  

  Many special functions, such as backspace, can be performed by special keys 
  or sequences of keys.  See "[1mdokey[22;0m" for a complete list.  You can also define 
  your own commands and bind them to key sequences.  See [1mbind[22;0m.  

  Normally, user input does not undergo the [1mexpansion[22;0m that [1mmacro[22;0m bodies 
  undergo.  The [1m/eval[22;0m command can be used to [1mexpand[22;0m text before executing it.  
  If the [1m%{sub}[22;0m flag is on (it is off by default), user input undergoes [1mmacro[22;0m 
  body [1mexpansion[22;0m without the [1m%{sub}[22;0m flag.  The [1m%{sub}[22;0m flag also applies to 
  text generated by "^old^new" history commands.  See: [1mhistory[22;0m, [1m/sub[22;0m, 
  [1mvariables[22;0m 

  Control characters may be input literally.  A literal control character will 
  be displayed in the input window in printable form in bold reverse.  Note 
  that since most control keys are also parts of the default keybindings, it 
  will usually be necessary to type ^V ([1m/dokey[22;0m LNEXT) to avoid invoking the 
  keybinding.  

  International characters may be input if your [1mlocale[22;0m is set to a locale that 
  supports them and your system supports locales.  Any input character that is 
  not valid in your locale and has the high bit set (normally generated by 
  holding the "meta" key) will be translated to ESC plus that character with 
  the high bit stripped (assuming [1m%meta_esc[22;0m is on).  This allows M-x and ^[x 
  to invoke the same ^[x keybinding.  See [1mlocale[22;0m, [1m%meta_esc[22;0m, [1m%istrip[22;0m.  

  If standard input is not a terminal, [1mvisual[22;0m mode will not be allowed, and tf 
  will continue to operate even after EOF is read, until /quit or something 
  else terminates it.  

  See also: [1mvisual[22;0m, [1moptions[22;0m 

&intro
&me
&newbie
&tinyfugue
&introduction

introduction

  TinyFugue is a MUD client.  It helps you connect to a MUD, in a much more 
  convenient manner than telnet.  You can connect to a mud world using the 
  same syntax as you would with telnet: "[1mtf[22;0m <[4mhost[24m> <[4mport[24m>".  Or, while running 
  tf, you can use "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>".  To make things easier, you can 
  give names to worlds, using [1m/addworld[22;0m, and then use "[1mtf[22;0m <[4mname[24m>" and 
  "[1m/connect[22;0m <[4mname[24m>".  If you store a set of [1m/addworld[22;0m commands in a file, TF 
  can read them automatically when it starts.  You can even connect to more 
  than one world at the same time, and switch between them.  See: [1m/connect[22;0m, 
  [1m/fg[22;0m, [1m/addworld[22;0m, [1mworlds[22;0m, [1mtfrc[22;0m.  

  Normally, TF will split the screen into two windows: one for input, and one 
  for output.  TF will display useful information on the line separating the 
  two windows, such as the name of the [1mforeground[22;0m world.  See: [1mwindows[22;0m.  

  Any line you type that starts with a single '/' is a tf command.  Anything 
  else you type will be sent to the mud.  See: [1minterface[22;0m, [1mcommands[22;0m.  

  You can define your own tf commands, called [1mmacros[22;0m.  The simplest type of 
  [1mmacro[22;0m is just an abbreviation or alias for a longer command or commands.  
  But [1mmacros[22;0m can also perform much more powerful tasks.  See: [1mmacros[22;0m, [1m/def[22;0m.  

  You can tell tf to watch for certain patterns in the text from the mud, and 
  then do special things when it sees that pattern: display the text in a 
  special way ([1mhilite[22;0m); not display the text at all ([1mgag[22;0m); execute a [1mmacro[22;0m 
  command ([1mtrigger[22;0m); or do any combination of these.  See: [1mattributes[22;0m, 
  [1mtriggers[22;0m, [1m/hilite[22;0m, [1m/gag[22;0m, [1m/trig[22;0m, [1m/def[22;0m.  

  TF keeps a [1mhistory[22;0m of every line it prints, every line sent by the mud, and 
  every command you enter.  You can see those histories using [1m/recall[22;0m.  You 
  can also have this text saved in a file using [1m/log[22;0m.  See: [1mhistory[22;0m, [1m/recall[22;0m, 
  [1m/log[22;0m.  

  See also: [1mtopics[22;0m 

&keys
&key
&kbbind
&kbfunc
&kbfunc.tf
&kbbind.tf
&keybindings

keybindings

Default keybindings

  TF's default command line editing keys are similar to those in emacs and 
  bash.  In addition, several features may be invoked by more than one 
  keybinding, and TF has keybindings for unique features like switching the 
  [1mforeground[22;0m [1msocket[22;0m.  

  Here, and throughout the TF documentation, the notation "^X" means the 
  character generated by typing the X key while holding the CTRL key.  Also, 
  "^[" can be more easily typed just by pressing the ESC key.  [1m/Def -b[22;0m and 
  [1m/bind[22;0m accept the ^X notation as well as "\<[4mnumber[24m>" notation, where <[4mnumber[24m> 
  is the octal, hexadecimal, or decimal number of the character's ascii value. 
  For example, the escape character can be given in any of these forms: ^[, 
  \033, \0x1B, or \27.  

  In the tables below, keys with "*" in the "Meaning" column make use of [1mkbnum[22;0m 
  (see [1mbelow[22;0m).  

#named keys
Named keys
  To redefine the named keys, see the section titled "[1mMapping Named Keys to 
  functions[22;0m".  

  Key         Command                 Meaning
  ---         -------                 -------
  Up          /kb_up_or_recallb       *cursor up or recall bkwd input [1mhistory[22;0m
  Down        /kb_down_or_recallf     *cursor down or recall fwd input [1mhistory[22;0m
  Right       [1m/dokey[22;0m RIGHT            *cursor right
  Left        [1m/dokey[22;0m LEFT             *cursor left
  Center      (none)

  Esc_Left    [1m/fg[22;0m -<                  *[1mforeground[22;0m previous [1msocket[22;0m
  Esc_Right   [1m/fg[22;0m ->                  *[1mforeground[22;0m next [1msocket[22;0m

  Ctrl_Up     [1m/dokey_recallb[22;0m          *recall backward input
  Ctrl_Down   [1m/dokey_recallf[22;0m          *recall forward input
  Ctrl_Right  [1m/dokey_wright[22;0m           *word right
  Ctrl_Left   [1m/dokey_wleft[22;0m            *word left

  Insert      [1m/test[22;0m [1minsert[22;0m:=![1minsert[22;0m    toggle [1minsert[22;0m mode
  Delete      [1m/dokey[22;0m dch              *delete character
  Home        [1m/dokey_home[22;0m              cursor to beginning of line
  End         [1m/dokey_end[22;0m               cursor to end of line
  PgDn        [1m/dokey_pgdn[22;0m             *scroll forward a screenful
  PgUp        [1m/dokey_pgup[22;0m             *scroll back a screenful
  Tab         [1m/dokey page[22;0m             *scroll forward a screenful

  Ctrl_Home   [1m/dokey_recallbeg[22;0m         recall first line of input
  Ctrl_End    [1m/dokey_recallend[22;0m         recall last line of input
  Ctrl_PgDn   [1m/dokey_flush[22;0m             scroll forward to last screenful
  Ctrl_PgUp   (reserved for future use)

  F1          [1m/help[22;0m                    help
  F2          (none)                   (function key F1)
  ...
  F20         (none)                   (function key F20)

  nkpTab      (none)                   (see "[1mkeypad[22;0m" section below)
  nkpEnt      (none)                   (see "[1mkeypad[22;0m" section below)
  nkp*        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp+        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp,        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp-        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp.        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp/        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp0        (none)                   (see "[1mkeypad[22;0m" section below)
  ...
  nkp9        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp=        (none)                   (see "[1mkeypad[22;0m" section below)

#unnamed keys
Unnamed key sequences

  String  Command                 Meaning
  ------  -------                 -------
  "^A"    [1m/dokey_home[22;0m              cursor to beginning of line
  "^B"    [1m/dokey[22;0m LEFT             *cursor left
  "^D"    [1m/dokey_dch[22;0m              *delete character to the right
  "^E"    [1m/dokey_end[22;0m               cursor to end of line
  "^F"    [1m/dokey[22;0m RIGHT            *cursor right
  "^G"    [1m/beep[22;0m 1                  beep
  "^H"    (internal)              *backspace
  "^I"    [1m/key_tab[22;0m                 perform the function assigned to the TAB key
  "^J"    (internal)               execute current line
  "^K"    [1m/dokey_deol[22;0m              delete to end of line
  "^L"    [1m/dokey[22;0m redraw            redraw (not clear) screen
  "^M"    (internal)               execute current line
  "^N"    [1m/dokey[22;0m recallf          *recall forward input [1mhistory[22;0m
  "^P"    [1m/dokey[22;0m recallb          *recall backward input [1mhistory[22;0m
  "^Q"    [1m/dokey[22;0m LNEXT             input next key literally (may be overridden
                                   by [1mterminal[22;0m)
  "^R"    [1m/dokey[22;0m REFRESH           refresh line
  "^S"    [1m/dokey[22;0m PAUSE             pause screen
  "^T"    [1m/kb_transpose_chars[22;0m     *transpose characters
  "^U"    [1m/kb_backward_kill_line[22;0m   delete to beginning of line
  "^V"    [1m/dokey[22;0m LNEXT             input next key literally
  "^W"    [1m/dokey[22;0m BWORD            *delete backward word (space-delimited)
  "^?"    (internal)              *backspace
  "^X^R"  [1m/load[22;0m [1m~/.tfrc[22;0m            reload personal config file
  "^X^V"  [1m/version[22;0m                 display version information
  "^X^?"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^X["   [1m/dokey[22;0m_hpageback        *scroll back a half screenful
  "^X]"   [1m/dokey[22;0m_hpage            *scroll forward a half screenful
  "^X{"   [1m/dokey[22;0m_pageback         *scroll back a screenful
  "^X}"   [1m/dokey[22;0m_page             *scroll forward a screenful
  "^[^E"  [1m/kb_expand_line[22;0m          [1mexpand[22;0m current input line in place
  "^[^H"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^[^I"  [1m/complete[22;0m                complete current word, depending on context
  "^[^L"  [1m/dokey[22;0m clear             clear screen (can be refilled with [1mscrollback[22;0m)
  "^[^N"  [1m/dokey[22;0m line             *scroll forward one line
  "^[^P"  [1m/dokey[22;0m lineback         *scroll back one line
  "^[^W"  [1m/complete worldname[22;0m      complete TF world name
  "^[$"   [1m/complete macroname[22;0m      complete TF macro name
  "^[%"   [1m/complete variable[22;0m       complete TF variable name
  "^[/"   [1m/complete filename[22;0m       complete file name (unix only)
  "^[ "   [1m/kb_collapse_space[22;0m       change multiple spaces to a single space
  "^[-"   [1m/set[22;0m [1mkbnum[22;0m=-             start [1mkbnum[22;0m entry with -
  "^[0"   [1m/set[22;0m [1mkbnum[22;0m=+0            start [1mkbnum[22;0m entry with 0
  ...
  "^[9"   [1m/set[22;0m [1mkbnum[22;0m=+9            start [1mkbnum[22;0m entry with 9
  "^[;"   [1m/complete user_defined[22;0m   complete from [1m%{completion_list}[22;0m
  "^[="   [1m/kb_goto_match[22;0m           move cursor to matching parenthesis/bracket
  "^[."   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[<"   [1m/dokey[22;0m recallbeg         go to beginning of input history
  "^[>"   [1m/dokey[22;0m recallend         go to end of input history
  "^[J"   [1m/dokey[22;0m selflush          selective flush (similar to "[1m/dokey[22;0m flush"
                                   followed by "[1m/limit[22;0m -a")
  "^[L"   [1m/kb_toggle_limit[22;0m         toggle between [1m/unlimit[22;0m and [1m/relimit[22;0m
  "^[_"   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[b"   [1m/dokey_wleft[22;0m            *cursor to beginning of word
  "^[c"   [1m/kb_capitalize_word[22;0m     *capitalize word
  "^[d"   [1m/kb_kill_word[22;0m           *delete forward word
  "^[fult keybindings
 type 'tiny.mush', escape all 
  occurrences of '%', '[' and '\' within that line, and send the new line 
  instead of the original.  This is useful for avoiding unwanted 
  interpretation of '%', '[', and '\' on TinyMUSH servers.  

      [1m/hook[22;0m SIGHUP = [1m/log[22;0m on%; [1m/recall[22;0m /10

  will [1mlog[22;0m the last 10 lines of output if you are unexpectedly disconnected 
  from your tf session.  

#CONNETFAIL
  The CONNETFAIL hook, which existed in versions 5.0 alpha 13 through 5.0 beta 
  6, has been replaced with the [1mICONFAIL[22;0m hook.  
#

  See also: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mpriority[22;0m, [1msignals[22;0m.  

&topics

topics

  Topics marked with + are new; those marked with * have changed since the 
  last version.  Many topics also have subtopics that are not listed here 
  (e.g., individual [1mvariables[22;0m, [1mhooks[22;0m, and functions).  


   *[1mcopying[22;0m       copyright; no warranty
    [1mintro[22;0m         introduction to tf
    [1mstartup[22;0m       how to start tf
    [1minterface[22;0m     how input works
    [1mtfrc[22;0m          personal config file
   *[1mvisual[22;0m        split-screen mode
   *[1mcommands[22;0m      list of commands
   *[1mworlds[22;0m        defining worlds
   *[1mpatterns[22;0m      glob and regexp pattern matching
   *[1mvariables[22;0m     state and environment
   *[1mglobals[22;0m       special tf variables
    [1mattributes[22;0m    special text display
    [1mprompts[22;0m       using LP/Diku prompts
    [1mproblems[22;0m      bugs, core dumps, etc.
   *[1mevaluation[22;0m    macro body execution
    [1mmacros[22;0m        user-defined commands
   *[1msockets[22;0m       world connections
    [1mhistory[22;0m       recall and logging
    [1mpriority[22;0m      trigger/hook selection
   *[1mkeybindings[22;0m   keyboard operations
    [1mcolor[22;0m         terminal color codes
   *[1mprotocols[22;0m     protocols supported by TF
    [1mexpressions[22;0m   math and string operations
    [1mtriggers[22;0m      automatic command execution based on incoming text
   *[1mhooks[22;0m         automatic command execution based on tf events
   +[1mmail[22;0m          mail checking
    [1mlibrary[22;0m       macros and variables in stdlib.tf
   *[1mtools[22;0m         extra commands in tools.tf
    [1mutilities[22;0m     useful extra command files
   *[1mprocesses[22;0m     timed commands and command quoting
   *[1msubs[22;0m          arithmetic, command, [1mmacro[22;0m, and variable substitutions
   *[1mfunctions[22;0m     special [1mexpression[22;0m operations
   *[1mhints[22;0m         some hints and style tips for [1mmacro[22;0m programming
   +[1mdebugging[22;0m     debugging your [1mmacros[22;0m
   *[1mtfio[22;0m          output, error, and world streams
   *[1mproxy[22;0m         connecting to outside hosts via a proxy server (firewall)
   +[1mlocale[22;0m        multi-language support
    

&typing
&user
&interface

interface

  Any input line that does not begin with '/' will be sent directly to the 
  [1mforeground[22;0m world, if there is one.  A line starting with more than one '/' 
  will be sent to the forground [1msocket[22;0m after having the first '/' removed.  
  (Exception: lines may be caught with a SEND [1mhook[22;0m before being sent; see 
  "[1mhooks[22;0m").  

  Any input line beginning with a single '/' is a TF command, which will be 
  interpreted as described in "[1mevaluation[22;0m".  

  Input lines of the form "^old^new" will cause TF to search backward in the 
  input [1mhistory[22;0m for a line containing "old", replace that text with "new", and 
  execute the modified command.  See: [1mhistory[22;0m.  

  Many special functions, such as backspace, can be performed by special keys 
  or sequences of keys.  See "[1mdokey[22;0m" for a complete list.  You can also define 
  your own commands and bind them to key sequences.  See [1mbind[22;0m.  

  Normally, user input does not undergo the [1mexpansion[22;0m that [1mmacro[22;0m bodies 
  undergo.  The [1m/eval[22;0m command can be used to [1mexpand[22;0m text before executing it.  
  If the [1m%{sub}[22;0m flag is on (it is off by default), user input undergoes [1mmacro[22;0m 
  body [1mexpansion[22;0m without the [1m%{sub}[22;0m flag.  The [1m%{sub}[22;0m flag also applies to 
  text generated by "^old^new" history commands.  See: [1mhistory[22;0m, [1m/sub[22;0m, 
  [1mvariables[22;0m 

  Control characters may be input literally.  A literal control character will 
  be displayed in the input window in printable form in bold reverse.  Note 
  that since most control keys are also parts of the default keybindings, it 
  will usually be necessary to type ^V ([1m/dokey[22;0m LNEXT) to avoid invoking the 
  keybinding.  

  International characters may be input if your [1mlocale[22;0m is set to a locale that 
  supports them and your system supports locales.  Any input character that is 
  not valid in your locale and has the high bit set (normally generated by 
  holding the "meta" key) will be translated to ESC plus that character with 
  the high bit stripped (assuming [1m%meta_esc[22;0m is on).  This allows M-x and ^[x 
  to invoke the same ^[x keybinding.  See [1mlocale[22;0m, [1m%meta_esc[22;0m, [1m%istrip[22;0m.  

  If standard input is not a terminal, [1mvisual[22;0m mode will not be allowed, and tf 
  will continue to operate even after EOF is read, until /quit or something 
  else terminates it.  

  See also: [1mvisual[22;0m, [1moptions[22;0m 

&intro
&me
&newbie
&tinyfugue
&introduction

introduction

  TinyFugue is a MUD client.  It helps you connect to a MUD, in a much more 
  convenient manner than telnet.  You can connect to a mud world using the 
  same syntax as you would with telnet: "[1mtf[22;0m <[4mhost[24m> <[4mport[24m>".  Or, while running 
  tf, you can use "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>".  To make things easier, you can 
  give names to worlds, using [1m/addworld[22;0m, and then use "[1mtf[22;0m <[4mname[24m>" and 
  "[1m/connect[22;0m <[4mname[24m>".  If you store a set of [1m/addworld[22;0m commands in a file, TF 
  can read them automatically when it starts.  You can even connect to more 
  than one world at the same time, and switch between them.  See: [1m/connect[22;0m, 
  [1m/fg[22;0m, [1m/addworld[22;0m, [1mworlds[22;0m, [1mtfrc[22;0m.  

  Normally, TF will split the screen into two windows: one for input, and one 
  for output.  TF will display useful information on the line separating the 
  two windows, such as the name of the [1mforeground[22;0m world.  See: [1mwindows[22;0m.  

  Any line you type that starts with a single '/' is a tf command.  Anything 
  else you type will be sent to the mud.  See: [1minterface[22;0m, [1mcommands[22;0m.  

  You can define your own tf commands, called [1mmacros[22;0m.  The simplest type of 
  [1mmacro[22;0m is just an abbreviation or alias for a longer command or commands.  
  But [1mmacros[22;0m can also perform much more powerful tasks.  See: [1mmacros[22;0m, [1m/def[22;0m.  

  You can tell tf to watch for certain patterns in the text from the mud, and 
  then do special things when it sees that pattern: display the text in a 
  special way ([1mhilite[22;0m); not display the text at all ([1mgag[22;0m); execute a [1mmacro[22;0m 
  command ([1mtrigger[22;0m); or do any combination of these.  See: [1mattributes[22;0m, 
  [1mtriggers[22;0m, [1m/hilite[22;0m, [1m/gag[22;0m, [1m/trig[22;0m, [1m/def[22;0m.  

  TF keeps a [1mhistory[22;0m of every line it prints, every line sent by the mud, and 
  every command you enter.  You can see those histories using [1m/recall[22;0m.  You 
  can also have this text saved in a file using [1m/log[22;0m.  See: [1mhistory[22;0m, [1m/recall[22;0m, 
  [1m/log[22;0m.  

  See also: [1mtopics[22;0m 

&keys
&key
&kbbind
&kbfunc
&kbfunc.tf
&kbbind.tf
&keybindings

keybindings

Default keybindings

  TF's default command line editing keys are similar to those in emacs and 
  bash.  In addition, several features may be invoked by more than one 
  keybinding, and TF has keybindings for unique features like switching the 
  [1mforeground[22;0m [1msocket[22;0m.  

  Here, and throughout the TF documentation, the notation "^X" means the 
  character generated by typing the X key while holding the CTRL key.  Also, 
  "^[" can be more easily typed just by pressing the ESC key.  [1m/Def -b[22;0m and 
  [1m/bind[22;0m accept the ^X notation as well as "\<[4mnumber[24m>" notation, where <[4mnumber[24m> 
  is the octal, hexadecimal, or decimal number of the character's ascii value. 
  For example, the escape character can be given in any of these forms: ^[, 
  \033, \0x1B, or \27.  

  In the tables below, keys with "*" in the "Meaning" column make use of [1mkbnum[22;0m 
  (see [1mbelow[22;0m).  

#named keys
Named keys
  To redefine the named keys, see the section titled "[1mMapping Named Keys to 
  functions[22;0m".  

  Key         Command                 Meaning
  ---         -------                 -------
  Up          /kb_up_or_recallb       *cursor up or recall bkwd input [1mhistory[22;0m
  Down        /kb_down_or_recallf     *cursor down or recall fwd input [1mhistory[22;0m
  Right       [1m/dokey[22;0m RIGHT            *cursor right
  Left        [1m/dokey[22;0m LEFT             *cursor left
  Center      (none)

  Esc_Left    [1m/fg[22;0m -<                  *[1mforeground[22;0m previous [1msocket[22;0m
  Esc_Right   [1m/fg[22;0m ->                  *[1mforeground[22;0m next [1msocket[22;0m

  Ctrl_Up     [1m/dokey_recallb[22;0m          *recall backward input
  Ctrl_Down   [1m/dokey_recallf[22;0m          *recall forward input
  Ctrl_Right  [1m/dokey_wright[22;0m           *word right
  Ctrl_Left   [1m/dokey_wleft[22;0m            *word left

  Insert      [1m/test[22;0m [1minsert[22;0m:=![1minsert[22;0m    toggle [1minsert[22;0m mode
  Delete      [1m/dokey[22;0m dch              *delete character
  Home        [1m/dokey_home[22;0m              cursor to beginning of line
  End         [1m/dokey_end[22;0m               cursor to end of line
  PgDn        [1m/dokey_pgdn[22;0m             *scroll forward a screenful
  PgUp        [1m/dokey_pgup[22;0m             *scroll back a screenful
  Tab         [1m/dokey page[22;0m             *scroll forward a screenful

  Ctrl_Home   [1m/dokey_recallbeg[22;0m         recall first line of input
  Ctrl_End    [1m/dokey_recallend[22;0m         recall last line of input
  Ctrl_PgDn   [1m/dokey_flush[22;0m             scroll forward to last screenful
  Ctrl_PgUp   (reserved for future use)

  F1          [1m/help[22;0m                    help
  F2          (none)                   (function key F1)
  ...
  F20         (none)                   (function key F20)

  nkpTab      (none)                   (see "[1mkeypad[22;0m" section below)
  nkpEnt      (none)                   (see "[1mkeypad[22;0m" section below)
  nkp*        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp+        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp,        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp-        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp.        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp/        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp0        (none)                   (see "[1mkeypad[22;0m" section below)
  ...
  nkp9        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp=        (none)                   (see "[1mkeypad[22;0m" section below)

#unnamed keys
Unnamed key sequences

  String  Command                 Meaning
  ------  -------                 -------
  "^A"    [1m/dokey_home[22;0m              cursor to beginning of line
  "^B"    [1m/dokey[22;0m LEFT             *cursor left
  "^D"    [1m/dokey_dch[22;0m              *delete character to the right
  "^E"    [1m/dokey_end[22;0m               cursor to end of line
  "^F"    [1m/dokey[22;0m RIGHT            *cursor right
  "^G"    [1m/beep[22;0m 1                  beep
  "^H"    (internal)              *backspace
  "^I"    [1m/key_tab[22;0m                 perform the function assigned to the TAB key
  "^J"    (internal)               execute current line
  "^K"    [1m/dokey_deol[22;0m              delete to end of line
  "^L"    [1m/dokey[22;0m redraw            redraw (not clear) screen
  "^M"    (internal)               execute current line
  "^N"    [1m/dokey[22;0m recallf          *recall forward input [1mhistory[22;0m
  "^P"    [1m/dokey[22;0m recallb          *recall backward input [1mhistory[22;0m
  "^Q"    [1m/dokey[22;0m LNEXT             input next key literally (may be overridden
                                   by [1mterminal[22;0m)
  "^R"    [1m/dokey[22;0m REFRESH           refresh line
  "^S"    [1m/dokey[22;0m PAUSE             pause screen
  "^T"    [1m/kb_transpose_chars[22;0m     *transpose characters
  "^U"    [1m/kb_backward_kill_line[22;0m   delete to beginning of line
  "^V"    [1m/dokey[22;0m LNEXT             input next key literally
  "^W"    [1m/dokey[22;0m BWORD            *delete backward word (space-delimited)
  "^?"    (internal)              *backspace
  "^X^R"  [1m/load[22;0m [1m~/.tfrc[22;0m            reload personal config file
  "^X^V"  [1m/version[22;0m                 display version information
  "^X^?"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^X["   [1m/dokey[22;0m_hpageback        *scroll back a half screenful
  "^X]"   [1m/dokey[22;0m_hpage            *scroll forward a half screenful
  "^X{"   [1m/dokey[22;0m_pageback         *scroll back a screenful
  "^X}"   [1m/dokey[22;0m_page             *scroll forward a screenful
  "^[^E"  [1m/kb_expand_line[22;0m          [1mexpand[22;0m current input line in place
  "^[^H"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^[^I"  [1m/complete[22;0m                complete current word, depending on context
  "^[^L"  [1m/dokey[22;0m clear             clear screen (can be refilled with [1mscrollback[22;0m)
  "^[^N"  [1m/dokey[22;0m line             *scroll forward one line
  "^[^P"  [1m/dokey[22;0m lineback         *scroll back one line
  "^[^W"  [1m/complete worldname[22;0m      complete TF world name
  "^[$"   [1m/complete macroname[22;0m      complete TF macro name
  "^[%"   [1m/complete variable[22;0m       complete TF variable name
  "^[/"   [1m/complete filename[22;0m       complete file name (unix only)
  "^[ "   [1m/kb_collapse_space[22;0m       change multiple spaces to a single space
  "^[-"   [1m/set[22;0m [1mkbnum[22;0m=-             start [1mkbnum[22;0m entry with -
  "^[0"   [1m/set[22;0m [1mkbnum[22;0m=+0            start [1mkbnum[22;0m entry with 0
  ...
  "^[9"   [1m/set[22;0m [1mkbnum[22;0m=+9            start [1mkbnum[22;0m entry with 9
  "^[;"   [1m/complete user_defined[22;0m   complete from [1m%{completion_list}[22;0m
  "^[="   [1m/kb_goto_match[22;0m           move cursor to matching parenthesis/bracket
  "^[."   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[<"   [1m/dokey[22;0m recallbeg         go to beginning of input history
  "^[>"   [1m/dokey[22;0m recallend         go to end of input history
  "^[J"   [1m/dokey[22;0m selflush          selective flush (similar to "[1m/dokey[22;0m flush"
                                   followed by "[1m/limit[22;0m -a")
  "^[L"   [1m/kb_toggle_limit[22;0m         toggle between [1m/unlimit[22;0m and [1m/relimit[22;0m
  "^[_"   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[b"   [1m/dokey_wleft[22;0m            *cursor to beginning of word
  "^[c"   [1m/kb_capitalize_word[22;0m     *capitalize word
  "^[d"   [1m/kb_kill_word[22;0m           *delete forward word
  "^[fult keybindings
 type 'tiny.mush', escape all 
  occurrences of '%', '[' and '\' within that line, and send the new line 
  instead of the original.  This is useful for avoiding unwanted 
  interpretation of '%', '[', and '\' on TinyMUSH servers.  

      [1m/hook[22;0m SIGHUP = [1m/log[22;0m on%; [1m/recall[22;0m /10

  will [1mlog[22;0m the last 10 lines of output if you are unexpectedly disconnected 
  from your tf session.  

#CONNETFAIL
  The CONNETFAIL hook, which existed in versions 5.0 alpha 13 through 5.0 beta 
  6, has been replaced with the [1mICONFAIL[22;0m hook.  
#

  See also: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mpriority[22;0m, [1msignals[22;0m.  

&topics

topics

  Topics marked with + are new; those marked with * have changed since the 
  last version.  Many topics also have subtopics that are not listed here 
  (e.g., individual [1mvariables[22;0m, [1mhooks[22;0m, and functions).  


   *[1mcopying[22;0m       copyright; no warranty
    [1mintro[22;0m         introduction to tf
    [1mstartup[22;0m       how to start tf
    [1minterface[22;0m     how input works
    [1mtfrc[22;0m          personal config file
   *[1mvisual[22;0m        split-screen mode
   *[1mcommands[22;0m      list of commands
   *[1mworlds[22;0m        defining worlds
   *[1mpatterns[22;0m      glob and regexp pattern matching
   *[1mvariables[22;0m     state and environment
   *[1mglobals[22;0m       special tf variables
    [1mattributes[22;0m    special text display
    [1mprompts[22;0m       using LP/Diku prompts
    [1mproblems[22;0m      bugs, core dumps, etc.
   *[1mevaluation[22;0m    macro body execution
    [1mmacros[22;0m        user-defined commands
   *[1msockets[22;0m       world connections
    [1mhistory[22;0m       recall and logging
    [1mpriority[22;0m      trigger/hook selection
   *[1mkeybindings[22;0m   keyboard operations
    [1mcolor[22;0m         terminal color codes
   *[1mprotocols[22;0m     protocols supported by TF
    [1mexpressions[22;0m   math and string operations
    [1mtriggers[22;0m      automatic command execution based on incoming text
   *[1mhooks[22;0m         automatic command execution based on tf events
   +[1mmail[22;0m          mail checking
    [1mlibrary[22;0m       macros and variables in stdlib.tf
   *[1mtools[22;0m         extra commands in tools.tf
    [1mutilities[22;0m     useful extra command files
   *[1mprocesses[22;0m     timed commands and command quoting
   *[1msubs[22;0m          arithmetic, command, [1mmacro[22;0m, and variable substitutions
   *[1mfunctions[22;0m     special [1mexpression[22;0m operations
   *[1mhints[22;0m         some hints and style tips for [1mmacro[22;0m programming
   +[1mdebugging[22;0m     debugging your [1mmacros[22;0m
   *[1mtfio[22;0m          output, error, and world streams
   *[1mproxy[22;0m         connecting to outside hosts via a proxy server (firewall)
   +[1mlocale[22;0m        multi-language support
    

&typing
&user
&interface

interface

  Any input line that does not begin with '/' will be sent directly to the 
  [1mforeground[22;0m world, if there is one.  A line starting with more than one '/' 
  will be sent to the forground [1msocket[22;0m after having the first '/' removed.  
  (Exception: lines may be caught with a SEND [1mhook[22;0m before being sent; see 
  "[1mhooks[22;0m").  

  Any input line beginning with a single '/' is a TF command, which will be 
  interpreted as described in "[1mevaluation[22;0m".  

  Input lines of the form "^old^new" will cause TF to search backward in the 
  input [1mhistory[22;0m for a line containing "old", replace that text with "new", and 
  execute the modified command.  See: [1mhistory[22;0m.  

  Many special functions, such as backspace, can be performed by special keys 
  or sequences of keys.  See "[1mdokey[22;0m" for a complete list.  You can also define 
  your own commands and bind them to key sequences.  See [1mbind[22;0m.  

  Normally, user input does not undergo the [1mexpansion[22;0m that [1mmacro[22;0m bodies 
  undergo.  The [1m/eval[22;0m command can be used to [1mexpand[22;0m text before executing it.  
  If the [1m%{sub}[22;0m flag is on (it is off by default), user input undergoes [1mmacro[22;0m 
  body [1mexpansion[22;0m without the [1m%{sub}[22;0m flag.  The [1m%{sub}[22;0m flag also applies to 
  text generated by "^old^new" history commands.  See: [1mhistory[22;0m, [1m/sub[22;0m, 
  [1mvariables[22;0m 

  Control characters may be input literally.  A literal control character will 
  be displayed in the input window in printable form in bold reverse.  Note 
  that since most control keys are also parts of the default keybindings, it 
  will usually be necessary to type ^V ([1m/dokey[22;0m LNEXT) to avoid invoking the 
  keybinding.  

  International characters may be input if your [1mlocale[22;0m is set to a locale that 
  supports them and your system supports locales.  Any input character that is 
  not valid in your locale and has the high bit set (normally generated by 
  holding the "meta" key) will be translated to ESC plus that character with 
  the high bit stripped (assuming [1m%meta_esc[22;0m is on).  This allows M-x and ^[x 
  to invoke the same ^[x keybinding.  See [1mlocale[22;0m, [1m%meta_esc[22;0m, [1m%istrip[22;0m.  

  If standard input is not a terminal, [1mvisual[22;0m mode will not be allowed, and tf 
  will continue to operate even after EOF is read, until /quit or something 
  else terminates it.  

  See also: [1mvisual[22;0m, [1moptions[22;0m 

&intro
&me
&newbie
&tinyfugue
&introduction

introduction

  TinyFugue is a MUD client.  It helps you connect to a MUD, in a much more 
  convenient manner than telnet.  You can connect to a mud world using the 
  same syntax as you would with telnet: "[1mtf[22;0m <[4mhost[24m> <[4mport[24m>".  Or, while running 
  tf, you can use "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>".  To make things easier, you can 
  give names to worlds, using [1m/addworld[22;0m, and then use "[1mtf[22;0m <[4mname[24m>" and 
  "[1m/connect[22;0m <[4mname[24m>".  If you store a set of [1m/addworld[22;0m commands in a file, TF 
  can read them automatically when it starts.  You can even connect to more 
  than one world at the same time, and switch between them.  See: [1m/connect[22;0m, 
  [1m/fg[22;0m, [1m/addworld[22;0m, [1mworlds[22;0m, [1mtfrc[22;0m.  

  Normally, TF will split the screen into two windows: one for input, and one 
  for output.  TF will display useful information on the line separating the 
  two windows, such as the name of the [1mforeground[22;0m world.  See: [1mwindows[22;0m.  

  Any line you type that starts with a single '/' is a tf command.  Anything 
  else you type will be sent to the mud.  See: [1minterface[22;0m, [1mcommands[22;0m.  

  You can define your own tf commands, called [1mmacros[22;0m.  The simplest type of 
  [1mmacro[22;0m is just an abbreviation or alias for a longer command or commands.  
  But [1mmacros[22;0m can also perform much more powerful tasks.  See: [1mmacros[22;0m, [1m/def[22;0m.  

  You can tell tf to watch for certain patterns in the text from the mud, and 
  then do special things when it sees that pattern: display the text in a 
  special way ([1mhilite[22;0m); not display the text at all ([1mgag[22;0m); execute a [1mmacro[22;0m 
  command ([1mtrigger[22;0m); or do any combination of these.  See: [1mattributes[22;0m, 
  [1mtriggers[22;0m, [1m/hilite[22;0m, [1m/gag[22;0m, [1m/trig[22;0m, [1m/def[22;0m.  

  TF keeps a [1mhistory[22;0m of every line it prints, every line sent by the mud, and 
  every command you enter.  You can see those histories using [1m/recall[22;0m.  You 
  can also have this text saved in a file using [1m/log[22;0m.  See: [1mhistory[22;0m, [1m/recall[22;0m, 
  [1m/log[22;0m.  

  See also: [1mtopics[22;0m 

&keys
&key
&kbbind
&kbfunc
&kbfunc.tf
&kbbind.tf
&keybindings

keybindings

Default keybindings

  TF's default command line editing keys are similar to those in emacs and 
  bash.  In addition, several features may be invoked by more than one 
  keybinding, and TF has keybindings for unique features like switching the 
  [1mforeground[22;0m [1msocket[22;0m.  

  Here, and throughout the TF documentation, the notation "^X" means the 
  character generated by typing the X key while holding the CTRL key.  Also, 
  "^[" can be more easily typed just by pressing the ESC key.  [1m/Def -b[22;0m and 
  [1m/bind[22;0m accept the ^X notation as well as "\<[4mnumber[24m>" notation, where <[4mnumber[24m> 
  is the octal, hexadecimal, or decimal number of the character's ascii value. 
  For example, the escape character can be given in any of these forms: ^[, 
  \033, \0x1B, or \27.  

  In the tables below, keys with "*" in the "Meaning" column make use of [1mkbnum[22;0m 
  (see [1mbelow[22;0m).  

#named keys
Named keys
  To redefine the named keys, see the section titled "[1mMapping Named Keys to 
  functions[22;0m".  

  Key         Command                 Meaning
  ---         -------                 -------
  Up          /kb_up_or_recallb       *cursor up or recall bkwd input [1mhistory[22;0m
  Down        /kb_down_or_recallf     *cursor down or recall fwd input [1mhistory[22;0m
  Right       [1m/dokey[22;0m RIGHT            *cursor right
  Left        [1m/dokey[22;0m LEFT             *cursor left
  Center      (none)

  Esc_Left    [1m/fg[22;0m -<                  *[1mforeground[22;0m previous [1msocket[22;0m
  Esc_Right   [1m/fg[22;0m ->                  *[1mforeground[22;0m next [1msocket[22;0m

  Ctrl_Up     [1m/dokey_recallb[22;0m          *recall backward input
  Ctrl_Down   [1m/dokey_recallf[22;0m          *recall forward input
  Ctrl_Right  [1m/dokey_wright[22;0m           *word right
  Ctrl_Left   [1m/dokey_wleft[22;0m            *word left

  Insert      [1m/test[22;0m [1minsert[22;0m:=![1minsert[22;0m    toggle [1minsert[22;0m mode
  Delete      [1m/dokey[22;0m dch              *delete character
  Home        [1m/dokey_home[22;0m              cursor to beginning of line
  End         [1m/dokey_end[22;0m               cursor to end of line
  PgDn        [1m/dokey_pgdn[22;0m             *scroll forward a screenful
  PgUp        [1m/dokey_pgup[22;0m             *scroll back a screenful
  Tab         [1m/dokey page[22;0m             *scroll forward a screenful

  Ctrl_Home   [1m/dokey_recallbeg[22;0m         recall first line of input
  Ctrl_End    [1m/dokey_recallend[22;0m         recall last line of input
  Ctrl_PgDn   [1m/dokey_flush[22;0m             scroll forward to last screenful
  Ctrl_PgUp   (reserved for future use)

  F1          [1m/help[22;0m                    help
  F2          (none)                   (function key F1)
  ...
  F20         (none)                   (function key F20)

  nkpTab      (none)                   (see "[1mkeypad[22;0m" section below)
  nkpEnt      (none)                   (see "[1mkeypad[22;0m" section below)
  nkp*        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp+        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp,        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp-        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp.        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp/        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp0        (none)                   (see "[1mkeypad[22;0m" section below)
  ...
  nkp9        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp=        (none)                   (see "[1mkeypad[22;0m" section below)

#unnamed keys
Unnamed key sequences

  String  Command                 Meaning
  ------  -------                 -------
  "^A"    [1m/dokey_home[22;0m              cursor to beginning of line
  "^B"    [1m/dokey[22;0m LEFT             *cursor left
  "^D"    [1m/dokey_dch[22;0m              *delete character to the right
  "^E"    [1m/dokey_end[22;0m               cursor to end of line
  "^F"    [1m/dokey[22;0m RIGHT            *cursor right
  "^G"    [1m/beep[22;0m 1                  beep
  "^H"    (internal)              *backspace
  "^I"    [1m/key_tab[22;0m                 perform the function assigned to the TAB key
  "^J"    (internal)               execute current line
  "^K"    [1m/dokey_deol[22;0m              delete to end of line
  "^L"    [1m/dokey[22;0m redraw            redraw (not clear) screen
  "^M"    (internal)               execute current line
  "^N"    [1m/dokey[22;0m recallf          *recall forward input [1mhistory[22;0m
  "^P"    [1m/dokey[22;0m recallb          *recall backward input [1mhistory[22;0m
  "^Q"    [1m/dokey[22;0m LNEXT             input next key literally (may be overridden
                                   by [1mterminal[22;0m)
  "^R"    [1m/dokey[22;0m REFRESH           refresh line
  "^S"    [1m/dokey[22;0m PAUSE             pause screen
  "^T"    [1m/kb_transpose_chars[22;0m     *transpose characters
  "^U"    [1m/kb_backward_kill_line[22;0m   delete to beginning of line
  "^V"    [1m/dokey[22;0m LNEXT             input next key literally
  "^W"    [1m/dokey[22;0m BWORD            *delete backward word (space-delimited)
  "^?"    (internal)              *backspace
  "^X^R"  [1m/load[22;0m [1m~/.tfrc[22;0m            reload personal config file
  "^X^V"  [1m/version[22;0m                 display version information
  "^X^?"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^X["   [1m/dokey[22;0m_hpageback        *scroll back a half screenful
  "^X]"   [1m/dokey[22;0m_hpage            *scroll forward a half screenful
  "^X{"   [1m/dokey[22;0m_pageback         *scroll back a screenful
  "^X}"   [1m/dokey[22;0m_page             *scroll forward a screenful
  "^[^E"  [1m/kb_expand_line[22;0m          [1mexpand[22;0m current input line in place
  "^[^H"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^[^I"  [1m/complete[22;0m                complete current word, depending on context
  "^[^L"  [1m/dokey[22;0m clear             clear screen (can be refilled with [1mscrollback[22;0m)
  "^[^N"  [1m/dokey[22;0m line             *scroll forward one line
  "^[^P"  [1m/dokey[22;0m lineback         *scroll back one line
  "^[^W"  [1m/complete worldname[22;0m      complete TF world name
  "^[$"   [1m/complete macroname[22;0m      complete TF macro name
  "^[%"   [1m/complete variable[22;0m       complete TF variable name
  "^[/"   [1m/complete filename[22;0m       complete file name (unix only)
  "^[ "   [1m/kb_collapse_space[22;0m       change multiple spaces to a single space
  "^[-"   [1m/set[22;0m [1mkbnum[22;0m=-             start [1mkbnum[22;0m entry with -
  "^[0"   [1m/set[22;0m [1mkbnum[22;0m=+0            start [1mkbnum[22;0m entry with 0
  ...
  "^[9"   [1m/set[22;0m [1mkbnum[22;0m=+9            start [1mkbnum[22;0m entry with 9
  "^[;"   [1m/complete user_defined[22;0m   complete from [1m%{completion_list}[22;0m
  "^[="   [1m/kb_goto_match[22;0m           move cursor to matching parenthesis/bracket
  "^[."   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[<"   [1m/dokey[22;0m recallbeg         go to beginning of input history
  "^[>"   [1m/dokey[22;0m recallend         go to end of input history
  "^[J"   [1m/dokey[22;0m selflush          selective flush (similar to "[1m/dokey[22;0m flush"
                                   followed by "[1m/limit[22;0m -a")
  "^[L"   [1m/kb_toggle_limit[22;0m         toggle between [1m/unlimit[22;0m and [1m/relimit[22;0m
  "^[_"   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[b"   [1m/dokey_wleft[22;0m            *cursor to beginning of word
  "^[c"   [1m/kb_capitalize_word[22;0m     *capitalize word
  "^[d"   [1m/kb_kill_word[22;0m           *delete forward word
  "^[fult keybindings
 type 'tiny.mush', escape all 
  occurrences of '%', '[' and '\' within that line, and send the new line 
  instead of the original.  This is useful for avoiding unwanted 
  interpretation of '%', '[', and '\' on TinyMUSH servers.  

      [1m/hook[22;0m SIGHUP = [1m/log[22;0m on%; [1m/recall[22;0m /10

  will [1mlog[22;0m the last 10 lines of output if you are unexpectedly disconnected 
  from your tf session.  

#CONNETFAIL
  The CONNETFAIL hook, which existed in versions 5.0 alpha 13 through 5.0 beta 
  6, has been replaced with the [1mICONFAIL[22;0m hook.  
#

  See also: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mpriority[22;0m, [1msignals[22;0m.  

&topics

topics

  Topics marked with + are new; those marked with * have changed since the 
  last version.  Many topics also have subtopics that are not listed here 
  (e.g., individual [1mvariables[22;0m, [1mhooks[22;0m, and functions).  


   *[1mcopying[22;0m       copyright; no warranty
    [1mintro[22;0m         introduction to tf
    [1mstartup[22;0m       how to start tf
    [1minterface[22;0m     how input works
    [1mtfrc[22;0m          personal config file
   *[1mvisual[22;0m        split-screen mode
   *[1mcommands[22;0m      list of commands
   *[1mworlds[22;0m        defining worlds
   *[1mpatterns[22;0m      glob and regexp pattern matching
   *[1mvariables[22;0m     state and environment
   *[1mglobals[22;0m       special tf variables
    [1mattributes[22;0m    special text display
    [1mprompts[22;0m       using LP/Diku prompts
    [1mproblems[22;0m      bugs, core dumps, etc.
   *[1mevaluation[22;0m    macro body execution
    [1mmacros[22;0m        user-defined commands
   *[1msockets[22;0m       world connections
    [1mhistory[22;0m       recall and logging
    [1mpriority[22;0m      trigger/hook selection
   *[1mkeybindings[22;0m   keyboard operations
    [1mcolor[22;0m         terminal color codes
   *[1mprotocols[22;0m     protocols supported by TF
    [1mexpressions[22;0m   math and string operations
    [1mtriggers[22;0m      automatic command execution based on incoming text
   *[1mhooks[22;0m         automatic command execution based on tf events
   +[1mmail[22;0m          mail checking
    [1mlibrary[22;0m       macros and variables in stdlib.tf
   *[1mtools[22;0m         extra commands in tools.tf
    [1mutilities[22;0m     useful extra command files
   *[1mprocesses[22;0m     timed commands and command quoting
   *[1msubs[22;0m          arithmetic, command, [1mmacro[22;0m, and variable substitutions
   *[1mfunctions[22;0m     special [1mexpression[22;0m operations
   *[1mhints[22;0m         some hints and style tips for [1mmacro[22;0m programming
   +[1mdebugging[22;0m     debugging your [1mmacros[22;0m
   *[1mtfio[22;0m          output, error, and world streams
   *[1mproxy[22;0m         connecting to outside hosts via a proxy server (firewall)
   +[1mlocale[22;0m        multi-language support
    

&typing
&user
&interface

interface

  Any input line that does not begin with '/' will be sent directly to the 
  [1mforeground[22;0m world, if there is one.  A line starting with more than one '/' 
  will be sent to the forground [1msocket[22;0m after having the first '/' removed.  
  (Exception: lines may be caught with a SEND [1mhook[22;0m before being sent; see 
  "[1mhooks[22;0m").  

  Any input line beginning with a single '/' is a TF command, which will be 
  interpreted as described in "[1mevaluation[22;0m".  

  Input lines of the form "^old^new" will cause TF to search backward in the 
  input [1mhistory[22;0m for a line containing "old", replace that text with "new", and 
  execute the modified command.  See: [1mhistory[22;0m.  

  Many special functions, such as backspace, can be performed by special keys 
  or sequences of keys.  See "[1mdokey[22;0m" for a complete list.  You can also define 
  your own commands and bind them to key sequences.  See [1mbind[22;0m.  

  Normally, user input does not undergo the [1mexpansion[22;0m that [1mmacro[22;0m bodies 
  undergo.  The [1m/eval[22;0m command can be used to [1mexpand[22;0m text before executing it.  
  If the [1m%{sub}[22;0m flag is on (it is off by default), user input undergoes [1mmacro[22;0m 
  body [1mexpansion[22;0m without the [1m%{sub}[22;0m flag.  The [1m%{sub}[22;0m flag also applies to 
  text generated by "^old^new" history commands.  See: [1mhistory[22;0m, [1m/sub[22;0m, 
  [1mvariables[22;0m 

  Control characters may be input literally.  A literal control character will 
  be displayed in the input window in printable form in bold reverse.  Note 
  that since most control keys are also parts of the default keybindings, it 
  will usually be necessary to type ^V ([1m/dokey[22;0m LNEXT) to avoid invoking the 
  keybinding.  

  International characters may be input if your [1mlocale[22;0m is set to a locale that 
  supports them and your system supports locales.  Any input character that is 
  not valid in your locale and has the high bit set (normally generated by 
  holding the "meta" key) will be translated to ESC plus that character with 
  the high bit stripped (assuming [1m%meta_esc[22;0m is on).  This allows M-x and ^[x 
  to invoke the same ^[x keybinding.  See [1mlocale[22;0m, [1m%meta_esc[22;0m, [1m%istrip[22;0m.  

  If standard input is not a terminal, [1mvisual[22;0m mode will not be allowed, and tf 
  will continue to operate even after EOF is read, until /quit or something 
  else terminates it.  

  See also: [1mvisual[22;0m, [1moptions[22;0m 

&intro
&me
&newbie
&tinyfugue
&introduction

introduction

  TinyFugue is a MUD client.  It helps you connect to a MUD, in a much more 
  convenient manner than telnet.  You can connect to a mud world using the 
  same syntax as you would with telnet: "[1mtf[22;0m <[4mhost[24m> <[4mport[24m>".  Or, while running 
  tf, you can use "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>".  To make things easier, you can 
  give names to worlds, using [1m/addworld[22;0m, and then use "[1mtf[22;0m <[4mname[24m>" and 
  "[1m/connect[22;0m <[4mname[24m>".  If you store a set of [1m/addworld[22;0m commands in a file, TF 
  can read them automatically when it starts.  You can even connect to more 
  than one world at the same time, and switch between them.  See: [1m/connect[22;0m, 
  [1m/fg[22;0m, [1m/addworld[22;0m, [1mworlds[22;0m, [1mtfrc[22;0m.  

  Normally, TF will split the screen into two windows: one for input, and one 
  for output.  TF will display useful information on the line separating the 
  two windows, such as the name of the [1mforeground[22;0m world.  See: [1mwindows[22;0m.  

  Any line you type that starts with a single '/' is a tf command.  Anything 
  else you type will be sent to the mud.  See: [1minterface[22;0m, [1mcommands[22;0m.  

  You can define your own tf commands, called [1mmacros[22;0m.  The simplest type of 
  [1mmacro[22;0m is just an abbreviation or alias for a longer command or commands.  
  But [1mmacros[22;0m can also perform much more powerful tasks.  See: [1mmacros[22;0m, [1m/def[22;0m.  

  You can tell tf to watch for certain patterns in the text from the mud, and 
  then do special things when it sees that pattern: display the text in a 
  special way ([1mhilite[22;0m); not display the text at all ([1mgag[22;0m); execute a [1mmacro[22;0m 
  command ([1mtrigger[22;0m); or do any combination of these.  See: [1mattributes[22;0m, 
  [1mtriggers[22;0m, [1m/hilite[22;0m, [1m/gag[22;0m, [1m/trig[22;0m, [1m/def[22;0m.  

  TF keeps a [1mhistory[22;0m of every line it prints, every line sent by the mud, and 
  every command you enter.  You can see those histories using [1m/recall[22;0m.  You 
  can also have this text saved in a file using [1m/log[22;0m.  See: [1mhistory[22;0m, [1m/recall[22;0m, 
  [1m/log[22;0m.  

  See also: [1mtopics[22;0m 

&keys
&key
&kbbind
&kbfunc
&kbfunc.tf
&kbbind.tf
&keybindings

keybindings

Default keybindings

  TF's default command line editing keys are similar to those in emacs and 
  bash.  In addition, several features may be invoked by more than one 
  keybinding, and TF has keybindings for unique features like switching the 
  [1mforeground[22;0m [1msocket[22;0m.  

  Here, and throughout the TF documentation, the notation "^X" means the 
  character generated by typing the X key while holding the CTRL key.  Also, 
  "^[" can be more easily typed just by pressing the ESC key.  [1m/Def -b[22;0m and 
  [1m/bind[22;0m accept the ^X notation as well as "\<[4mnumber[24m>" notation, where <[4mnumber[24m> 
  is the octal, hexadecimal, or decimal number of the character's ascii value. 
  For example, the escape character can be given in any of these forms: ^[, 
  \033, \0x1B, or \27.  

  In the tables below, keys with "*" in the "Meaning" column make use of [1mkbnum[22;0m 
  (see [1mbelow[22;0m).  

#named keys
Named keys
  To redefine the named keys, see the section titled "[1mMapping Named Keys to 
  functions[22;0m".  

  Key         Command                 Meaning
  ---         -------                 -------
  Up          /kb_up_or_recallb       *cursor up or recall bkwd input [1mhistory[22;0m
  Down        /kb_down_or_recallf     *cursor down or recall fwd input [1mhistory[22;0m
  Right       [1m/dokey[22;0m RIGHT            *cursor right
  Left        [1m/dokey[22;0m LEFT             *cursor left
  Center      (none)

  Esc_Left    [1m/fg[22;0m -<                  *[1mforeground[22;0m previous [1msocket[22;0m
  Esc_Right   [1m/fg[22;0m ->                  *[1mforeground[22;0m next [1msocket[22;0m

  Ctrl_Up     [1m/dokey_recallb[22;0m          *recall backward input
  Ctrl_Down   [1m/dokey_recallf[22;0m          *recall forward input
  Ctrl_Right  [1m/dokey_wright[22;0m           *word right
  Ctrl_Left   [1m/dokey_wleft[22;0m            *word left

  Insert      [1m/test[22;0m [1minsert[22;0m:=![1minsert[22;0m    toggle [1minsert[22;0m mode
  Delete      [1m/dokey[22;0m dch              *delete character
  Home        [1m/dokey_home[22;0m              cursor to beginning of line
  End         [1m/dokey_end[22;0m               cursor to end of line
  PgDn        [1m/dokey_pgdn[22;0m             *scroll forward a screenful
  PgUp        [1m/dokey_pgup[22;0m             *scroll back a screenful
  Tab         [1m/dokey page[22;0m             *scroll forward a screenful

  Ctrl_Home   [1m/dokey_recallbeg[22;0m         recall first line of input
  Ctrl_End    [1m/dokey_recallend[22;0m         recall last line of input
  Ctrl_PgDn   [1m/dokey_flush[22;0m             scroll forward to last screenful
  Ctrl_PgUp   (reserved for future use)

  F1          [1m/help[22;0m                    help
  F2          (none)                   (function key F1)
  ...
  F20         (none)                   (function key F20)

  nkpTab      (none)                   (see "[1mkeypad[22;0m" section below)
  nkpEnt      (none)                   (see "[1mkeypad[22;0m" section below)
  nkp*        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp+        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp,        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp-        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp.        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp/        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp0        (none)                   (see "[1mkeypad[22;0m" section below)
  ...
  nkp9        (none)                   (see "[1mkeypad[22;0m" section below)
  nkp=        (none)                   (see "[1mkeypad[22;0m" section below)

#unnamed keys
Unnamed key sequences

  String  Command                 Meaning
  ------  -------                 -------
  "^A"    [1m/dokey_home[22;0m              cursor to beginning of line
  "^B"    [1m/dokey[22;0m LEFT             *cursor left
  "^D"    [1m/dokey_dch[22;0m              *delete character to the right
  "^E"    [1m/dokey_end[22;0m               cursor to end of line
  "^F"    [1m/dokey[22;0m RIGHT            *cursor right
  "^G"    [1m/beep[22;0m 1                  beep
  "^H"    (internal)              *backspace
  "^I"    [1m/key_tab[22;0m                 perform the function assigned to the TAB key
  "^J"    (internal)               execute current line
  "^K"    [1m/dokey_deol[22;0m              delete to end of line
  "^L"    [1m/dokey[22;0m redraw            redraw (not clear) screen
  "^M"    (internal)               execute current line
  "^N"    [1m/dokey[22;0m recallf          *recall forward input [1mhistory[22;0m
  "^P"    [1m/dokey[22;0m recallb          *recall backward input [1mhistory[22;0m
  "^Q"    [1m/dokey[22;0m LNEXT             input next key literally (may be overridden
                                   by [1mterminal[22;0m)
  "^R"    [1m/dokey[22;0m REFRESH           refresh line
  "^S"    [1m/dokey[22;0m PAUSE             pause screen
  "^T"    [1m/kb_transpose_chars[22;0m     *transpose characters
  "^U"    [1m/kb_backward_kill_line[22;0m   delete to beginning of line
  "^V"    [1m/dokey[22;0m LNEXT             input next key literally
  "^W"    [1m/dokey[22;0m BWORD            *delete backward word (space-delimited)
  "^?"    (internal)              *backspace
  "^X^R"  [1m/load[22;0m [1m~/.tfrc[22;0m            reload personal config file
  "^X^V"  [1m/version[22;0m                 display version information
  "^X^?"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^X["   [1m/dokey[22;0m_hpageback        *scroll back a half screenful
  "^X]"   [1m/dokey[22;0m_hpage            *scroll forward a half screenful
  "^X{"   [1m/dokey[22;0m_pageback         *scroll back a screenful
  "^X}"   [1m/dokey[22;0m_page             *scroll forward a screenful
  "^[^E"  [1m/kb_expand_line[22;0m          [1mexpand[22;0m current input line in place
  "^[^H"  [1m/kb_backward_kill_word[22;0m  *delete backward word (punctuation-delimited)
  "^[^I"  [1m/complete[22;0m                complete current word, depending on context
  "^[^L"  [1m/dokey[22;0m clear             clear screen (can be refilled with [1mscrollback[22;0m)
  "^[^N"  [1m/dokey[22;0m line             *scroll forward one line
  "^[^P"  [1m/dokey[22;0m lineback         *scroll back one line
  "^[^W"  [1m/complete worldname[22;0m      complete TF world name
  "^[$"   [1m/complete macroname[22;0m      complete TF macro name
  "^[%"   [1m/complete variable[22;0m       complete TF variable name
  "^[/"   [1m/complete filename[22;0m       complete file name (unix only)
  "^[ "   [1m/kb_collapse_space[22;0m       change multiple spaces to a single space
  "^[-"   [1m/set[22;0m [1mkbnum[22;0m=-             start [1mkbnum[22;0m entry with -
  "^[0"   [1m/set[22;0m [1mkbnum[22;0m=+0            start [1mkbnum[22;0m entry with 0
  ...
  "^[9"   [1m/set[22;0m [1mkbnum[22;0m=+9            start [1mkbnum[22;0m entry with 9
  "^[;"   [1m/complete user_defined[22;0m   complete from [1m%{completion_list}[22;0m
  "^[="   [1m/kb_goto_match[22;0m           move cursor to matching parenthesis/bracket
  "^[."   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[<"   [1m/dokey[22;0m recallbeg         go to beginning of input history
  "^[>"   [1m/dokey[22;0m recallend         go to end of input history
  "^[J"   [1m/dokey[22;0m selflush          selective flush (similar to "[1m/dokey[22;0m flush"
                                   followed by "[1m/limit[22;0m -a")
  "^[L"   [1m/kb_toggle_limit[22;0m         toggle between [1m/unlimit[22;0m and [1m/relimit[22;0m
  "^[_"   [1m/kb_last_argument[22;0m        input last word of previous line
  "^[b"   [1m/dokey_wleft[22;0m            *cursor to beginning of word
  "^[c"   [1m/kb_capitalize_word[22;0m     *capitalize word
  "^[d"   [1m/kb_kill_word[22;0m           *delete forward word
  "^[fult keybindings
 type 'tiny.mush', escape all 
  occurrences of '%', '[' and '\' within that line, and send the new line 
  instead of the original.  This is useful for avoiding unwanted 
  interpretation of '%', '[', and '\' on TinyMUSH servers.  

      [1m/hook[22;0m SIGHUP = [1m/log[22;0m on%; [1m/recall[22;0m /10

  will [1mlog[22;0m the last 10 lines of output if you are unexpectedly disconnected 
  from your tf session.  

#CONNETFAIL
  The CONNETFAIL hook, which existed in versions 5.0 alpha 13 through 5.0 beta 
  6, has been replaced with the [1mICONFAIL[22;0m hook.  
#

  See also: [1mmacros[22;0m, [1mtriggers[22;0m, [1mpatterns[22;0m, [1mpriority[22;0m, [1msignals[22;0m.  

&topics

topics

  Topics marked with + are new; those marked with * have changed since the 
  last version.  Many topics also have subtopics that are not listed here 
  (e.g., individual [1mvariables[22;0m, [1mhooks[22;0m, and functions).  


   *[1mcopying[22;0m       copyright; no warranty
    [1mintro[22;0m         introduction to tf
    [1mstartup[22;0m       how to start tf
    [1minterface[22;0m     how input works
    [1mtfrc[22;0m          personal config file
   *[1mvisual[22;0m        split-screen mode
   *[1mcommands[22;0m      list of commands
   *[1mworlds[22;0m        defining worlds
   *[1mpatterns[22;0m      glob and regexp pattern matching
   *[1mvariables[22;0m     state and environment
   *[1mglobals[22;0m       special tf variables
    [1mattributes[22;0m    special text display
    [1mprompts[22;0m       using LP/Diku prompts
    [1mproblems[22;0m      bugs, core dumps, etc.
   *[1mevaluation[22;0m    macro body execution
    [1mmacros[22;0m        user-defined commands
   *[1msockets[22;0m       world connections
    [1mhistory[22;0m       recall and logging
    [1mpriority[22;0m      trigger/hook selection
   *[1mkeybindings[22;0m   keyboard operations
    [1mcolor[22;0m         terminal color codes
   *[1mprotocols[22;0m     protocols supported by TF
    [1mexpressions[22;0m   math and string operations
    [1mtriggers[22;0m      automatic command execution based on incoming text
   *[1mhooks[22;0m         automatic command execution based on tf events
   +[1mmail[22;0m          mail checking
    [1mlibrary[22;0m       macros and variables in stdlib.tf
   *[1mtools[22;0m         extra commands in tools.tf
    [1mutilities[22;0m     useful extra command files
   *[1mprocesses[22;0m     timed commands and command quoting
   *[1msubs[22;0m          arithmetic, command, [1mmacro[22;0m, and variable substitutions
   *[1mfunctions[22;0m     special [1mexpression[22;0m operations
   *[1mhints[22;0m         some hints and style tips for [1mmacro[22;0m programming
   +[1mdebugging[22;0m     debugging your [1mmacros[22;0m
   *[1mtfio[22;0m          output, error, and world streams
   *[1mproxy[22;0m         connecting to outside hosts via a proxy server (firewall)
   +[1mlocale[22;0m        multi-language support
    

&typing
&user
&interface

interface

  Any input line that does not begin with '/' will be sent directly to the 
  [1mforeground[22;0m world, if there is one.  A line starting with more than one '/' 
  will be sent to the forground [1msocket[22;0m after having the first '/' removed.  
  (Exception: lines may be caught with a SEND [1mhook[22;0m before being sent; see 
  "[1mhooks[22;0m").  

  Any input line beginning with a single '/' is a TF command, which will be 
  interpreted as described in "[1mevaluation[22;0m".  

  Input lines of the form "^old^new" will cause TF to search backward in the 
  input [1mhistory[22;0m for a line containing "old", replace that text with "new", and 
  execute the modified command.  See: [1mhistory[22;0m.  

  Many special functions, such as backspace, can be performed by special keys 
  or sequences of keys.  See "[1mdokey[22;0m" for a complete list.  You can also define 
  your own commands and bind them to key sequences.  See [1mbind[22;0m.  

  Normally, user input does not undergo the [1mexpansion[22;0m that [1mmacro[22;0m bodies 
  undergo.  The [1m/eval[22;0m command can be used to [1mexpand[22;0m text before executing it.  
  If the [1m%{sub}[22;0m flag is on (it is off by default), user input undergoes [1mmacro[22;0m 
  body [1mexpansion[22;0m without the [1m%{sub}[22;0m flag.  The [1m%{sub}[22;0m flag also applies to 
  text generated by "^old^new" history commands.  See: [1mhistory[22;0m, [1m/sub[22;0m, 
  [1mvariables[22;0m 

  Control characters may be input literally.  A literal control character will 
  be displayed in the input window in printable form in bold reverse.  Note 
  that since most control keys are also parts of the default keybindings, it 
  will usually be necessary to type ^V ([1m/dokey[22;0m LNEXT) to avoid invoking the 
  keybinding.  

  International characters may be input if your [1mlocale[22;0m is set to a locale that 
  supports them and your system supports locales.  Any input character that is 
  not valid in your locale and has the high bit set (normally generated by 
  holding the "meta" key) will be translated to ESC plus that character with 
  the high bit stripped (assuming [1m%meta_esc[22;0m is on).  This allows M-x and ^[x 
  to invoke the same ^[x keybinding.  See [1mlocale[22;0m, [1m%meta_esc[22;0m, [1m%istrip[22;0m.  

  If standard input is not a terminal, [1mvisual[22;0m mode will not be allowed, and tf 
  will continue to operate even after EOF is read, until /quit or something 
  else terminates it.  

  See also: [1mvisual[22;0m, [1moptions[22;0m 

&intro
&me
&newbie
&tinyfugue
&introduction

introduction

  TinyFugue is a MUD client.  It helps you connect to a MUD, in a much more 
  convenient manner than telnet.  You can connect to a mud world using the 
  same syntax as you would with telnet: "[1mtf[22;0m <[4mhost[24m> <[4mport[24m>".  Or, while running 
  tf, you can use "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>".  To make things easier, you can 
  give names to worlds, using [1m/addworld[22;0m, and then use "[1mtf[22;0m <[4mname[24m>" and 
  "[1m/connect[22;0m <[4mname[24m>".  If you store a set of [1m/addworld[22;0m commands in a file, TF 
  can read them automatically when it starts.  You can even connect to more 
  than one world at the same time, and switch between them.  See: [1m/connect[22;0m, 
  [1m/fg[22;0m, [1m/addworld[22;0m, [1mworlds[22;0m, [1mtfrc[22;0m.  

  Normally, TF will split the screen into two windows: one for input, and one 
  for output.  TF will display useful information on the line separating the 
  two windows, such as the name of the [1mforeground[22;0m world.  See: [1mwindows[22;0m.  

  Any line you type that starts with a single '/' is a tf command.  Anything 
  else you type will be sent to the mud.  See: [1minterface[22;0m, [1mcommands[22;0m.  

  You can define your own tf commands, called [1mmacros[22;0m.  The simplest type of 
  [1mmacro[22;0m is just an abbreviation or alias for a longer command or commands.  
  But [1mmacros[22;0m can also perform much more powerful tasks.  See: [1mmacros[22;0m, [1m/def[22;0m.  

  You can tell tf to watch for certain patterns in the text from the mud, and 
  then do special things when it sees that pattern: display the text in a 
  special way ([1mhilite[22;0m); not display the text at all ([1mgag[22;0m); execute a [1mmacro[22;0m 
  command ([1mtrigger[22;0m); or do any combination of these.  See: [1mattributes[22;0m, 
  [1mtriggers[22;0m, [1m/hilite[22;0m, [1m/gag[22;0m, [1m/trig[22;0m, [1m/def[22;0m.  

  TF keeps a [1mhistory[22;0m of every line it prints, every line sent by the mud, and 
  every command you enter.  You can see those histories using [1m/recall[22;0m.  You 
  can also have this text saved in a file using [1m/log[22;0m.  See: [1mhistory[22;0m, [1m/recall[22;0m, 
  [1m/log[22;0m.  

  See also: [1mtopics[22;0m 

&keys
&key
&kbbind
&kbfunc
&kbfunc.tf
&kbbind.tf
&keybindings

keybindings

Default keybindings

  TF's default command line editing keys are similar to those in emacs and 
  bash.  In addition, several features may be invoked by more than one 
  keybindi                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    