&/addworld
&addworld()

addworld()

  [1mFunction[22;0m usage: 

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

  Command usage: 

  [1m/ADDWORLD[22;0m [-p] [-T<[4mtype[24m>] <[4mname[24m> [<[4mchar[24m> <[4mpass[24m>] <[4mhost[24m> <[4mport[24m> [<[4mfile[24m>]
  [1m/ADDWORLD[22;0m [-T<[4mtype[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>.  

  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.  

  <[4mUse_proxy[24m> may be 0, "off", 1, or "on".  If <[4muse_proxy[24m> is 0 or "off" in 
  the function form, or -p is given in the 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.  

  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("QWest", "tiny.muck", "glia",         9999, <[4mchar[24m>, <[4mpass[24m>)
    [1m/test[22;0m [1maddworld[22;0m("DS",    "tiny.mush", "foo.bar.com",  6250, <[4mchar[24m>, <[4mpass[24m>)

  then tiny-style [1mautologin[22;0m would still work (using the library hooks), and 
  you could also define your own triggers and hooks specific to TinyMUCKs or 
  TinyMUSHes.  

  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/telnet[22;0m, [1m/edworld[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>
  ____________________________________________________________________________

  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.  

  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/REQUIRE[22;0m at.tf

  [1m/AT[22;0m <[4mwhen[24m> <[4mcommands[24m>
  ____________________________________________________________________________

  <[4mCommands[24m> will be executed at time-of-day <[4mwhen[24m>, which must be of the form 
  "<[4mhours[24m>:<[4mminutes[24m>" or "<[4mhours[24m>:<[4mminutes[24m>:<[4mseconds[24m>" (<[4mhours[24m> is between 0 
  and 23).  If <[4mwhen[24m> is less than equal to the current time of day, it is 
  interpreted as that time tomorrow.  The "equal" condition makes it possible 
  for /at to call /at again with the same <[4mwhen[24m> argument, and have it execute 
  tomorrow instead of immediately.  

  Example: [1m/at[22;0m 23:30 [1m/echo[22;0m Stop mudding, it's time for Letterman! 

  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 -1 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, [1mutilities[22;0m (bind-bash, bind-emacs, 
  completion), [1mgeneral[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/~hawkeye/tf/CHANGES[22;0m.  

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

&/connect

/connect

  Usage: 

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

  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 connected.  If <[4mworld[24m> is omitted, the 
  first defined world will be used.  "[1m/connect[22;0m <[4mhost[24m> <[4mport[24m>" will define a 
  temporary world with the given address, and try to connect to it.  

  [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).  

  When successfully connected to a new [1msocket[22;0m, 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.  The default CONNECT [1mhook[22;0m calls [1m/fg[22;0m to 
      bring the new [1msocket[22;0m into the [1mforeground[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.  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.  

  When a hostname is given, TF must resolve it to an IP address.  If 
  [1m%{gethostbyname}[22;0m is "nonblocking", and this process takes too long, TF will 
  print "Hostname resolution for <[4mworld[24m> in progress" (the PENDING [1mhook[22;0m) and 
  continue to work in the background, leaving you free to do other things.  If 
  the resolution succeeds, TF will try to connect; if it fails, you will be 
  notified.  

  On most platforms, if [1m%{connect}[22;0m is "nonblocking" and the connection takes 
  too long, TF will print "Connection to <[4mworld[24m> in progress" (the PENDING 
  [1mhook[22;0m) and continue to try to connect in the background, leaving you free to 
  do other things.  If the connection eventually succeeds, you will be 
  switched to that [1msocket[22;0m (but see note below); if it fails, you will be 
  notified.  

  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).  

  When a pending [1m/connect[22;0m succeeds, the [1mforegrounding[22;0m is done by a CONNECT 
  [1mhook[22;0m defined by the standard library.  If you don't want to switch 
  automaticly, you can either delete the default [1mhook[22;0m ([1m/undef[22;0m 
  ~connect_switch_hook) or define your own (with a [1mpriority[22;0m higher than 0).  
  If you define your own but you still want the switch to occur, you must 
  either make it a [1mfall-thru[22;0m, or explicitly call "[1m/fg[22;0m [1m%1[22;0m" from your [1mhook[22;0m.  

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

  [1m/connect[22;0m returns 0 on error or failure, 1 on success, or 2 if the 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 

&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 that [1mpositional parameters[22;0m ([1m%n[22;0m) 
          and [1msubexpression matches[22;0m ([1m%Pn[22;0m) are not available in <[4mexpression[24m>.  
          Default: no [1mexpression[22;0m (i.e., always match if the trigger or hook 
          matches).  

#/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.  

#/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.  

#/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".  

#/def -B
#-B
  -B<[4mkeyname[24m> 
          The [1mmacro[22;0m will be called when the key named <[4mkeyname[24m> is typed at 
          the keyboard.  Default: no key.  The list of recognized <[4mkeyname[24m>s 
          and other details are described under "[1mkeybindings[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>.  Default: 
          1.  See also: [1mfall-thru[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[ngGurfdBbhC] 
          Set [1mattribute[22;0m(s) (normal, [1mgag[22;0m, norecord, underline, reverse, flash, 
          dim, 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[<[4mn[24m>][nurfdBhC] 
          "Partial [1mhilite[22;0m": Set [1mattribute[22;0m(s) used to display text matched by 
          the <[4mn[24m>th parenthesized subexpression in a [1mregexp[22;0m [1mtrigger[22;0m.  If <[4mn[24m> 
          is omitted it defaults to 0, i.e.  the text matched by the entire 
          [1mregexp[22;0m.  If there are multiple matches in the text, the [1mattributes[22;0m 
          will be applied to all of them.  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>
  ____________________________________________________________________________

  Executes the function of the edit key <[4mname[24m>.  Most of the edit key 
  functions are not meaningful when the [1m/dokey[22;0m command is executed from the 
  regular command line, but are intended to be called from a keybinding 
  created with [1m/bind[22;0m or [1m/def[22;0m [1m-b[22;0m.  


    Name          Default binding   Function
    ----          ---------------   --------
#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            (termcap), ^[[A   Cursor up
#down
    DOWN          (termcap), ^[[B   Cursor down
#right
    RIGHT         (termcap), ^[[C   Cursor right
#left
    LEFT          (termcap), ^[[D   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                Clear/redraw 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
#page
    PAGE          ^I                Scroll 1 page ("[1mmore[22;0m")
#hpage
    HPAGE         ^[h               Scroll half page ("[1mmore[22;0m")
#line
    LINE          ^[L               Scroll 1 line ("[1mmore[22;0m")
#flush
    FLUSH         ^[j               Discard all queued lines.
#selflush
    SELFLUSH      ^[J               Discard queued lines without [1mattributes[22;0m.

#

  A default of "(stty)" means the key sequence is that used by your terminal 
  driver.  A default of "(termcap)" means the key sequence is that given in 
  the termcap entry for [1m%TERM[22;0m.  

  The return value of [1m/dokey[22;0m depends on the function.  The movement and 
  deletion functions return the new position of the cursor.  The return values 
  of other functions aren't very useful.  

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

  Example: 

    [1m/bind[22;0m ^? = [1m/dokey[22;0m BSPC
    [1m/bind[22;0m ^H = [1m/dokey[22;0m BSPC

  Both ^H and DEL could then be used to do backspacing (this is already done 
  by default).  

  See: [1mkeybindings[22;0m, [1mgeneral[22;0m, [1msockets[22;0m, [1mhistory[22;0m, [1m/bind[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 [-p] [-a<[4mattrs[24m>] [-e] [-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.  
  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).  

  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!", "B", 1)
    [1m/echo[22;0m -aB -p @{u}Hello@{n}, world!

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

    [1m[4mHello[24m, world![22m

  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.  

  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 turning it off without actually [1mundefining[22;0m it.  

  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

  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 [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 

  -s<[4mlevel[24m> 
          Expands the <[4mcommand[24m> as if [1m%{sub}[22;0m were set to <[4mlevel[24m>.  By default, 
          [1m/eval[22;0m expands the <[4mcommand[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 is a shorthand for "[1m/eval[22;0m 
  [1m/echo[22;0m -- $$[<[4m[1mexpression[22;0m[24m>]".  

  Example: 

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

  See: [1mexpressions[22;0m 

&/bg
&/fg

/fg

  Usage: 

  [1m/FG[22;0m [-nsq<>] [<[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, 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.  
  -l      ignored.  
  -q      quiet: don't display lines that were buffered while the 
          socket was in the background.  

  [1m/fg[22;0m returns 0 on failure, nonzero otherwise.  

  If successful, [1m/fg[22;0m invokes the WORLD [1mhook[22;0m, which by default echoes "---- 
  World <[4mworld[24m> ----" or "---- No world ----".  

  [1m/bg[22;0m puts all [1msockets[22;0m in the [1mbackground[22;0m, and is equivalent to [1m/fg[22;0m -n.  

  See: [1m/connect[22;0m, [1mworlds[22;0m, [1msockets[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 perfomred 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 a system time <[4mtime[24m> (obtained from [1mtime()[22;0m) 
  according to <[4mformat[24m>.  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 (nonstandard TF extension) 
  %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) 
  %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      second (00-61) 
  %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; see your system's strftime() documentation for details.  All 
  other characters in <[4mformat[24m> are copied unmodified to the result.  

  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 

&/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/~hawkeye/tf/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 elm

  will automatically invoke "elm" 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 the return value of the 
  last <[4mexpr[24m> evaluated or <[4mlist[24m> executed.  

  [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 in the current version.  

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

&/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 

&/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.  
  -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>.  
  -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 -aurfdh ^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, flash, dim, or [1mhilite[22;0m 
  [1mattributes[22;0m; and have an empty body.  

  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 [-s] [-m<[4mstyle[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 
  -m<[4mstyle[24m> 
          Use <[4mstyle[24m> for [1mpattern matching[22;0m in other options (default: 
          [1m%{matching}[22;0m).  
  -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
          48  13h tiny.muck Cave            tcp.com                    2283
  *  foregnd   1m tiny.mush DeepSeas        muds.okstate.edu           6250
        none   7s telnet    whitehouse.gov, whitehouse.gov             smtp
   ?    none  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 "!" for dead, "?" for pending, "@" for an 
          established [1mproxy[22;0m connection, or blank for a normal established 
          connection.  
  LINES   for a [1mbackground[22;0m [1msocket[22;0m, the number of unseen lines; for a 
          [1mforeground[22;0m [1msocket[22;0m, "foregnd".  
  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 open 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>] [-T] [<[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).  
  -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 ';' 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 manipulates the state of the TELNET ECHO option.  With no 
  arguments, [1m/localecho[22;0m does nothing, and returns 0 if TF is not echoing its 
  input, or nonzero if tf is echoing input.  TF echoes its input by default, 
  unless the server has negotiated otherwise.  

  ON and OFF are ignored and [1m/localecho[22;0m returns 0 if the server is not known 
  to support TELNET protocol.  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.  Note that tf does 
  not transmit input until a newline is pressed, and the server can not echo 
  it until it is received.  

  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; 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.  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.  

  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".  

  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

  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 
  screenfull, ^[h will scroll a Half screen, ^[l will scroll one Line, and ^[j 
  will Jump to the end of the text, skipping all text which has been received 
  but not yet displayed.  

  In [1mvisual mode[22;0m, with the default setting of [1mstatus_fields[22;0m, the number of 
  pending lines is displayed with the More prompt.  If the number of pending 
  lines is 10000 or more, no number will be displayed and the prompt will just 
  say "MuchMore".  

  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, [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< argument, [1m/nohilite[22;0m undefines a [1mmacro[22;0m that is [1mtrigger[22;0med by 
  <pattern> and has the [1mhilite[22;0m [1mattribute[22;0m.  <Pattern> 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 
  `ESC 1' input the first word of the most recent mud output, you could do 
  this: 

  [1m/bind[22;0m ^[1 = [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).  Colors 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 

&/endpaste
&/paste

/paste

  Usage: 

  [1m/PASTE[22;0m [-p] [<[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 executed (without 
  [1msubstitution[22;0m).  If <[4mprefix[24m> is omitted, it defaults to the value of 
  %paste_prefix; if %paste_prefix is empty or unset, it defaults to ":|".  
  Entering the line "[1m/endpaste[22;0m" turns this off.  [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). 

  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 (ctrl-c) are the only ways to 
  end [1m/paste[22;0m.  

  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 [-s]
  ____________________________________________________________________________

  [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 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.  
  TYPE    [1mquote[22;0m or [1mrepeat[22;0m.  
  DISP    disposition (echo, send, or exec) of [1m/quote[22;0m lines.  
  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
  ____________________________________________________________________________

  Exits from TinyFugue.  All [1msocket[22;0m connections will be disconnected; all 
  logfiles will be closed; [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.  

  See: [1m/dc[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_cmd[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.  This will be done 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> 
          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, the command's [1mcurrent[22;0m world will be 
          whatever happens to be in the [1mforeground[22;0m when the 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>".  
          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 (see "[1mprocesses[22;0m").  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.  
  -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>   <[4msuf[24m> is suffixed to each generated line.  If omitted, the 
          double quotes around the <[4mfile[24m> or <[4mcommand[24m> may be omitted.  

  An asynchronous [1m/quote[22;0m returns the pid of the new [1mprocess[22;0m, or 0 if an error 
  occurred.  A synchronous 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 -decho #<[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, lines like "/* comment */", etc.) 

  ____________________________________________________________________________

  See: [1mprocesses[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>] 
  [#]<[4mrange[24m> [<[4mpattern[24m>]
  ____________________________________________________________________________

  Recalls lines from a [1mhistory[22;0m buffer.  

  [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.  
  -v      recall lines that [4mdon't[24m match the pattern 
  -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).  
  #       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).  

  /[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 <[4mpattern[24m> is given, only lines in the given range that match <[4mpattern[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 
  with "---- Recall start ----" and followed 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".  

  If lines are received while tf is suspended (by ^Z 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.  

  See: [1mhistory[22;0m, [1mattributes[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 

  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 -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>]] [-<[4mtime[24m>] <[4mcount[24m> <[4mcommand[24m>
  ____________________________________________________________________________

  Repeats <[4mcommand[24m>, <[4mcount[24m> times.  <[4mCommand[24m> may be any legal [1mmacro[22;0m body.  
  This works through a [1mprocess[22;0m i.e.  it runs concurrently with normal input 
  and output.  

  If <[4mtime[24m> is specified in the format "<[4mhours[24m>:<[4mminutes[24m>:<[4mseconds[24m>", 
  "<[4mhours[24m>:<[4mminutes[24m>", or "<[4mseconds[24m>", it is used as the delay between each 
  line.  If <[4mtime[24m> is given as the letter "S", the repeat will run 
  synchronously (see "[1mprocesses[22;0m").  Otherwise, the delay between each line is 
  determined by the [1mvariable[22;0m [1m%{ptime}[22;0m.  

  <[4mCommand[24m> will execute with <[4mworld[24m> as the [1mcurrent[22;0m world.  If no <[4mworld[24m> was 
  specified, the [1mcurrent[22;0m world will be whatever world happens to be the 
  [1mforeground[22;0m world when it's time for the command to run.  

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

  An asynchronous [1m/repeat[22;0m 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 an 
  asynchrounous [1m/repeat[22;0m), a useful trick is to use "[1m/repeat[22;0m -<[4mtime[24m> 1 
  <[4mcommand[24m>" to delay the execution of a single command.  

  Example: Here's a technique to execute an infinite 30-minute repeat: 

      [1m/def[22;0m doodle_forever = /doodle%; [1m/repeat[22;0m -0:30 1 /doodle_forever

  See: [1mprocesses[22;0m, [1m%ptime[22;0m, [1m/at[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>.  

#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([1mstrcat[22;0m({PL}, "TinyFugue", \
            [1mreplace[22;0m("TF", "TinyFugue", {PR})))

  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/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 

&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

  Usage: 

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

  Sends <[4mtext[24m> to a world.  

  [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).  

  If none of the -w, -W, or -T options are given, <[4mtext[24m> is sent to the 
  [1mcurrent[22;0m world.  

  The [1m/send[22;0m command never executes a SEND [1mhook[22;0m.  

  See: [1msend()[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.  

  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.  

  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 flag is on, Fugue 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 with access 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\n[22;0m" is substituted with the character with decimal ASCII code 
  <[4mnn[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 systems.  

  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 and the 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), and BINARY (allows transmission of 8-bit characters).  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 

&/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 

&/fgrep
&/grep
&/egrep
&/readfile
&/writefile
&/head
&/wc
&/tee
&/copyio
&/fmt
&/uniq
&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.  For all commands that take an optional <[4mhandle[24m> argument, [1mtfin[22;0m 
  is used if <[4mhandle[24m> is omitted.  

  [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>] [<[4mhandle[24m>] 
          Reads the first <[4mcount[24m> (default 10) lines from <[4mhandle[24m> or [1mtfin[22;0m and 
          writes them to [1mtfout[22;0m.  

  [1m/wc[22;0m [-lwc] [<[4mhandle[24m>] 
          Reads lines from <[4mhandle[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 <[4mhandle[24m> 
          Reads lines from [1mtfin[22;0m and prints them to <[4mhandle[24m> and [1mtfout[22;0m.  

  [1m/copyio[22;0m <[4min[24m> <[4mout[24m> 
          Reads lines from handle <[4min[24m> and prints them to handle <[4mout[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. 

  ____________________________________________________________________________

  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, [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>.

  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 [-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.  

  If no options are given, both -g and -w are assumed.  That is, <[4mtext[24m> is 
  matched against global [1mtriggers[22;0m and [1mhooks[22;0m, as well as [1mtriggers[22;0m and [1mhooks[22;0m for 
  the [1mcurrent[22;0m [1mworld[22;0m.  

  See: [1mtriggers[22;0m, [1mhooks[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/~hawkeye/tf/[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 [-lqn] [<[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 -lqn 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
&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, x, g, G, u, r, f, d, B, b, h, C<[4mcolor[24m>.  The attribute 
  codes stand for: none, exclusive, [1mgag[22;0m, norecord, underline, reverse, flash, 
  dim, Bold, bell, [1mhilite[22;0m, and [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 only for finding macros without attributes, e.g.  
  "[1mlist[22;0m -an".  

  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.  

  "G" (norecord) prevents the line from being recorded in [1mhistory[22;0m (however, if 
  [1mlogging[22;0m is enabled, the line will be [1mlogged[22;0m).  

  "C<[4mname[24m>" ([1mColor[22;0m) allows you to specify black, red, green, yellow, blue, 
  magenta, cyan, white, 8 thru 15, bgblack, bgred, bggreen, bgyellow, bgblue, 
  bgmagenta, bgcyan, or bgwhite.  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.  See: [1mcolor[22;0m.  

  "h" ([1mhilite[22;0m) [1mattribute[22;0m is special.  If specified, the [1mattributes[22;0m listed in 
  the [1m%{hiliteattr}[22;0m [1mvariable[22;0m 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.  

  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.  

  [1mAttributes[22;0m not supported by your terminal type will be ignored.  

&%catch_ctrls

%catch_ctrls

  See: [1m%emulation[22;0m 
&/color_on
&/color_off
&color
&colour
&colours
&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 ("C<[4mname[24m>") allows you to specify any one of: [30mblack[0m 
  (black), [31mred[0m, [32mgreen[0m, [33myellow[0m, [34mblue[0m, [35mmagenta[0m, [36mcyan[0m, [37mwhite[0m (white), 8 thru 15, 
  [40mbgblack[0m (bgblack), [41mbgred[0m, [42mbggreen[0m, [43mbgyellow[0m, [44mbgblue[0m, [45mbgmagenta[0m, [46mbgcyan[0m, or 
  [47mbgwhite[0m (bgwhite).  (If 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 first 
  eight are defined in stdlib.tf as ANSI foreground colors.  The bg* colors 
  are defined in stdlib.tf as ANSI background colors.  The numbered colors are 
  defined in stdlib.tf to work with the corresponding color xterm colors.  
  They can all be redefined as described below.  

  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.  

  On some terminals, lighter versions of ANSI colors can be produced by 
  combining bold with a color; for example, light red is BCred.  

  Note: color will not work if you are running tf under older versions of 
  iscreen, since they do not understand the color codes.  Also, some versions 
  of xterm don't support color; some variants that do include dtterm, cxterm, 
  color_xterm, rxvt, nxterm.  

  To define your own codes for terminals that don't accept the ANSI codes, you 
  will need to edit the color [1mvariables[22;0m.  The code to enable color <[4mname[24m> is 
  stored in a [1mvariable[22;0m called [1m%{start_color_<[4mname[24m>}[22;0m.  The code to turn it off 
  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[37;40;0m", which should work 
  on most ANSI-like terminals.  If you find that all text is reversed after 
  displaying some colored text, then try "[1m/set[22;0m [1mend_color[22;0m \033[30;47;0m".  

  If [1m%{emulation}[22;0m is set to "ansi_attr", ANSI 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 ANSI color codes from the 
  server into codes for your terminal, even if your terminal does not use ANSI 
  codes.  See: [1m%emulation[22;0m.  

  See: [1mattributes[22;0m 

&/complete
&%completion_list
&completion

completion

  Usage: 

  [1m/REQUIRE[22;0m complete.tf

  [1m/complete[22;0m 
  ____________________________________________________________________________

  Loading complete.tf will define the following keybindings: 

  ESC TAB 
          complete from context, input [1mhistory[22;0m, or [1m%{completion_list}[22;0m.  
  ESC ;   complete from [1m%{completion_list}[22;0m.  
  ESC i   complete from input [1mhistory[22;0m.  
  ESC /   filename completion.  
  ESC @   hostname completion.  
  ESC %   [1mvariable[22;0m name completion.  
  ESC $   [1mmacro[22;0m name completion.  
  ESC ^W  world name completion.  

  To use them, type part of a word, type one of the keybindings, and the rest 
  of the word will be filled in for you automagically.  ESC TAB attempts to 
  figure out from context what kind of completion you want; the other bindings 
  do more explicit completions.  

  By "from context", I mean it will look for patterns and decide which type of 
  completion to use.  For example, if the line begins with "[1m/load[22;0m", it will 
  use filename completion; if the word begins with "%" or "%{", it will use 
  [1mvariable[22;0m name completion; etc.  

  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: [1m/bind[22;0m, [1mtfrc[22;0m 

&copy
&warranty
&copying
&copyright

copyright

  TinyFugue - programmable mud client
  Copyright (C) 1993 - 1999 Ken Keys 

  Regexp package is Copyright (C) 1986 by University of Toronto.  

  For bug reports, questions, suggestions, etc., I can be reached by email at 
  hawkeye@tf.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/~hawkeye/tf/[22;0m for the latest info on TF.  

&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 

&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
#integer
#string
#hours:minutes:seconds
#hours:minutes
#hh:mm
#hh:mm:ss
#operands
Operands
  Operands can be any of: 

    * Integer constants like 42.  
    * Floating point constants ("floats", for short) containing a decimal 
      point (12.3) or exponent (1e-2) or both (1.2e3).  
    * Time values of the form <[4mhours[24m>:<[4mminutes[24m> or 
      <[4mhours[24m>:<[4mminutes[24m>:<[4mseconds[24m> (will be converted to integer seconds, and 
      can be used anywhere integers are expected).  
    * 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 wrapsize.  
    * [1mVariable substitutions[22;0m (see below) like {wrapsize} 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 and [4mm[24m for numeric (integer or float), [4ms[24m and [4mt[24m for string.  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; but if either operand is a float, the other will be converted 
  to float if it is not already a float, and the result will be a float.  

  ([4mexpression[24m) 
          Parentheses, for grouping.  

  [4mfn[24m([4margs[24m) 
          Perform [1mfunction[22;0m <[4mfn[24m> on <[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     Adds 1 to variable [4mv[24m and returns its new value.  
  --[4mv[24m     Subtracts 1 from variable [4mv[24m and returns its new value.  

  [4mn[24m * [4mm[24m   Numeric multiplication.  
  [4mn[24m / [4mm[24m   Numeric division.  

  [4mn[24m + [4mm[24m   Numeric addition.  
  [4mn[24m - [4mm[24m   Numeric subtraction.  

  [4mn[24m = [4mm[24m   Numeric equality.  
  [4mn[24m == [4mm[24m  Numeric equality.  
  [4mn[24m != [4mm[24m  Numeric inequality.  
  [4ms[24m =~ [4mt[24m  String equality (case sensitive).  
  [4ms[24m !~ [4mt[24m  String inequality (case sensitive).  
  [4ms[24m =/ [4mt[24m  String [4ms[24m matches [1mglob[22;0m pattern [4mt[24m.  
  [4ms[24m !/ [4mt[24m  String [4ms[24m does not match [1mglob[22;0m pattern [4mt[24m.  
  [4mn[24m < [4mm[24m   Numeric less than.  
  [4mn[24m <= [4mm[24m  Numeric less than or equal.  
  [4mn[24m > [4mm[24m   Numeric greater than.  
  [4mn[24m >= [4mm[24m  Numeric greater than or equal.  

  [4mn[24m & [4mm[24m   Boolean AND.  [4mm[24m will be evaluated if and only if [4mn[24m is true.  

  [4mn[24m | [4mm[24m   Boolean OR.  [4mm[24m will be evaluated if and only if [4mn[24m is false.  

  [4mn[24m ? [4ma[24m : [4mb[24m 
  [4mn[24m ? : [4mb[24m 
          Conditional.  If [4mn[24m is nonzero, the result is the value of [1mexpression[22;0m 
          [4ma[24m; otherwise it is the value of [1mexpression[22;0m [4mb[24m.  If [4ma[24m is omitted, the 
          value of [4mn[24m is used in its place.  

  [4mv[24m := [4ms[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.  

  [4ma[24m , [4mb[24m   Comma.  [1mExpressions[22;0m [4ma[24m and [4mb[24m are evaluated; the result is the 
          value of [4mb[24m.  Only useful if [4ma[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.  
#

  All operands will be automatically converted to the type expected by the 
  operator.  

    * Integer to boolean: 0 is false, nonzero is true.  
    * Other to boolean: converted to integer, then to boolean.  
    * String to numeric: leading signs, digits, and exponents are 
      interpreted as a numeric value; e.g., "12abc" becomes 12, "12.3junk" 
      becomes 12.3, and "xyz" becomes 0.  
    * Integer to float: straightforward.  
    * Integer to string: straightforward.  
    * Float to integer: the fractional part is truncated.  
    * Float to string: decimal notation if the exponent is greater than -5 
      and less than 10, otherwise exponential notation.  
    * [1mEnumerated variable[22;0m to string: straightforward string value.  
    * [1mEnumerated variable[22;0m to integer: 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').  
    * Other (non-enumerated) [1mvariables[22;0m are treated as strings, which are 
      converted to another type if needed.  

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 /usrs/bob/macros.tf.  

  "~user" expansion is not supported on systems that do not have the 
  getpwnam() function.  

&function
&functions

functions

  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.  

  In the following list of builtin functions, arguments <[4ms[24m> and <[4mt[24m> are any 
  string value, <[4mi[24m> and <[4mj[24m> are any integer value, <[4mx[24m> and <[4my[24m> are any float 
  value, and <[4mf[24m> is a flag value (0 or "off"; or, 1 or "on").  

Mathematical functions
  Angles are in radians.  

#abs
#abs()
  [1mabs[22m([4mi[24m)  (int) Absolute value of <[4mi[24m>.  
  [1mabs[22m([4mx[24m)  (float) Absolute value of <[4mx[24m>.  
#sin
#sin()
  [1msin[22m([4mx[24m)  (float) Sine of <[4mx[24m>.  
#cos
#cos()
  [1mcos[22m([4mx[24m)  (float) Cosine of <[4mx[24m>.  
#tan
#tan()
  [1mtan[22m([4mx[24m)  (float) Tangent of <[4mx[24m>.  
#asin
#asin()
  [1masin[22m([4mx[24m) 
          (float) Arcsine of <[4mx[24m>, in the range [-pi/2, pi/2].  <[4mx[24m> must be in 
          the domain [-1, 1].  
#acos
#acos()
  [1macos[22m([4mx[24m) 
          (float) Arccosine of <[4mx[24m>, in the range [0, pi].  <[4mx[24m> must be in the 
          domain [-1, 1].  
#atan
#atan()
  [1matan[22m([4mx[24m) 
          (float) Arctangent of <[4mx[24m>, in the range [-pi/2, pi/2].  
#exp
#exp()
  [1mexp[22m([4mx[24m)  (float) [4me[24m raised to the power <[4mx[24m>.  
#pow
#pow()
  [1mpow[22m([4mx[24m, [4my[24m) 
          (float) <[4mx[24m> raised to the power <[4my[24m>.  If <[4mx[24m> is negative, <[4my[24m> must 
          be an integer.  
#sqrt
#sqrt()
  [1msqrt[22m([4mx[24m) 
          (float) Square root of <[4mx[24m> (same as [1mpow[22;0m(<[4mx[24m>, 0.5)).  
#log
#log()
#log10
#log10()
  [1mlog[22m([4mx[24m)  (float) Natural logarithm of <[4mx[24m>.  <[4mx[24m> must be positive.  
          The base B logarithm of any number N can be found with the 
          expression [1mlog[22;0m(N) / [1mlog[22;0m(B).  
  [1mlog10[22m([4mx[24m) 
          (float) Base 10 logarithm of <[4mx[24m>.  <[4mx[24m> must be positive.  
#mod
#mod()
  [1mmod[22m([4mi[24m,[4mj[24m) 
          (int) Remainder of <[4mi[24m> divided by <[4mj[24m>.  
#trunc
#trunc()
  [1mtrunc[22m([4mx[24m) 
          (int) Integer part of <[4mx[24m>.  
#rand
#rand()
  [1mrand[22m()  (int) Random number in the range [0, system maximum].  
  [1mrand[22m([4mj[24m) 
          (int) Random number in the range [0, <[4mj[24m> - 1].  
  [1mrand[22m([4mi[24m,[4mj[24m) 
          (int) Random number in the range [<[4mi[24m>, <[4mj[24m>].  
#

Input/output functions

#
  [1mecho[22m([4ms[24m [,[4mattrs[24m [,[4mdest[24m [,[4minline[24m]]]) 
          (int) Echoes <[4ms[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".  
#send
#send()
  [1msend[22m([4ms[24m, [4mt[24m, [4mf[24m) 
          (int) Sends string <[4ms[24m> to world <[4mt[24m>, or the [1mcurrent[22;0m world if <[4mworld[24m> 
          is blank.  An end-of-line will be appended if <[4mf[24m> is 1 or "on".  
  [1msend[22m([4ms[24m, [4mt[24m) 
          Equivalent to [1msend[22;0m([4ms[24m, <[4mt[24m>, 1).  
  [1msend[22m([4ms[24m) 
          Equivalent to [1msend[22;0m(<[4ms[24m>, "", 1).  
#fwrite
#fwrite()
  [1mfwrite[22m([4ms[24m,[4mt[24m) 
          Writes string <[4mt[24m> to the end of file <[4ms[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.  
#tfopen
#tfopen()
  [1mtfopen[22m([4ms[24m, [4mt[24m) 
  [1mtfopen[22m() 
          (int) Open a [1mtfio stream[22;0m using file <[4ms[24m> and mode <[4mt[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) 
          (str) Convert all characters in <[4ms[24m> to lower case.  
#toupper
#toupper()
  [1mtoupper[22m([4ms[24m) 
          (str) Convert 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([4ms[24m, [4mt[24m) 
          (int) Returns 1 if string <[4mt[24m> matches [1mregexp[22;0m <[4ms[24m>, otherwise returns 
          0.  Subexpressions can later be extracted using the P[4mn[24m [1mvariables[22;0m or 
          [1m%P[4mn[24m[22;0m substitutions.  Warning: [1mregmatch()[22;0m is much less efficient than 
          the =/ [1moperator[22;0m (their difference in efficiency is even greater than 
          that between [1mregexp[22;0m and [1mglob[22;0m [1mtriggers[22;0m).  (See also: [1mregexp[22;0m) 
#strcat
#strcat()
  [1mstrcat[22m(...) 
          (str) Join strings (takes any number of string arguments).  
#strchr
#strchr()
  [1mstrchr[22m([4ms[24m, [4mt[24m) 
          (int) First position within <[4ms[24m> of any character contained in <[4mt[24m>, 
          or -1 if <[4ms[24m> does not contain any characters from <[4mt[24m>.  
#strcmp
#strcmp()
  [1mstrcmp[22m([4ms[24m, [4mt[24m) 
          (int) Returns a number less than, equal to, or greater than 0 if <[4ms[24m> 
          is lexicographically less than, equal to, or greater than <[4mt[24m>, 
          respectively.  
#strlen
#strlen()
  [1mstrlen[22m([4ms[24m) 
          (int) Length of string <[4ms[24m>.  
#strncmp
#strncmp()
  [1mstrncmp[22m([4ms[24m, [4mt[24m, [4mi[24m) 
          (int) Like [1mstrcmp()[22;0m, but compares only the first <[4mi[24m> characters of 
          <[4ms[24m> and <[4mt[24m>.  
#strrchr
#strrchr()
  [1mstrrchr[22m([4ms[24m, [4mt[24m) 
          (int) Last position within <[4ms[24m> of any character contained in <[4mt[24m>, or 
          -1 if <[4ms[24m> does not contain any characters from <[4mt[24m>.  
#strrep
#strrep()
  [1mstrrep[22m([4ms[24m, [4mi[24m) 
          (str) Returns a string containing <[4mi[24m> repetitions of <[4ms[24m>.  
#strstr
#strstr()
  [1mstrstr[22m([4ms[24m, [4mt[24m) 
          (int) First position of <[4mt[24m> within <[4ms[24m>, or -1 if <[4ms[24m> does not 
          contain <[4mt[24m>.  
#substr
#substr()
  [1msubstr[22m([4ms[24m, [4mi[24m) 
  [1msubstr[22m([4ms[24m, [4mi[24m, [4mj[24m) 
          (str) Substring of <[4ms[24m>, starting at position <[4mi[24m>, with length <[4mj[24m>.  
          If <[4mj[24m> is omitted, it defaults to the remaining length of <[4ms[24m>.  If 
          <[4mi[24m> or <[4mj[24m> is negative, they are counted as absolute values from the 
          end of <[4ms[24m>.  
#

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()  (int) System time (typically seconds since 1970-01-01 
          00:00:00 UTC).  See also: [1m/time[22;0m, [1mftime()[22;0m.  
#columns
#columns()
  [1mcolumns[22m() 
          (int) Number of columns on the screen.  See also: [1mhooks (RESIZE)[22;0m, 
          [1mlines()[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 the expression ([1mlines()[22;0m - ([1mvisual[22;0m ? [1misize[22;0m+1 : 
          0)).  See also: [1mhooks (RESIZE)[22;0m, [1mcolumns()[22;0m, [1m%LINES[22;0m.  
#morescroll
#morescroll()
  [1mmorescroll[22m([4mi[24m) 
          (int) If at a [1mmore[22;0m prompt, this function displays up to the next <[4mi[24m> 
          lines of text, and returns 1.  Otherwise, it does nothing, and 
          returns 0.  
#moresize
#moresize()
  [1mmoresize[22m() 
          (int) Number of lines queued at a [1mmore[22;0m prompt.  
#world_info
#world_info()
  [1mworld_info[22m([4ms[24m, [4mt[24m) 
          (str) Return the value of field <[4mt[24m> of world <[4ms[24m>, 
  [1mworld_info[22m([4mt[24m) 
          (str) Return the value of field <[4mt[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.  
#idle
#idle()
  [1midle[22m()  (int) Number of seconds since the last keypress.  
  [1midle[22m([4ms[24m) 
          (int) Number of seconds 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) 
          (int) Number of seconds 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.  
#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).  
#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", "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".  
#filename
#filename()
  [1mfilename[22m([4ms[24m) 
          (str) Performs filename expansion on <[4ms[24m> as described under 
          "[1mfilenames[22;0m".  
  [1mftime[22m([4ms[24m,[4mi[24m) 
          (str) Formats a system time <[4mi[24m> (obtained from [1mtime()[22;0m) according to 
          format <[4ms[24m>.  See: [1mftime()[22;0m.  
#
  [1mgetopts[22m([4ms[24m, [4mt[24m) 
          (int) Parse macro options according to format <[4ms[24m>.  See "[1mgetopts()[22;0m". 
#
  [1msubstitute[22m([4ms[24m [,[4mattrs[24m [,[4minline[24m]]) 
          (int) Replaces trigger text.  See "[1m/substitute[22;0m".  
#

#macro
#function syntax

  [1mMacros[22;0m and builtin commands can be called using function syntax, unless 
  there is a builtin function with the same name.  The syntax is "[4mname[24m([4marg1[24m, 
  [4marg2[24m, ...  [4margN[24m)".  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."

  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, assuming "spam" is a macro, the function call 
  spam("foo", "bar", "baz")

  is the same as 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.  
#

  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)").  

  Examples: 

  Capitalize first letter of string <[4ms[24m>: 

        [1mstrcat[22;0m([1mtoupper[22;0m([1msubstr[22;0m(s, 0, 1)), [1msubstr[22;0m(s, 1))

  Extract the number from a string <[4mdbref[24m> 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, and if a letter is followed by "#" the 
  option will be expected to have a numeric argument.  The option syntax 
  accepted by [1mgetopts()[22;0m is the same as 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("abns:", "")) [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'

  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 ';' 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 it 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}".  

    * Debugging: "[1m/set[22;0m [1mpedantic[22;0m=on" to make tf generate warnings about 
      some potential problems.  "[1m/set[22;0m [1mmecho[22;0m=on" to see what commands are being 
      executed, or "[1m/connect[22;0m localhost echo" 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.  

&scrollback
&history

history

  Associated commands: 

  [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 [1msocket[22;0m text.  [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 to the [1mtferr stream[22;0m (i.e., the screen) 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.  

      Event Name  Arguments       Default Message or Action
      ----------  ---------       -------------------------
#ACTIVITY
      ACTIVITY    world           '% Activity in world <[4mworld[24m>'
                                  (called only the first time activity
                                  occurs on a given [1msocket[22;0m.)
#BACKGROUND
      BACKGROUND  world           '% [1mTrigger[22;0m in world <[4mworld[24m>'
#BAMF
      BAMF        world           '% [1mBamfing[22;0m to <[4mworld[24m>'
#CONFAIL
      CONFAIL     world, reason   '% [1mConnection[22;0m to <[4mworld[24m> failed: <[4mreason[24m>'
#CONFLICT
      CONFLICT    [1mmacro[22;0m           '% <[4mmacro[24m> conflicts with builtin command.'
#CONNECT
      CONNECT     world           '% [1mConnection[22;0m to <[4mworld[24m> established.'
#DISCONNECT
      DISCONNECT  world, reason   '% [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            '% You have new mail in <[4mfile[24m>.'
#MORE
      MORE                        '[1m--More--[22;0m' (reverse bold)
#NOMACRO
      NOMACRO     name            '% <[4mname[24m>: No such command or macro'
#PENDING
      PENDING     world           '% Hostname resolution for <[4mworld[24m> in progress'
      PENDING     world           '% [1mConnection[22;0m to <[4mworld[24m> in progress'
#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>'
#SIGWINCH
#RESIZE
      RESIZE      columns, lines  (window was resized)
                                  (see also: [1mcolumns()[22;0m, [1mlines()[22;0m)
#RESUME
      RESUME                      '% Resuming TinyFugue'
#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 terminates)
#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           '---- World <[4mworld[24m> ----'
#

  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.  

  BACKGROUND's "% 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 
  -hBACKGROUND".  

  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.  SEND [1mhooks[22;0m are never called from [1msend()[22;0m, but they can be called 
  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 this is not a [1mproxy[22;0m 
  connection, the CONNECT [1mhook[22;0m is called; 3) 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.  4) If there is a file associated with the world, the file will 
  be loaded (and the LOAD [1mhook[22;0m will be called).  

  The message for the CONNECT [1mhook[22;0m is displayed only if the connection was 
  pending.  The standard library defines a default CONNECT [1mhook[22;0m to [1m/fg[22;0m the 
  [1msocket[22;0m, which in turn calls the WORLD [1mhook[22;0m; define your own CONNECT [1mhook[22;0m if 
  you want to override this automatic [1m/fg[22;0m.  

  The SIGHUP, SIGTERM, SIGUSR1, and SIGUSR2 [1mhooks[22;0m are called when the 
  corresponding [1msignal[22;0m is received.  For SIGHUP and SIGTERM, 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.  

  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.  

  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      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
    [1mprotocol[22;0m      LP/Diku prompt protocol
    [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
   *[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.  

  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.  

  In [1mvisual mode[22;0m, 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.  To 
  use it, just type "[1m/visual[22;0m on".  See: [1m%visual[22;0m, [1mmode[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
&kbbind
&kbfunc
&kbfunc.tf
&kbbind.tf
&keybindings

keybindings

Binding keys
  [1m/Def[22;0m [1m-b[22;0m allows you to bind a character string to a [1mmacro[22;0m.  Typing that 
  string at the keyboard (which may mean pressing a single key that generates 
  the string) will then call the [1mmacro[22;0m.  

  [1m/Def[22;0m [1m-B[22;0m allows you to bind a symbolic keyname to a [1mmacro[22;0m.  There are several 
  advantages in using symbolic key names over key code strings.  First, you 
  don't have to know what string is generated by the special keys on your 
  keyboard.  They will work on multiple terminals, based on the value of [1m%TERM[22;0m 
  (assuming the keys are defined in the termcap database).  Changing [1m%TERM[22;0m at 
  any time will rebind the [1mmacros[22;0m to the new codes.  

  The keynames recognized by tf are: 

    * Function keys: F0, F1,...  F19 
    * Keypad keys: KP1 (upper left), KP2 (upper right), KP3 (center), KP4 
      (lower left), KP5 (lower right).  (It may be necessary to turn Num Lock 
      off to enable these.) 
    * Arrow keys: Up, Down, Right, Left 
    * others: Backspace, Clear EOL, Clear EOS, Clear Screen, Delete, 
      Delete Line, Home, Home Down, Insert, Insert Line, PgDn, PgUp, Scroll 
      Down, Scroll Up 

  Unfortunately, even if your terminal has a particular key, your termcap 
  entries may not define it, so you may not be able to use it by name.  The 
  arrow and function are pretty reliably defined, but many of the other keys 
  are not.  Also, terminal emulators often do not match all the key 
  definitions.  

  They must be spelled as shown, but capitalization is ignored.  The function 
  [1mkeycode()[22;0m can be used to find the string generated by a key (as defined in 
  the termcap entry for [1m%TERM[22;0m).  

  Because [1mTF[22m runs in a terminal and not in a windowing system, it does not see 
  actual keystrokes, but only the characters generated by a keystroke.  If two 
  different keys generate the same characters, [1mTF[22m can not tell them apart.  In 
  earlier versions, this meant that on many terminals [1mTF[22m could not distinguish 
  the numeric keypad keys from arrow or digit keys, because they generated the 
  same character sequences.  Starting in 4.0 alpha 11, [1mTF[22m tries to put the 
  keypad in "application mode", which on many terminals will make the keypad 
  keys generate unique character sequences if Num Lock is on.  

  Note that before version 3.5 alpha 21 or beta 1, it was usually harmless to 
  "[1m/set[22;0m [1mTERM[22;0m=vt100" on terminals that accepted a superset of vt100 display 
  codes.  However, the termcap key definitions are often different for 
  terminals that are otherwise similar (e.g., vt100 and xterm share many 
  display codes, but the key definitions are different), so setting [1m%TERM[22;0m 
  incorrectly will interfere with the operation of named keys.  Xterm users 
  should also note that since 3.5 alpha 17, tf ignores xterm's ti and te 
  capabilities that sometimes interfered with the operation of the scrollbar, 
  so tricking tf with [1mTERM[22;0m=vt100 is no longer necessary.  

Special keys
  TF's input handler recognizes ^H and ^? as backspace and ^J and ^M as 
  newline, even when they are not bound to [1mmacros[22;0m.  However, if a keybinding 
  is defined for any of these keys, it will override the internal handling of 
  that key.  

  At [1mstartup[22;0m, tf also examines the terminal driver settings for keys 
  corresponding to the [1m/dokey[22;0m functions BWORD, DLINE, REFRESH, and LNEXT, and 
  binds them accordingly if different than the default bindings listed below.  

Default keybindings
  Named keys 

  Key     Command                 Meaning
  ---     -------                 -------
  Up      [1m/dokey[22;0m UP               cursor up
  Down    [1m/dokey[22;0m DOWN             cursor down
  Right   [1m/dokey[22;0m RIGHT            cursor right
  Left    [1m/dokey[22;0m LEFT             cursor left
  F1      [1m/help[22;0m                   help
  Insert  [1m/test[22;0m [1minsert[22;0m:=![1minsert[22;0m   toggle [1minsert[22;0m mode
  Home    [1m/dokey_home[22;0m             cursor to beginning of line
  PgDn    [1m/dokey[22;0m page             scroll 1 screenful at [1m--More--[22;0m prompt

  Unnamed key sequences 

  String  Command                 Meaning
  ------  -------                 -------
  "^A"    [1m/dokey_home[22;0m             cursor to beginning of line
  "^B"    [1m/dokey_wleft[22;0m            cursor to beginning of word
  "^D"    [1m/dokey_dch[22;0m              delete character
  "^E"    [1m/dokey_end[22;0m              cursor to end of line
  "^F"    [1m/dokey_wright[22;0m           cursor to end of word
  "^G"    [1m/beep[22;0m 1                 beep
  "^I"    [1m/dokey[22;0m page             scroll 1 screenful at [1m--More--[22;0m prompt
  "^J"    [1m/dokey[22;0m NEWLINE          execute current line
  "^K"    [1m/dokey_deol[22;0m             delete to end of line
  "^L"    [1m/dokey[22;0m redraw           redraw screen
  "^M"    [1m/dokey[22;0m NEWLINE          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
  "^R"    [1m/dokey[22;0m REFRESH          refresh line
  "^T"    [1m/kb_transpose_chars[22;0m     transpose characters
  "^U"    [1m/dokey[22;0m DLINE            delete line
  "^V"    [1m/dokey[22;0m LNEXT            input next key literally
  "^W"    [1m/dokey[22;0m BWORD            delete backward word (space-delimited)
  "^[^E"  [1m/kb_expand_line[22;0m         [1mexpand[22;0m current line in place
  "^[ "   [1m/kb_collapse_space[22;0m      change multiple spaces to a single space
  "^[-"   [1m/kb_goto_match[22;0m          move cursor to matching parenthesis/bracket
  "^[."   [1m/kb_last_argument[22;0m       input last word of previous line
  "^[J"   [1m/dokey[22;0m selflush         selective flush (flush non-[1mhilite[22;0md text)
  "^[_"   [1m/kb_last_argument[22;0m       input last word of previous line
  "^[b"   [1m/fg[22;0m -<                  [1mforeground[22;0m previous [1msocket[22;0m
  "^[c"   [1m/kb_capitalize_word[22;0m     capitalize word
  "^[d"   [1m/dokey_dword[22;0m            delete forward word
  "^[f"   [1m/fg[22;0m ->                  [1mforeground[22;0m next [1msocket[22;0m
  "^[h"   [1m/dokey[22;0m hpage            scroll half screenful at [1m--More--[22;0m prompt
  "^[j"   [1m/dokey[22;0m flush            flush (discard text after [1m--More--[22;0m prompt)
  "^[l"   [1m/kb_downcase_word[22;0m       downcase word
  "^[n"   [1m/dokey[22;0m searchf          search forward input [1mhistory[22;0m
  "^[p"   [1m/dokey[22;0m searchb          search backward input [1mhistory[22;0m
  "^[u"   [1m/kb_upcase_word[22;0m         upcase word
  "^[v"   [1m/test[22;0m insert:=!insert   toggle insert mode
  "^[^?"  [1m/kb_backward_kill_word[22;0m  delete backward word (punctuation-delimited)

Terminal keys
  Some keys are interpeted by the terminal, not TF, so if you want to change 
  them, you must do so outside of TF (e.g.  with stty in unix).  Typical unix 
  terminal keys include: 

  ^S      "stop" - stops terminal output.  
  ^Q      "start" - restart terminal output after a "stop".  
  ^C      "int" - generates a SIGINT [1msignal[22;0m.  
  ^\      "quit" - generates a SIGQUIT [1msignal[22;0m.  
  ^Z      "susp" - suspends the process 

Other key bindings
#kbstack.tf
#kb-bash.tf
#kb-emacs.tf
#kbregion.tf
#cut
#paste
#cut and paste
#bash
#emacs
#extra keybindings
  Some additional keyboard operations can be defined by [1m/load[22;0ming these library 
  files: 

  kb-bash.tf 
          keybindings like those in bash 
  kb-emacs.tf 
          keybindings like those in emacs 
  kbregion.tf 
          cut-and-paste operations 
  kbstack.tf 
          save the current line with ESC-DOWN and recall it later with ESC-UP. 

  See the comments at the top of each file for further documentation.  

#
  See: [1m/dokey[22;0m, [1m/bind[22;0m, [1mcompletion[22;0m, [1m%wordpunct[22;0m, [1msignals[22;0m.  

&stdlib.tf
&local.tf
&lib
&library
&library
&standard library

standard library

  When [1mTF[22;0m is started, commands are loaded from the standard library 
  ([1m%{TFLIBDIR}[22;0m/stdlib.tf).  If the installer has created an optional local 
  library ([1m%{TFLIBDIR}[22;0m/local.tf), that will also be loaded.  [1mMacros[22;0m defined in 
  the standard library are marked with the invisible option ("[1m-i[22;0m") so they 
  will not be processed by [1m/list[22;0m, [1m/save[22;0m and [1m/purge[22;0m unless forced.  Redefining 
  or undefining such a [1mmacro[22;0m will clear the [1m-i[22;0m option, so customized [1mmacros[22;0m 
  with the same names as library [1mmacros[22;0m can be created, listed, saved, and 
  purged.  

  See also: [1mutilities[22;0m 

#filename macros
Filenames:

  These [1mmacros[22;0m may be redefined to any filename.  LOGFILE contains the default 
  filename used by [1m/log[22;0m.  MACROFILE, HILITEFILE, GAGFILE, TRIGFILE, BINDFILE, 
  HOOKFILE, and WORLDFILE contain the default filenames used by the [1m/load[22;0m* and 
  [1m/save[22;0m* families of commands.  
#

#list*
List commands:

  [1m/listdef[22;0m <[4mspec[24m> 
          equivalent to '[1m/list[22;0m <[4mspec[24m>'.  
  [1m/listhilite[22;0m <[4mspec[24m> 
          lists [1mhilite[22;0ms on <[4mspec[24m>.  
  [1m/listgag[22;0m <[4mspec[24m> 
          lists [1mgag[22;0ms on <[4mspec[24m>.  
  [1m/listtrig[22;0m <[4mspec[24m> 
          lists [1mtriggers[22;0m on <[4mspec[24m>.  
  [1m/listbind[22;0m <[4mspec[24m> 
          lists key bindings matching <[4mspec[24m> 
  [1m/listhook[22;0m <[4mspec[24m> 
          lists [1mhooks[22;0m matching <[4mspec[24m>.  

  See: [1m/list[22;0m 

#purge*
Purge commands:

  [1m/purgedef[22;0m <[4mspec[24m> 
          purges [1mmacros[22;0m whose name matches <[4mspec[24m> 
  [1m/purgehilite[22;0m <[4mspec[24m> 
          purges [1mmacros[22;0m with [1mhilite[22;0ms on <[4mspec[24m> 
  [1m/purgegag[22;0m <[4mspec[24m> 
          purges [1mmacros[22;0m with [1mgag[22;0ms on <[4mspec[24m> 
  [1m/purgetrig[22;0m <[4mspec[24m> 
          purges [1mmacros[22;0m with [1mtriggers[22;0m on <[4mspec[24m> 
  [1m/purgedeft[22;0m <[4mspec[24m> 
          purges named [1mmacros[22;0m with [1mtriggers[22;0m on <[4mspec[24m> 
  [1m/purgebind[22;0m <[4mspec[24m> 
          purges key bindings matching <[4mspec[24m>.  
  [1m/purgehook[22;0m <[4mspec[24m> 
          purges [1mhooks[22;0m matching <[4mspec[24m>.  

  See: [1m/purge[22;0m 

#load*
Load commands:

  [1m/loaddef[22;0m, [1m/loadhilite[22;0m, [1m/loadgag[22;0m, [1m/loadtrig[22;0m, [1m/loadbind[22;0m, [1m/loadhook[22;0m, 
  [1m/loadworld[22;0m.  All take a <[4mfile[24m> argument; if the argument is omitted, the 
  appropriate default [1mfilename macro[22;0m is used.  

  See: [1m/load[22;0m 

#save*
Save commands:

  [1m/savedef[22;0m, [1m/savehilite[22;0m, [1m/savegag[22;0m, [1m/savetrig[22;0m, [1m/savebind[22;0m, [1m/savehook[22;0m, 
  [1m/saveworld[22;0m.  All take a <[4mfile[24m> argument.  If <[4mfile[24m> is omitted, the 
  appropriate default [1mfilename macro[22;0m is used.  

  See: [1m/save[22;0m 

#compress
#COMPRESS_READ
#$COMPRESS_READ
#COMPRESS_SUFFIX
#$COMPRESS_SUFFIX
#compression
File compression:

  The helpfile, personal config file, and files read with [1m/load[22;0m may be stored 
  compressed on disk.  If TF can not find a file with the specified name, it 
  will add ${COMPRESS_SUFFIX} to the filename and try to read it by piping it 
  through ${COMPRESS_READ}.  ${COMPRESS_READ} should contain the name of a 
  shell command that takes a filename as an argument, and prints its output on 
  standard output.  The default values for ${COMPRESS_SUFFIX} and 
  ${COMPRESS_READ} defined in the library are ".Z" and "zcat" for unix, ".zip" 
  and "unzip -p" for os/2.  Undefining ${COMPRESS_SUFFIX} will disable this 
  feature.  Note: [1m/save[22;0m, [1m/saveworld[22;0m, and [1m/log[22;0m do not write compressed files.  

#retry
World connection commands:

  [1m/retry[22;0m <[4mworld[24m> [<[4mdelay[24m>] 
          Try to connect to <[4mworld[24m>; repeat every <[4mdelay[24m> seconds until 
          successful.  
  [1m/retry_off[22;0m [<[4mworld[24m>] 
          Cancels "[1m/retry[22;0m <[4mworld[24m>" (default: all worlds) 

#hilite_whisper
#hilite whisper
#hilite_page
#hilite page
Hilite commands:

  [1m/hilite_whisper[22;0m, [1m/hilite_page[22;0m, [1m/nohilite_whisper[22;0m, and [1m/nohilite_page[22;0m turn on 
  or off [1mhiliting[22;0m several different page and whisper formats.  

#
Backward compatible commands:

  [1m/reply[22;0m, [1m/act[22;0m, [1m/nolog[22;0m, [1m/nologin[22;0m, [1m/nologme[22;0m, [1m/noquiet[22;0m, and [1m/nowrap[22;0m are provided 
  for compatibility.  

&8-bit
&international
&i18n
&internationalization
&internationalisation
&locale

locale

  A locale defines a set of rules for a language and culture.  If the platform 
  on which TF runs supports locales, TF will support the following categories 
  of locale rules: 

  LC_CTYPE 
          determines what characters are allowed, and whether they should be 
          treated as letters, digits, puctuation, or control characters.  When 
          using a locale with an 8-bit character set, make sure that TF's 
          [1mistrip[22;0m variable is off.  
  LC_TIME 
          determines the names and formats used in displaying dates and times 
          with [1m/time[22;0m, [1mftime()[22;0m, etc.  

  The user can set the locale either by having special variables defined in 
  the environment before starting TF (preferred), or by setting them while TF 
  is running (they will automatically be exported to the environment even if 
  [1m/set[22;0m is used).  The exact rules for setting locale depend on the platform, 
  and should be found your system's documentation for setlocale().  The rules 
  are usually something like this: 

    * If the variable [1mLC_ALL[22;0m is set, its value is used as the locale for 
      all supported categories.  
    * Otherwise, if the variable with the name of a category is set, its 
      value is used as the locale for that category.  
    * Otherwise, if the variable [1mLANG[22;0m is set, its value is used as the 
      locale for any supported categories that were not covered by the first 
      two rules.  
    * If none of those are set for a category, the default "C" locale is 
      used for that category, which allows the 7-bit ASCII character set and 
      US English date and time formats.  

  The valid values for the locale variables depend on your system.  On a POSIX 
  system, the valid values can be listed with the shell command "locale -a".  

  Bugs: 

    * LC_COLLATE and LC_MESSAGES categories are not supported.  
    * In glob and regexp [1mpatterns[22;0m, there is no way to specify a range of 
      all letters that works in all locales.  E.g., "[A-Za-z]" works in the 
      standard "C" locale, but not necessarily in others.  
    * TF will convert character 0x80 to the character 0x00.  This is not 
      usually an issue, since character 0x80 is not a printable character in 
      the character sets of most locales (including all ISO character sets).  

  If your system has locale support, but does not have any locales installed, 
  you can get the POSIX 1003.2 WG15-collection locale definitions from 
  [1mftp://dkuug.dk/i18n/[22;0m or [1mftp://i44ftp.info.uni-karlsruhe.de/pub/linux/ctype/[22;0m. 

  Note to linux users and other users of GNU libc: at least some versions of 
  GNU localedef generate invalid LC_TIME information from the WG15-collection 
  sources, and the GNU libc causes any program that tries to use the invalid 
  LC_TIME information to crash.  Workarounds: delete the LC_TIME data; or, do 
  not set any of the LC_ALL, LC_TIME, or LANG variables.  

&autologin
&login

login

  If the [1m%{login}[22;0m flag is on when you [1mconnect[22;0m to a world, and that world was 
  [1mdefined[22;0m with a character, password, and optional worldtype, TF will attempt 
  to automatically [1mlogin[22;0m to that world.  

  [1mAutologin[22;0m is done by a [1mhook[22;0m defined in the [1mstandard library[22;0m.  The [1mhook[22;0m for 
  the default worldtype uses TinyMUD [1mlogin[22;0m format; there are also [1mhooks[22;0m for 
  "tiny", "lp", "lpp", and "telnet" worldtypes.  You can also define your own 
  LOGIN [1mhooks[22;0m.  

  See: [1mhooks[22;0m, [1mvariables[22;0m, [1m/addworld[22;0m 

&macros

macros

  The simplest kind of [1mmacro[22;0m has a name and a body.  The body is a list of one 
  or more commands, separated by '%;' tokens.  These commands are executed 
  when the [1mmacro[22;0m is called.  For example, if you define a [1mmacro[22;0m like 

      [1m/def[22;0m time_warp = :jumps to the left!%;:steps to the right!

  and call it by typing 

      /time_warp

  you will execute the commands 

      :jumps to the left!
      :steps to the right!

  A [1mmacro[22;0m name is the way of calling it from the command line or from another 
  [1mmacro[22;0m.  You can execute a [1mmacro[22;0m by typing '/' followed by the name of the 
  [1mmacro[22;0m.  If a [1mmacro[22;0m and builtin have the same name, the [1mmacro[22;0m will be called. 
  Typing '/@' followed by the name will always call the builtin command.  

  A [1mmacro[22;0m body, or execution text, is the commands and/or text executed when 
  the [1mmacro[22;0m is called.  This text is evaluated according to the rules 
  described under "[1mevaluation[22;0m".  

  [1mMacros[22;0m actually have many more fields, described below.  All fields 
  (including name and body) are optional.  

  name    The name of the [1mmacro[22;0m.  Names should begin with a letter, 
          and contain letters, numbers, or '_' characters.  

  body    One or more commands to be executed when [1mmacro[22;0m is called.  

  number  All [1mmacros[22;0m are automatically numbered sequentially.  This 
          field can not be changed.  

  trigger 
          when text matches the [1mtrigger[22;0m pattern, the [1mmacro[22;0m may be called.  

  hook    the [1mmacro[22;0m can be called when a TF [1mhook[22;0m event occurs.  

  keybinding 
          the [1mmacro[22;0m will be called when its keybinding is typed.  

  shots   the [1mmacro[22;0m will be deleted after it is [1mtrigger[22;0med or [1mhook[22;0med a 
          certain number of times.  

  [1mpriority[22;0m 
          when multiple [1mtriggers[22;0m match the same text, the one with the highest 
          [1mpriority[22;0m is selected (see "[1mpriority[22;0m").  

  [1mfall-thru[22;0m 
          on a [1mtrigger[22;0m or [1mhook[22;0m, allows additional [1mmacros[22;0m of lower [1mpriority[22;0m to 
          be run (see "[1mpriority[22;0m").  

  world   the [1mmacro[22;0m can only be [1mtrigger[22;0med/[1mhook[22;0med by text/events from a 
          particular world.  

  worldtype 
          the [1mmacro[22;0m can only be [1mtrigger[22;0med/hooked by [1mtrigger[22;0med/[1mhook[22;0med by 
          text/events from a particular type of world.  

  expression 
          the [1mmacro[22;0m can only be [1mtrigger[22;0med/[1mhook[22;0med if [1mexpression[22;0m is non-zero.  

  attributes 
          bold, underline, etc.  for displaying [1mtrigger[22;0m text.  

  probability 
          when [1mtrigger[22;0med, the [1mmacro[22;0m has a certain probability of being 
          executed.  

  invisibility 
          prevents handling of [1mmacro[22;0m by [1m/list[22;0m, [1m/save[22;0m, or [1m/purge[22;0m.  

  [1mMacros[22;0m may be called in several ways: 

    * a command of the form "/[4mname[24m" or "/#[4mnumber[24m" 
    * triggered by text from a [1msocket[22;0m (see "[1mtriggers[22;0m") 
    * hooked by a tinyfugue event (see "[1mhooks[22;0m") 
    * by keybindings 

  Associated commands: 

  [1m/def[22;0m    define a named [1mmacro[22;0m, with any fields 
  [1m/trig[22;0m   define a [1mtrigger[22;0m [1mmacro[22;0m 
  [1m/hilite[22;0m 
          define a [1mhilite[22;0m [1mmacro[22;0m 
  [1m/gag[22;0m    define a [1mgag[22;0m [1mmacro[22;0m 
  [1m/bind[22;0m   define a keybinding [1mmacro[22;0m 
  [1m/hook[22;0m   define a [1mhook[22;0m [1mmacro[22;0m 
  [1m/undef[22;0m  undefine a named [1mmacro[22;0m 
  [1m/unhook[22;0m 
          undefine a [1mhook[22;0m [1mmacro[22;0m 
  [1m/unbind[22;0m 
          undefine a keybinding [1mmacro[22;0m 
  [1m/undefn[22;0m 
          undefine a [1mmacro[22;0m by number 
  [1m/undeft[22;0m 
          undefine a [1mmacro[22;0m by [1mtrigger[22;0m 
  [1m/purge[22;0m  undefine a set of [1mmacros[22;0m 
  [1m/list[22;0m   display a list of [1mmacros[22;0m 
  [1m/load[22;0m   load commands from a file 
  [1m/save[22;0m   save [1mmacro[22;0m definitions to a file 

  See also: [1mtriggers[22;0m, [1mgags[22;0m, [1mhilites[22;0m, [1mhooks[22;0m 

&mail
&mail check
&mail checking

mail checking

  If [1m%{maildelay}[22;0m is nonzero, TF will check for mail every [1m%{maildelay}[22;0m 
  seconds.  TF checks for mail in each file in the space-separated list of 
  files in the [1m%{TFMAILPATH}[22;0m [1mvariable[22;0m.  If [1m%{TFMAILPATH}[22;0m is not set, TF will 
  check in the single file named by the [1m%{MAIL}[22;0m [1mvariable[22;0m.  

  TF considers a mailfile to have unread mail if the file has been written 
  more recently than it has been read.  When this changes for any of the 
  monitored files, TF updates the mail indicator on the [1mstatus line[22;0m (actually, 
  the "@mail" [1mstatus[22;0m).  When TF determines that a mailfile contains new mail, 
  it calls the [1mMAIL hook[22;0m, which by default prints "You have new mail".  If a 
  mailfile is not empty the [4mfirst[24m time TF checks it, TF just prints "You have 
  mail" without calling the [1mMAIL hook[22;0m.  

  If an error occurs while checking any file, an error message will be 
  displayed only once, until that error clears up (or changes to a different 
  error), but TF will continue to check that file.  To disable checking, even 
  after an error, you must remove the file from [1m%{TFMAILPATH}[22;0m or [1m%{MAIL}[22;0m.  

  The [1mnmail()[22;0m [1mfunction[22;0m returns the number of monitored mail files containing 
  unread mail.  

  MAIL and/or MAILPATH variables are usually set in the environment before [1mTF[22;0m 
  starts.  If [1m%{MAIL}[22;0m is not set when TF starts, TF will try to set it to the 
  name of the system mail directory plus your user name (if the system mail 
  directory was defined when TF was installed).  If MAILPATH (which uses ":" 
  as a delimiter) is set when TF starts, it is transferred to [1m%{TFMAILPATH}[22;0m 
  (which uses space as a delimiter).  

  See: [1mnmail()[22;0m, [1mvariables[22;0m, [1mspecial variables[22;0m, [1m/set[22;0m 

&mailing list
&mail list

mailing list

  The TinyFugue mailing list is an email forum for discussion of topics 
  related to TinyFugue.  To subscribe, send email to [1mmajordomo@tcp.com[22;0m with a 
  body of "subscribe tinyfugue".  

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

&visual
&nonvisual
&windows
&screen
&mode

mode

  TinyFugue has two main interface modes: Visual and non-visual.  Visual mode 
  will be enabled by default, unless your [1m%{TERM}[22;0m does not support it, or 
  [1m%{visual}[22;0m is explicitly turned off in [1m.tfrc[22;0m, or [1mtf[22;0m is started with the -v 
  option.  Visual mode can be turned off or on with the "[1m/visual[22;0m" command.  

#visual
Visual mode
  The Visual interface has two windows: the bottom window is for input, the 
  top for output.  If your terminal can scroll in a region, output will 
  [1mscroll[22;0m; otherwise if your terminal can delete and insert lines, TF will 
  simulate [1mscrolling[22;0m; otherwise it will wrap from bottom to top, clearing two 
  lines ahead.  The [1m%{scroll}[22;0m [1mvariable[22;0m can be set to explicitly choose 
  [1mscrolling[22;0m or wrapping.  The [1m%{isize}[22;0m, [1m%{cleardone}[22;0m, and [1m%{clearfull}[22;0m 
  [1mvariables[22;0m can be used to customize the visual display.  See: [1m%isize[22;0m, 
  [1m%cleardone[22;0m, [1m%clearfull[22;0m.  

  The two windows are separated by a [1mstatus line[22;0m, which can be formatted by 
  the user as described under [1mstatus_fields[22;0m.  

  If you are using a terminal emulator that emulates different terminal types, 
  the recommended type to use is vt220, vt100, or ansi (in that order), with 
  [1m%{TERM}[22;0m set to the same value.  Scrolling may appear jumpy under ansi, but 
  will be smooth under vt220 and vt100.  vt220 also provides some additional 
  features that may make command line editing smoother (especially over a slow 
  modem).  

#nonvisual
Non-visual mode
  In the non-visual interface, input and output are both displayed on the 
  bottom line.  If you are typing and output appears, your input is cleared, 
  the output is displayed, and your input is redisplayed on the last line.  If 
  your input has wrapped around to a second or third line, only the last line 
  will be cleared and redisplayed.  

#
  ____________________________________________________________________________

  In both modes, output text is wrapped around at a right margin of one less 
  than the number of columns on your screen (typically 79) unless [1mwrapping[22;0m has 
  been turned off.  In addition, if you set the [1mvariable[22;0m [1m%{wrapspace}[22;0m, all 
  lines after the first in a wrapped piece of text will be indented by that 
  many spaces.  See: [1mcolumns()[22;0m, [1m%wrap[22;0m, [1m%wrapsize[22;0m, [1m%wrapspace[22;0m.  

  If the [1m%{more}[22;0m flag is on, output is suspended when the screen is full, and 
  you can use the TAB key to continue.  See: [1m/more[22;0m, [1m/dokey[22;0m.  

&-
&--
&options

options

  Many commands take options to modify their behavior, following these rules 
  (similar to UNIX conventions, but not identical): 

    * All options must be immediately preceded by '-'.  
    * Options may be grouped after a single '-'.  
    * Some options may take string, numeric, or time arguments.  There 
      must be no space between the option and the argument.  
    * String option-arguments may be delimited by a space, double quotes, 
      single quotes, or backquotes.  
    * A literal delimiter character or '\' within a delimited string must 
      be escaped by preceding it with '\'.  
    * All options must precede normal arguments.  
    * A '-' or '--' by itself may be used to mark the end of the options.  
      This is useful when the first regular argument begins with '-'.  
    * A '-?' or invalid option will produce a list of valid options.  

  See also: [1mgetopts()[22;0m.  

&patterns

patterns

  Patterns are used in [1mtriggers[22;0m, [1mhooks[22;0m, [1m/purge[22;0m, [1m/list[22;0m, and [1m/recall[22;0m.  There are 
  three styles of pattern matching available: "simple" comparison, "glob" 
  (similar to shell filename patterns), and "regexp" (regular expressions).  
  The style used by a particular command is determined either by the use of 
  the -m option or the setting of the global [1mvariable[22;0m [1m%{matching}[22;0m.  

#comparison
#simple
#simple matching
Simple matching ("simple")

  The pattern is compared directly to the string.  There are no special 
  characters.  Case is significant.  

#smatch
#globbing
#glob
Globbing ("glob")

  Globbing is the default matching style, and was the only style available 
  before version 3.2.  It is similar to filename expansion ("globbing") used 
  by many shells (but is only used for comparison, not expansion).  

  There are several special sequences that can be used in tf globbing: 

    * The '*' character matches any number of characters.  

    * The '?' character matches any one character.  

    * Square brackets ([...]) can be used to match any one of a sequence 
      of characters.  Ranges can be specified by giving the first and last 
      characters with a '-' between them.  If '^' is the first character, the 
      sequence will match any character NOT specified.  

    * Curly braces ({...}) can be used to match any one of a list of 
      words.  Different words can be matched by listing each within the 
      braces, separated by a '|' (or) character.  Both ends of {...} will only 
      match a space or end of string.  Therefore "{foo}*" and "{foo}p" do not 
      match "foop", and "*{foo}" and "p{foo}" do not match "pfoo".  

      Patterns containing "{...}" can easily be meaningless.  A valid {...} 
      pattern must: (a) contain no spaces, (b) follow a wildcard, space, or 
      beginning of string, (c) be followed by a wildcard, space, or end of 
      string.  

      The pattern "{}" will match the empty string.  

    * Any other character will match itself, ignoring case.  A special 
      character can be made to match itself by preceding it with '\' to remove 
      its special meaning.  

  Examples:
  "d?g" matches "dog", "dig" and "dug" but not "dg" or "drug". 
  "d*g" matches "dg", "dog", "drug", "debug", "dead slug", etc. 
  "{d*g}" matches "dg", "dog", "drug", "debug", but not "dead slug". 
  "M[rs]." matches "Mr." and "Ms."
  "M[a-z]" matches "Ma", "Mb", "Mc", etc. 
  "[^a-z]" matches any character that is not in the English alphabet. 
  "{storm|chup*}*" matches "chupchup fehs" and "Storm jiggles". 
  "{storm|chup*}*" does NOT match "stormette jiggles". 

#re
#regex
#regexp
#regexps
#regular expressions
Regular expressions ("regexp")

  The regexp package was written by Henry Spencer, and is similar to those 
  used in egrep and many text editors.  See also: [1mregmatch()[22;0m, [1msubstitution[22;0m.  
  The following excerpt is taken from Henry Spencer's regexp(3) man page.  

       REGULAR EXPRESSION SYNTAX
            A regular expression is zero or more branches, separated by
            `|'.  It matches anything that matches one of the branches.

            A branch is zero or more pieces, concatenated.  It matches a
            match for the first, followed by a match for the second,
            etc.

            A piece is an atom possibly followed by `*', `+', or `?'.
            An atom followed by `*' matches a sequence of 0 or more
            matches of the atom.  An atom followed by `+' matches a
            sequence of 1 or more matches of the atom.  An atom followed
            by `?' matches a match of the atom, or the null string.

            An atom is a regular expression in parentheses (matching a
            match for the regular expression), a range (see below), `.'
            (matching any single character), `^' (matching the null
            string at the beginning of the input string), `$' (matching
            the null string at the end of the input string), a `\'
            followed by a single character (matching that character), or
            a single character with no other significance (matching that
            character).

            A range is a sequence of characters enclosed in `[]'.  It
            normally matches any single character from the sequence.  If
            the sequence begins with `^', it matches any single
            character not from the rest of the sequence.  If two
            characters in the sequence are separated by `-', this is
            shorthand for the full list of ASCII characters between them
            (e.g. `[0-9]' matches any decimal digit).  To include a
            literal `]' in the sequence, make it the first character
            (following a possible `^').  To include a literal `-', make
            it the first or last character.

       AMBIGUITY
            If a regular expression could match two different parts of
            the input string, it will match the one which begins
            earliest.  If both begin in the same place    but match
            different lengths, or match the same length in different
            ways, life gets messier, as follows.

            In general, the possibilities in a list of branches are
            considered in left-to-right order, the possibilities for
            `*', `+', and `?' are considered longest-first, nested
            constructs are considered from the outermost in, and
            concatenated constructs are considered leftmost-first.  The
            match that will be chosen is the one that uses the earliest
            possibility in the first choice that has to be made.  If
            there is more than one choice, the next will be made in the
            same manner (earliest possibility) subject to the decision
            on the first choice.  And so forth.

            For example, `(ab|a)b*c' could match `abc' in one of two
            ways.  The first choice is between `ab' and `a'; since `ab'
            is earlier, and does lead to a successful overall match, it
            is chosen.  Since the `b' is already spoken for, the `b*'
            must match its last possibility-the empty string-since it
            must respect the earlier choice.

            In the particular case where no `|'s are present and there
            is only one `*', `+', or `?', the net effect is that the
            longest possible match will be chosen.  So `ab*', presented
            with `xabbbby', will match `abbbb'.  Note that if `ab*' is
            tried against `xabyabbbz', it will match `ab' just after
            `x', due to the begins-earliest rule.  (In effect, the
            decision on where to start the match is the first choice to
            be made, hence subsequent choices must respect it even if
            this leads them to less-preferred alternatives.)

Comparison of glob and regexps. 
  In a glob, '*' and '?' by themselves match text.  In a regexp, '*' and '?' 
  are only meaningful in combination with the pattern they follow.  Regexps 
  are not "anchored"; that is, the match may occur anywhere in the string, 
  unless you explicitly use '^' and/or '$' to anchor it.  Globs are anchored, 
  and must match the entire string.  

      regexp              equivalent glob
                          (except for case)
      ------              -----------------
      "part of line"      "*part of line*"
      "^entire line$"     "entire line"
      "(^| )word( |$)"    "*{word}*"
      "^(You|Hawkeye) "   "{You|Hawkeye} *"
      "foo.*bar"          "*foo*bar*"
      "f(oo|00)d"         "*{*food*|*f00d*}*"
      "line[0-9]"         "*line[0-9]*"
      "^[^ ]+ whispers,"  "{*} whispers,*"
      "foo(AB)?bar"       "*{*foobar*|*fooABbar*}*"
      "zoo+m"             none
      "foo ?bar"          none
      "(foo bar|frodo)"   none

Notes. 

    * For best speed, make the beginning of your patterns as specific as 
      possible.  
    * Do not use ".*" or "^.*" at the beginning of a regexp.  It is [4mvery[24m 
      inefficient, and not needed.  Use [1m%PL[22;0m instead if you need to retrieve 
      the value of the left side.  
    * If a glob and regexp can do the same job, use the glob, it's usually 
      faster.  

&priorities
&fallthru
&fall-thru
&selection
&priority
&priority rules

priority

  When more than one [1mmacro[22;0m is matched by a [1mtrigger[22;0m or [1mhook[22;0med event, the 
  following rules are used to select which of the [1mmacros[22;0m will be applied 
  (i.e., have its attributes applied to the text, and its body executed): 

    * [1mMacros[22;0m are compared in order of decreasing [1mpriority[22;0m.  
    * [1mFall-thrus[22;0m of a given [1mpriority[22;0m are compared before [1mnon-fall-thrus[22;0m of 
      the same [1mpriority[22;0m.  
    * Each matching [1mfall-thru[22;0m [1mmacro[22;0m is applied immediately when it is 
      found.  
    * When the first matching [1mnon-fall-thru[22;0m [1mmacro[22;0m is found, all the 
      [1mnon-fall-thrus[22;0m of equal [1mpriority[22;0m are collected, and the search ends.  
      One of the [1mnon-fall-thrus[22;0m is chosen at random and applied.  

  So, in the simple case when there are no [1mfall-thrus[22;0m, the highest [1mpriority[22;0m 
  match is chosen.  If there is more than one of the highest [1mpriority[22;0m, one of 
  those is chosen at random.  

  These [1mpriority[22;0m rules apply even to [1mmacros[22;0m defined or undefined by a [1mmacro[22;0m 
  found during the search.  For example, if a mud line triggers a [1mfall-thru[22;0m 
  [1mmacro[22;0m /foo, and /foo defines a new [1mtrigger[22;0m [1mmacro[22;0m /bar which also matches the 
  line, then /bar may be triggered if it has lower [1mpriority[22;0m than /foo.  

  A [1mmacro's[22;0m [1mpriority[22;0m is set with [1m/def[22;0m [1m-p[22;0m; its [1mfall-thru[22;0m option is set with 
  [1m/def[22;0m [1m-F[22;0m.  

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

&bug
&bugs
&core
&crash
&error
&report
&hawkeye
&author
&support
&problems

problems

  If you have an old version of TF, chances are your bug has already been 
  fixed.  The latest version of TF should be available for anonymous ftp from 
  tf.tcp.com in pub/tinyfugue.  

  Also see [1mhttp://tf.tcp.com/~hawkeye/tf/[22;0m for the latest info on TF.  See 
  "/help mailing list" for information on how to subscribe to the tinyfugue 
  mailing list.  

  Send general bug reports, questions, etc, to hawkeye@tf.tcp.com.  For 
  problems specific to the OS/2 version, contact Andreas Sahlbach at 
  asa@stardiv.de.  When reporting a problem or bug, please provide this 
  information: 

    * The full version number of TF (type "[1m/version[22;0m" in tf).  Please give 
      the [4mfull[24m number, don't just say something like "beta 4" or "the latest 
      version".  
    * The operating system name and version.  (On unix systems, type 
      "uname -a" in the shell to get the exact version information.) 
    * If tf won't install, send the Build.log file (UNIX only) if there is 
      one, or send a log of the installation errors (don't leave out parts 
      just because you don't know what they mean or think they're irrelevant). 
    * If you have a bug or core, give me ALL messages from tf, not just 
      the last line.  Also tell me what you did or what happened before the 
      problem, and whether the problem is repeatable.  
    * If you have a core, do NOT send the core file.  But if you know how, 
      and tf was compiled with debugging option (usually '-g'), a stack trace 
      would be useful (use the 'where' command in gdb or dbx).  If you don't 
      know how, at least provide the other information described above.  

#
  The following bugs are known.  Don't bother reporting them.  

    * The [1m%{lp}[22;0m and [1m%{emulation}[22;0m [1mvariables[22;0m should work on a per-[1msocket[22;0m 
      basis (This is partially overcome with WORLD [1mhooks[22;0m).  
    * If a shell quote ([1m/quote[22;0m !) reads a partial line from the child 
      process, tf will hang until the line is completed.  
    * [1m/recall[22;0m by timestamp doesn't work when switching to/from daylight 
      savings time (but [1m/recall[22;0m by age always works).  

&tinyprocesses
&process
&proc
&processes

processes

  Associated topics: 

  [1m/quote[22;0m
  [1m/repeat[22;0m
  [1m/ps[22;0m
  [1m/kill[22;0m
  [1m%ptime[22;0m
  [1m%lpquote[22;0m

  The [1m/quote[22;0m and [1m/repeat[22;0m commands in Fugue are done by setting up internal 
  [1mprocesses[22;0m that run concurrently with normal input and output.  

  [1m/ps[22;0m can be used to get a listing of the currently running [1mprocesses[22;0m and 
  their process ID's (for use with [1m/kill[22;0m).  

  [1m/kill[22;0m can be used to terminate a [1mprocess[22;0m.  

  [1mProcesses[22;0m can be either synchronous or asynchronous.  Synchronous [1mprocesses[22;0m 
  run immediately when they are started, and run to completion before any 
  other commands are executed.  Synchronous [1mprocesses[22;0m are new in version 3.3 
  beta 10.  

  Asynchronous [1mprocesses[22;0m are merely scheduled to be run by a [1m/quote[22;0m or [1m/repeat[22;0m 
  command; the actual execution occurs at some later time.  They can be run 
  based on two different criteria: 

  1.  Normally, [1mprocesses[22;0m run whenever a specific period of time has elapsed.  
  The delay can be specified when the [1mprocess[22;0m is started, or will default to 
  the value of [1m%{ptime}[22;0m.  

  2.  If the [1m%{lpquote}[22;0m flag is on, [1mprocesses[22;0m run whenever a [1mprompt[22;0m is 
  received from the server, indicating that the previous command as completed. 
  Example: 

          [1m/lpquote[22;0m on
          [1m/quote[22;0m [1m/send[22;0m !echo n; echo w; echo w; echo s

  will send the commands "n", "w", "w", and "s", but will wait to send a 
  command until the [1mprompt[22;0m following the last command is seen.  

  If an asynchronous [1m/quote[22;0m or [1m/repeat[22;0m is followed immediately by another 
  command, the other command will run first, because the asynchronous [1mprocess[22;0m 
  was only scheduled, not actually executed.  Use a synchronous [1m/quote[22;0m or 
  [1m/repeat[22;0m to force the [1mprocess[22;0m to run before any other commands.  

  Bodies of [1m/repeat[22;0m undergo [1mmacro[22;0m body [1mexpansion[22;0m when they are executed; text 
  generated by [1m/quote[22;0m does not.  

  See also: [1mutilities[22;0m ([1m/at[22;0m, [1m/tick[22;0m) 

&goahead
&eor
&end-of-record
&protocol
&prompt protocol

prompt protocol

  TF will recognize the TELNET protocol commands GOAHEAD or END-OF-RECORD as 
  the end of a [1mprompt[22;0m.  If you are responsible for a server that has [1mprompts[22;0m, 
  and wish to make it more friendly to TF users, choose one of these options: 

  GOAHEAD: Send IAC GA (\377 \371) after each [1mprompt[22;0m.  This is the easier of 
  the two options.  In many servers, this can be done at the beginning of the 
  routine that reads user input.  Disadvantage: could possibly cause problems 
  in clients that don't understand TELNET protocol (but usually, they will 
  just pass it through to the terminal, which will usually ignore it).  

  END-OF-RECORD: Send IAC WILL EOR (\377 \373 \031) when the user connects.  
  If the client responds with IAC DO EOR, then you can send IAC END-OF-RECORD 
  (\377 \357) after each [1mprompt[22;0m; otherwise, do nothing special in [1mprompts[22;0m.  
  Disadvantage: requires extra state per descriptor and more understanding of 
  telnet protocol.  Advantage: minimizes potential problems for clients that 
  do not recognize telnet protocol.  

  For more information on TELNET protocol, see RFCs 854, 855, 885, and 1123.  
  RFCs can be obtained via FTP from [1mNIS.NSF.NET[22;0m, [1mNISC.JVNC.NET[22;0m, 
  [1mVENERA.ISI.EDU[22;0m, [1mWUARCHIVE.WUSTL.EDU[22;0m, [1mSRC.DOC.IC.AC.UK[22;0m, [1mFTP.CONCERT.NET[22;0m, 
  [1mDS.INTERNIC.NET[22;0m, or [1mNIC.DDN.MIL[22;0m.  

  See also: [1m/telnet[22;0m, [1mprompts[22;0m 

&lp
&diku
&prompt
&prompts

prompts

  Most LP muds, Diku muds, telnetd, and some other types of servers send 
  unterminated [1mprompts[22;0m, that is, [1mprompts[22;0m that do not end with newline or any 
  other special character.  Normally, TF will not display text until a newline 
  is received, so you may not see the [1mprompt[22;0m until after you press return.  
  But if the [1m%{lp}[22;0m flag is on, TF will attempt to separate these [1mprompts[22;0m from 
  normal text and display them correctly.  

  The recommended way to use the [1m%{lp}[22;0m flag is to define your worlds with one 
  of the [1m/addlp[22;0m, [1m/adddiku[22;0m, or [1m/addtelnet[22;0m commands.  The [1m%{lp}[22;0m flag will be 
  turned on automatically when you switch to such a world, and turned off for 
  the other predefined world types.  See: [1m/addworld[22;0m.  

  TF also provides a PROMPT [1mhook[22;0m, which allows you to tell it what to look for 
  in a [1mprompt[22;0m.  When an unterminated line is received, the PROMPT [1mhook[22;0m is 
  called immediately.  If there is no match, TF will use the timeout method 
  described below (if [1m%{lp}[22;0m is on).  But if there is a matching PROMPT [1mhook[22;0m, 
  TF will forget about the line (unless the hook was defined with [1m/def[22;0m [1m-q[22;0m) and 
  let the [1mhook[22;0m deal with it.  By combining the PROMPT [1mhook[22;0m with the [1m/prompt[22;0m 
  command, you can recognize most [1mprompts[22;0m immediately without having to use 
  the [1m%{lp}[22;0m timing mechanism.  The typical way of doing this is: 

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

  So, whenever TF receives an unterminated line that ends in "> ", 
  catch_prompt will see it, and use [1m/prompt[22;0m to copy it to the current [1mprompt[22;0m.  

  If an unterminated line is not matched by any PROMPT [1mhook[22;0m, and it is not 
  followed by more text within a short period of time, TF will assume it is a 
  [1mprompt[22;0m.  This method is not foolproof.  If the delay is too short, broken 
  lines will look like [1mprompts[22;0m, and will briefly appear in the input window 
  until the rest of the line arrives, at which time both parts of the line 
  will be printed as normal output.  If the delay is too long, there will be 
  an annoying delay before displaying real [1mprompts[22;0m.  

  The delay can be varied by setting the [1mvariables[22;0m [1mprompt_sec[22;0m=<[4mseconds[24m> and 
  [1mprompt_usec[22;0m=<[4mmicroseconds[24m>.  The default values are [1mprompt_sec[22;0m=0 and 
  [1mprompt_usec[22;0m=250000 (that is, 0.25 seconds).  

  All of this hackery can be avoided if the server sends unambiguous [1mprompts[22;0m.  
  TF will recognize "*\b" (that is, "*" followed by backspace) and anything 
  ending with [1mGOAHEAD[22;0m or [1mEND-OF-RECORD[22;0m telnet characters.  When TF sees such 
  text, it does not wait for a delay, but calls the PROMPT hook immediately; 
  if there is no match, TF displays the prompt immediately.  To avoid some 
  minor glitches, you should leave the [1m%{lp}[22;0m flag off when connected to such a 
  server.  If you are responsible for a server and wish to make it more 
  TF-friendly, see "[1mprotocol[22;0m".  

  See also: [1m%login[22;0m, [1mprompt protocol[22;0m, [1m/addworld[22;0m 

&firewall
&proxy
&/proxy_command
&proxy server

proxy server

  If [1m%{proxy_host}[22;0m is set, all connections will go through a proxy server 
  (firewall) defined by [1m%proxy_host[22;0m and [1m%proxy_port[22;0m.  

  When the connection to [1m%proxy_host[22;0m [1m%proxy_port[22;0m is made, only the PROXY [1mhook[22;0m 
  is called; the CONNECT and LOGIN [1mhooks[22;0m which are normally called after 
  making a connection are not called when a proxy is used.  A PROXY [1mhook[22;0m 
  defined in the standard library calls [1m/proxy_command[22;0m, which by default sends 
  "telnet [1m${world_host}[22;0m [1m${world_port}[22;0m", and then calls the CONNECT and LOGIN 
  [1mhooks[22;0m.  If your proxy server requires a different command, you should 
  redefine [1m/proxy_command[22;0m.  

  Before the connection is made, [1m${world_host}[22;0m, [1m${world_port}[22;0m, error messages, 
  and [1m/listsockets[22;0m refer to the proxy server; after the connection is made, 
  they refer to the server defined in [1m/addworld[22;0m.  

  Note that tf has no way of knowing if the command sent to the proxy server 
  actually succeeded in opening a connection to the destination server; if it 
  failed, the default /proxy_command will happily call the LOGIN [1mhook[22;0m and send 
  your login command to the proxy server instead of the destination.  However, 
  since the CONNECT and LOGIN [1mhooks[22;0m are called by /proxy_command, not tf, you 
  can define your own /proxy_command that waits for specific error and success 
  messages sent by your particular proxy server.  

  For example, say you use a Gauntlet telnet proxy that leaves localecho off; 
  prints a "tn-gw-> " prompt; requires you to send "telnet <[4mhostname[24m> <[4mport[24m>" 
  to connect; after a successful connection, prints "Connected to <[4mhostname[24m>"; 
  and after a failed connection prints an error message and prints another 
  prompt.  For such a proxy server, you could use this /proxy_command: 

  /def proxy_command =\
      /def -p10000 -w -1 -h'PROMPT tn-gw->*' =\
          telnet $${world_host} $${world_port}%%; \
          /localecho on%%; \
          /def -p10002 -w -1 -h'PROMPT tn-gw->*' proxy_error_$${world_name} =\
              /undef proxy_success_$$${world_name}%%%;\
              /dc%%;\
          /def -p10002 -w -1 -t'Connected to *' proxy_success_$${world_name} =\
              /undef proxy_error_$$${world_name}%%%;\
              /trigger -hCONNECT $$${world_name}%%%;\
              /if ($$${world_character} !~ "" & $$${world_login}) \
                  /trigger -hLOGIN ${world_name}%%%;\
              /endif

  The first /def waits for the first prompt before doing anything.  It then 
  sends the connection command, turns localecho back on, and sets up macros to 
  catch the results of the connection command.  The success trigger undefines 
  the error hook, and calls the CONNECT and LOGIN hooks.  The error hook 
  undefines the success trigger and disconnects from the proxy.  

  For systems that use SOCKS, tf should be compiled with the SOCKS option, 
  instead of using the method described here.  See the README file for 
  details.  

  See: [1m/addworld[22;0m, [1m%proxy_host[22;0m, [1m%proxy_port[22;0m 

&redirection

redirection

  If TF is started with input or output redirected, [1m%more[22;0m will be ignored and 
  SIGINT (^C) will kill TF without prompting.  TF will not exit when EOF is 
  reached; the [1m/quit[22;0m command must be given explicitly.  

  On UNIX systems, it is possible to write a tf script starting with the 
  lines: 

      #!/bin/sh
      exec tf -n $* <$0

  and following with any tf commands.  The file can then be executed directly 
  like a shell script.  

&interrupt
&hangup
&sigwinch
&signals

signals

  TF catches several signals from the OS and handles them specially: 

  SIGINT (normally generated by typing ^C) 
          Aborts any running [1mmacro[22;0m or blocking [1mhostname resolution[22;0m or [1mconnect[22;0m, 
          and offers a menu of choices:
          C) continue tf; X) exit; T) disable triggers; P) kill processes.  
  SIGQUIT (normally generated by typing ^\) 
          Prompts the user to quit.  If the answer is 'y', TF will dump a core 
          file if the OS supports it, and exit.  
  SIGTERM 
          Calls the SIGTERM [1mhook[22;0m, and then exits TF.  
  SIGHUP (normally generated when the terminal disconnects) 
          Calls the SIGHUP [1mhook[22;0m, and then exits TF.  
  SIGUSR1 
          Calls the SIGUSR1 [1mhook[22;0m.  TF does not exit.  
  SIGUSR2 
          Calls the SIGUSR2 [1mhook[22;0m.  TF does not exit.  
  SIGTSTP (normally generated by typing ^Z) 
          Suspends the TF process, like [1m/suspend[22;0m.  
  SIGWINCH (normally generated by resizing the terminal) 
          Redraws the screen, and calls the RESIZE [1mhook[22;0m.  

  See also: [1mhooks[22;0m, [1m/signal[22;0m 

&
&sockets

sockets

  Associated topics: 

  [1m/connect[22;0m 
          open a [1msocket[22;0m connection to a world 
  [1m/dc[22;0m     close (disconnect) a [1msocket[22;0m 
  [1m/fg[22;0m     bring a [1msocket[22;0m into the [1mforeground[22;0m 
  [1m%login[22;0m  enable [1mautomatic login[22;0m 
  [1m/listsockets[22;0m 
          display a list of open [1msockets[22;0m 
  [1mfg_world()[22;0m 
          name of foreground world 
  [1midle()[22;0m  idle time 
  [1mnactive()[22;0m 
          number of active sockets, or number of undisplayed lines 
  [1m%background[22;0m 
          determines when to process text from [1mbackground[22;0m [1msockets[22;0m 
  [1m%bg_output[22;0m 
          determines how to display text from [1mbackground[22;0m [1msockets[22;0m 

#current
#foreground
#background
#foreground/background/current
  A [1msocket[22;0m is an open connection to a world.  TF can have multiple [1msockets[22;0m 
  open simultaneously.  Only one of these can be displayed at a time; this is 
  called the [1mforeground[22;0m [1msocket[22;0m.  In [1mvisual mode[22;0m, the name of the world on the 
  [1mforeground[22;0m [1msocket[22;0m is displayed on the [1mstatus line[22;0m.  Other [1msockets[22;0m are in the 
  [1mbackground[22;0m.  Text from any [1msocket[22;0m is [1mtrigger[22;0med and stored in [1mhistory[22;0m 
  immediately, but is not displayed until that [1msocket[22;0m is brought into the 
  [1mforeground[22;0m.  Turning off the [1m%{bg_output}[22;0m flag prevents the display when the 
  [1msocket[22;0m is [1mforegrounded[22;0m.  Turning off the [1m%{background}[22;0m flag prevents all 
  processing until the [1msocket[22;0m is [1mforegrounded[22;0m.  

  The [1mcurrent[22;0m [1msocket[22;0m is the [1msocket[22;0m to which commands are sent.  The [1mcurrent[22;0m 
  [1msocket[22;0m is almost always the same as the [1mforeground[22;0m [1msocket[22;0m, except: 1) when a 
  [1mmacro[22;0m is [1mtriggered[22;0m from any [1msocket[22;0m, that [1msocket[22;0m becomes the [1mcurrent[22;0m [1msocket[22;0m 
  for the duration of that [1mmacro[22;0m execution; 2) when a [1m/repeat[22;0m or [1m/quote[22;0m with 
  world redirection runs (-w option), that world's [1msocket[22;0m becomes the [1mcurrent[22;0m 
  [1msocket[22;0m for the duration of the [1mprocess[22;0m execution.  

#
  Text from a [1msocket[22;0m goes through a number of checks before being displayed.  
  If the text matches any [1mtrigger[22;0m patterns, a [1mmacro[22;0m may be executed, or the 
  text may be [1mgag[22;0mged or [1mhilite[22;0md.  If the text was not [1mgag[22;0mged, TF also checks 
  to see if it should be suppressed because of [1m%quiet[22;0m, [1m/watchdog[22;0m or 
  [1m/watchname[22;0m.  Finally, the text is added to the world's [1mhistory[22;0m and the 
  global [1mhistory[22;0m, and is queued for display.  

  You can open a new [1msocket[22;0m in several ways: 

    * By giving the world name or address on the command line when 
      [1mstarting tf[22;0m.  
    * By using a [1m/connect[22;0m or [1m/world[22;0m command.  
    * By "[1mbamfing[22;0m" through a portal between muds (see "[1mbamf[22;0m").  

  You can switch between [1mforeground[22;0m [1msockets[22;0m with the [1m/fg[22;0m command; the next 
  [1msocket[22;0m and previous [1msocket[22;0m keys, which default to ESC-b and ESC-f, and can 
  be modified with [1m/bind[22;0m; and, when the file world-q.tf is loaded, with the 
  ESC-w keybinding.  

  If the [1m%{quitdone}[22;0m flag is on, and you disconnect from all worlds (either 
  with [1m/dc[22;0m or because the other end of the [1msocket[22;0m closes), Fugue will exit.  

  If the [1m%{sockmload}[22;0m flag is on, a world's [1mmacro[22;0m file will be loaded when you 
  switch to the [1msocket[22;0m for that world (either with the next and previous 
  [1msocket[22;0m keys or with the [1m/world[22;0m command).  

  TF supports several TELNET options; see [1mtelnet[22;0m.  

  If [1m%{proxy_host}[22;0m is defined, all connections will go through a [1mproxy[22;0m server. 
  See: [1mproxy[22;0m.  

  See also: [1mworlds[22;0m 

&flags
&globals
&global variables
&environment
&enumerated variable
&enumerated variables
&special
&special variable
&special variables

special variables

  Many options in TF can be controlled by setting special global [1mvariables[22;0m.  
  Many [1mvariables[22;0m have a limited number of permitted values, with corresponding 
  integer values; these are called enumerated [1mvariables[22;0m.  All flags are 
  enumerated [1mvariables[22;0m which can have the values "off" (0) or "on" (1).  
  Numeric [1mvariables[22;0m can have any integer value (within the range allowed by 
  your system).  Attempting to unset numeric [1mvariable[22;0m or give it a string 
  value will force its value to 0.  A variable's type (enumerated, numeric, or 
  string) affects its behavior in [1mexpressions[22;0m.  

Special substitute-only variables
  The following special [1mvariables[22;0m may be used only in [1msubstitutions[22;0m, never as 
  a variable [1mreference[22;0m in an [1mexpression[22;0m.  

##
#%#
  [1m#[22m       The number of words in a [1mmacro[22;0m's argument text.  

#?
#%?
  [1m?[22m       The string return value of the most recently executed 
          command (builtin or [1mmacro[22;0m).  

#
  [1m1,2...[22m 
  [1mL1,L2...[22m 
  [1m*[22m 
  [1mR[22m       Positional parameters.  See "[1msubstitution[22;0m".  

#
  [1mP<[4mn[24m>[22m 
  [1mPL[22m 
  [1mPR[22m      The text matched by the <[4mn[24m>th parenthesized subexpression, 
          or the text to the left or right of the matched text, in the last 
          successful [1mregexp[22;0m comparison.  See [1m%Pn[22;0m for more details.  

#
Special global variables
  The following special global [1mvariables[22;0m can be examined and set.  In the 
  following list, a '=' following a [1mvariable[22;0m name indicates its default value. 
  For [1mvariables[22;0m that do not have defaults listed, the default is dependent on 
  your system or configuration.  

#COLUMNS
#%COLUMNS
  [1mCOLUMNS[22m 
          If this variable is set in the environment when TF starts, TF will 
          use its value instead of the value from the terminal driver.  See 
          [1m%LINES[22;0m, [1mcolumns()[22;0m.  

#HOME
#%HOME
  [1mHOME[22m    Your home directory, used by [1m/cd[22;0m and [1mfilename expansion[22;0m.  
          This is usually inherited from the environment when tf starts.  

#LANG
#%LANG
  [1mLANG[22m    The current locale.  See [1mlocale[22;0m.  Automatically exported to 
          the environment when set.  

#LC_ALL
#%LC_ALL
  [1mLC_ALL[22m  The current locale.  See [1mlocale[22;0m.  Automatically exported to 
          the environment when set.  

#LC_CTYPE
#%LC_CTYPE
  [1mLC_CTYPE[22m 
          The current locale for character classification.  See [1mlocale[22;0m.  
          Automatically exported to the environment when set.  

#LC_TIME
#%LC_TIME
  [1mLC_TIME[22m 
          The current locale for time formatting.  See [1mlocale[22;0m.  Automatically 
          exported to the environment when set.  

#LINES
#%LINES
  [1mLINES[22m   If this variable is set in the environment when TF starts, 
          TF will use its value instead of the value from the terminal driver. 
          See [1m%COLUMNS[22;0m, [1mlines()[22;0m.  

#%MAIL
  [1mMAIL[22m    The name of a file which TF may check for mail.  See: [1mmail[22;0m.  

#SHELL
#%SHELL
  [1mSHELL[22m   Shell used by [1m/sh[22;0m and [1m/quote[22;0m !.  This is usually inherited 
          from the environment when tf starts.  

#terminal
#term
#TERM
#%TERM
  [1mTERM[22m    Terminal type.  Changing the value of [1m%TERM[22;0m at any time will 
          cause TF to re-initialize its display functions to use the new 
          value.  The value of [1m%TERM[22;0m should agree with your actual terminal or 
          emulator.  If your emulator supports multiple terminal types, the 
          recommended type to use is vt220, vt100, or ansi (in that order).  
          [1m%TERM[22;0m is usually inherited from the environment when tf starts.  See 
          also: [1mmode[22;0m.  

#TFHELP
#%TFHELP
  [1mTFHELP[22m=[1m%{TFLIBDIR}[22;0m/tf-help 
          The name of the file used by [1m/help[22;0m.  

#TFLIBDIR
#%TFLIBDIR
  [1mTFLIBDIR[22m 
          The name of the TF library directory, which should contain the help 
          file (tf-help), the standard library (stdlib.tf), the local library 
          (local.tf), and many useful utility files.  The default value of 
          [1mTFLIBDIR[22;0m is set when TF is installed, but can be overridden by 
          setting it in the environment before starting TF.  This directory 
          will be searched by [1m/load[22;0m if [1mTFPATH[22;0m is blank or not set.  See also: 
          [1m/load[22;0m.  

#TFLIBRARY
#%TFLIBRARY
  [1mTFLIBRARY[22m=[1m%{TFLIBDIR}[22;0m/stdlib.tf 
          The name of the library file loaded at [1mstartup[22;0m.  This can be set in 
          the environment before starting tf, to load from an alternate 
          library file.  

#MAILPATH
#TFMAILPATH
#%TFMAILPATH
  [1mTFMAILPATH[22m 
          A space-separated list of files which TF may check for mail.  See: 
          [1mmail[22;0m.  

#TFPATH
#%TFPATH
  [1mTFPATH[22m= 
          A space-separated list of directories that will be searched by 
          [1m/load[22;0m.  If this is set, [1m%{TFLIBDIR}[22;0m will be ignored by [1m/load[22;0m, so be 
          sure to include the value of [1m%{TFLIBDIR}[22;0m in [1m%{TFPATH}[22;0m if you want to 
          be able to [1m/load[22;0m files with relative names from the standard library 
          directory.  See also: [1m/load[22;0m.  

#TZ
#%TZ
  [1mTZ[22m      On most systems, the timezone used to display formatted 
          times.  In the United States, the value is usually the local 
          timezone name, followed by the difference in hours from GMT, 
          followed by an optional daylight saving timezone name; for example, 
          "PST8PDT".  For details, see your system documentation for tzset(3) 
          or environ(5).  This is usually inherited from the environment when 
          tf starts, and is automatically exported to the environment when 
          set.  

#auto_fg
#%auto_fg
  [1mauto_fg[22m=on 
          (flag) If on when the [1mforeground[22;0m [1msocket[22;0m disconnects, tf will 
          automatically bring another [1msocket[22;0m into the [1mforeground[22;0m.  

#background
#%background
  [1mbackground[22m=on 
          (flag) If on, text from [1mbackground[22;0m worlds is processed and recorded 
          immediately upon receipt.  Otherwise, the text is ignored until the 
          [1msocket[22;0m is brought into the [1mforeground[22;0m.  In either case, the text is 
          not displayed until the [1msocket[22;0m is brought into the [1mforeground[22;0m (but 
          see [1m%{bg_output}[22;0m).  

#backslash
#%backslash
  [1mbackslash[22m=on 
          (flag) Enables use of '\' to quote the following character literally 
          during [1mmacro[22;0m [1mexpansion[22;0m.  Generally, this should only be turned off 
          if you are having problems with '\' in [1mmacros[22;0m written before version 
          3.0.  

#bamf
#%bamf
  [1mbamf[22m=off 

          off     (0): server "[1mportals[22;0m" are ignored.  
          on      (1): Unter-style [1mbamfing[22;0m is enabled (disconnect).  
          old     (2): Old-style [1mbamfing[22;0m is enabled (no disconnect).  

          See [1m/bamf[22;0m.  

#bg_output
#%bg_output
  [1mbg_output[22m=on 
          (flag) If on, output from a [1mbackground[22;0m world will be displayed when 
          that world is brought into the [1mforeground[22;0m.  If off, [1mbackground[22;0m 
          output will not be displayed, but it will go through all other 
          normal processing, including [1mtriggers[22;0m and [1mhistory[22;0m (so it can be 
          accessed with [1m/recall[22;0m).  This flag is ignored if the [1m%{background}[22;0m 
          flag is off.  (The -q option of [1m/fg[22;0m is a more flexible way to do the 
          same thing.) 

#binary_eol
#%binary_eol
  [1mbinary_eol[22m=LF 
          Determines what to send as end-of-line marker in [1mTELNET[22;0m BINARY mode. 
          Valid values are "LF", "CR", and "CRLF".  (See: [1m/telnet[22;0m) 

#borg
#%borg
  [1mborg[22m=on 
          (flag) Enables [1mtrigger[22;0m bodies ([1mattributes[22;0m are unaffected).  (See: 
          [1mtriggers[22;0m) 

#clearfull
#%clearfull
  [1mclearfull[22m=off 
          (flag) In [1mvisual[22;0m mode, clear input window rather than scroll when 
          full.  Always 1 if terminal can not scroll.  

#cleardone
#%cleardone
  [1mcleardone[22m=off 
          (flag) In [1mvisual[22;0m mode, enables clearing of input window when return 
          is pressed.  

#clock
#%clock
  [1mclock[22m   This variable is no longer supported.  To disable the clock, 
          remove the "@clock" field from the [1m%status_fields[22;0m variable, or /set 
          status_int_clock=''.  To make the clock display in 24-hour format, 
          /set status_int_clock=[1mftime[22;0m("%H:%M", [1mtime[22;0m()).  

#connect
#%connect
  [1mconnect[22m=nonblocking 
          Set to "blocking" or "nonblocking" to determine how [1m/connect[22;0m works.  
          Default is "nonblocking" on platforms that support it.  Nonblocking 
          allows you to continue doing other things while tf tries to 
          establish a new connection.  See also [1m%gethostbyname[22;0m.  

#%e
  [1me[22m=2.718281828 
          Euler's number.  

#raw
#canon
#print
#ansi
#ansi_strip
#ansi_attr
#emulation
#%emulation
  [1memulation[22m=ansi_attr 
          Determines how special codes sent by the server should be 
          interpreted by tf.  The set of printable characters is determined by 
          the current [1mlocale[22;0m.  Valid values for [1m%emulation[22;0m are: 

          raw:    No processing done; lines not wrapped; all 
                  nonprintable characters are displayed, and their effect is 
                  undefined (depending mainly on your terminal).  TF's input 
                  display is not guaranteed correct; use at your own risk.  
                  This mode allows the server to have most of the control over 
                  the screen, but is not guaranteed to give the desired 
                  effect.  For best results, [1m%visual[22;0m should be "off", and tf 
                  [1mattributes[22;0m should not be used.  
          print:  Tabs expanded; backspaces interpreted; lines 
                  wrapped; nonprintable characters removed.  
          ansi_strip: 
                  Like "print", but ansi-like display codes (i.e., a sequence 
                  consisting of ESC, '[', 0 or more digits and ';'s, and a 
                  letter) are also removed.  
          ansi_attr: 
                  Like "ansi_strip", but ansi-like [1mdisplay attribute[22;0m codes 
                  (i.e., ansi codes ending with 'm') will be converted to tf's 
                  internal format and displayed correctly (on any terminal).  
                  Other ansi-like codes (e.g., cursor motion) will be removed. 
                  Recommended for servers that send vt100/ansi display 
                  [1mattribute[22;0m codes.  
          debug:  converts nonprinting characters to a printable form. 
                  See also: [1m%telopt[22;0m.  

          See also: [1m%istrip[22;0m, [1m%meta_esc[22;0m, [1m%tabsize[22;0m, [1mlocale[22;0m, [1mattributes[22;0m 

#end_color
#%end_color
  [1mend_color[22m 
          The code that should be sent to your terminal to return to normal 
          [1mcolor[22;0m after a [1m%{start_color_<[4mname[24m>}[22;0m code.  See: [1mcolor[22;0m.  

#gag
#%gag
  [1mgag[22m=on  (flag) Enable the [1mgag[22;0m [1mattribute[22;0m.  (See: [1m/gag[22;0m, [1m/nogag[22;0m) 

#gethostbyname
#%gethostbyname
  [1mgethostbyname[22m 
          Set to "blocking" or "nonblocking" to determine how [1m/connect[22;0m does 
          hostname resolution.  On OS/2, default is "nonblocking".  On UNIX, 
          default is "blocking", because nonblocking is usually slower unless 
          you have a fast machine and slow name service.  See also [1m%connect[22;0m.  

#gpri
#%gpri
  [1mgpri[22m=0  Priority of subsequent [1m/gag[22;0ms.  (See: [1m/gag[22;0m) 

#hook
#%hook
  [1mhook[22m=on 
          (flag) Enable [1mhooks[22;0m.  (See: [1mhooks[22;0m, [1m/hook[22;0m) Note that [1mautologin[22;0m and 
          automatic [1m%{lp}[22;0m setting will not work if [1m%{hook}[22;0m is 0.  

#hilite
#%hilite
  [1mhilite[22m=on 
          (flag) Enable display [1mattributes[22;0m, whether from a [1mtrigger[22;0m, the 
          server, or whatever.  (See: [1m/hilite[22;0m, [1m/nohilite[22;0m) 

#hiliteattr
#%hiliteattr
  [1mhiliteattr[22m=B 
          Defines the [1mattributes[22;0m used by [1mhilite[22;0ms.  Can be any combination of 
          [1mattributes[22;0m, including color names.  (See: [1mattributes[22;0m, [1m/hilite[22;0m) 

#histsize
#%histsize
  [1mhistsize[22m=1000 
          When a new world [1mhistory[22;0m is created, it will have space for 
          [1m%{histsize}[22;0m lines.  A world [1mhistory[22;0m is created the first time text 
          is sent to it.  (See also: [1m/histsize[22;0m) 

#hpri
#%hpri
  [1mhpri[22m=0  Priority of subsequent [1m/hilite[22;0ms.  

#insert
#typeover
#%insert
  [1minsert[22m=on 
          (flag) If on, keyboard input is inserted; if off, input overstrikes 
          existing text.  

#isize
#%isize
  [1misize[22m=3 
          Size of input window in [1mvisual[22;0m mode.  See also: [1mlines()[22;0m.  

#istrip
#%istrip
  [1mistrip[22m=off 
          (flag) If on, the high bit will be stripped from all input 
          characters.  Note that this will prevent [1m%meta_esc[22;0m and [1mlocales[22;0m with 
          8-bit characters from working correctly.  

#kecho
#%kecho
  [1mkecho[22m=off 
          (flag) Re-echoing of keyboard input, preceded by [1m%{kprefix}[22;0m.  See 
          also: [1m/localecho[22;0m.  

#kprefix
#%kprefix
  [1mkprefix[22m= 
          Prefix for echoed keyboard text, if [1m%{kecho}[22;0m is on.  

#%login
  [1mlogin[22m=on 
          (flag) Enable [1mautomatic login[22;0m [1mhook[22;0m.  (See: [1mautomatic login[22;0m, [1mhooks[22;0m, 
          [1m/world[22;0m) 

#lp
#%lp
  [1mlp[22m=off  (flag) Displays partial lines as [1mprompts[22;0m, after a short 
          timeout.  Useful for LP and Diku MUDs.  (See: [1mprompts[22;0m) 

#lpquote
#%lpquote
  [1mlpquote[22m=off 
          (flag) If on, waits for LP [1mprompt[22;0m for [1m/quote[22;0m and [1m/repeat[22;0m, instead of 
          operating on a timed basis.  (See: [1mprocesses[22;0m, [1m/quote[22;0m, [1m/repeat[22;0m) 

#maildelay
#%maildelay
  [1mmaildelay[22m=60 
          Delay in seconds between mail checks.  Setting this to 0 disables 
          mail checking.  The file to be checked is named by the [1m%{MAIL}[22;0m 
          [1mvariable[22;0m.  

#matching
#%matching
  [1mmatching[22m=glob 
          Determines the default [1mpattern matching[22;0m style.  

          "[1msimple[22;0m": 
                  straightforward string comparison.  
          "[1mglob[22;0m": 
                  shell-like matching (as before version 3.2).  
          "[1mregexp[22;0m": 
                  regular expression.  

          See also: [1mpatterns[22;0m, [1mregmatch()[22;0m, [1m%Pn[22;0m.  

#max_iter
#%max_iter
  [1mmax_iter[22m=1000 
          Maximum number of iterations in a [1m/while[22;0m loop.  A value of 0 will 
          allow unlimited iterations.  

#max_recur
#%max_recur
  [1mmax_recur[22m=100 
          Maximum depth of recursive [1mmacro[22;0m calls or [1mtriggers[22;0m.  A value of 0 
          will allow unlimited recursion.  

#debug
#debugging
#mecho
#%mecho
  [1mmecho[22m=off 

          "off" (0): 
                  do not echo [1mmacro[22;0m [1mexpansions[22;0m.  
          "on" (1): 
                  echo [1mexpansions[22;0m of non-invisible [1mmacros[22;0m.  
          "all" (2): 
                  echo [1mexpansions[22;0m of all [1mmacros[22;0m.  

          [1m%{mprefix}[22;0m will be prepended once for each recursion level when 
          [1mmacro[22;0m [1mexpansion[22;0m echoing is enabled.  

#meta_esc
#%meta_esc
  [1mmeta_esc[22m=on 
          (flag) If [1m%istrip[22;0m is off and [1m%meta_esc[22;0m is on, any characters that 
          are not printable in the current [1mlocale[22;0m and have their high bit set 
          will have their high bit striped, and will be prefixed with an ESC 
          character.  This allows M-x and ^[x to invoke the same keybinding.  

#more
#%more
  [1mmore[22m=off 
          (flag) Displays output one screenfull at a time.  (See: [1m/more[22;0m) 

#mprefix
#%mprefix
  [1mmprefix[22m=+ 
          Prefix for [1mmacro[22;0m echoing, if [1m%{mecho}[22;0m is not "off".  

#oldslash
#%oldslash
  [1moldslash[22m=on 
          (flag) If on, sequences of more than one '/' in a [1mmacro[22;0m body will be 
          compressed by one during [1mmacro[22;0m [1mexpansion[22;0m.  This allows [1mmacros[22;0m 
          written before version 3.0 to work properly.  With oldslash=off, 
          only slashes at the beginning of a body are handled specially.  You 
          are encouraged to turn this off.  (See: [1mevaluation[22;0m) 

#%pi
  [1mpi[22m=3.141592654 
          The ratio of a circle's circumference to its diameter.  

#pedantic
#%pedantic
  [1mpedantic[22m=off 
          (flag) If on, tf will generate warnings about some potential 
          problems in your macro code.  Often the warnings indicate code that 
          is technically valid but may not do what you intended.  

#prompt_sec
#%prompt_sec
#prompt_usec
  [1mprompt_sec[22m=0 
  [1mprompt_usec[22m=250000 
          These two [1mvariables[22;0m control the delay used to recognize unterminated 
          [1mprompts[22;0m.  (See: [1mprompts[22;0m).  

#proxy_host
#%proxy_host
#proxy_port
#%proxy_port
  [1mproxy_host[22m= 
  [1mproxy_port[22m=23 
          These two [1mvariables[22;0m describe the [1mproxy[22;0m server used for opening 
          connections.  (See: [1mproxy[22;0m).  

#ptime
#%ptime
  [1mptime[22m=1 
          Default delay (in seconds) between [1m/quote[22;0m and [1m/repeat[22;0m [1mprocess[22;0m runs.  

#qecho
#%qecho
  [1mqecho[22m=off 
          (flag) Echoing of [1m/quote[22;0m text, prefixed by [1m%{qprefix}[22;0m.  

#qprefix
#%qprefix
  [1mqprefix[22m= 
          Prefix for [1m/quote[22;0m echoing, if [1m%{qecho}[22;0m is on.  

#quiet login
#quiet
#%quiet
  [1mquiet[22m=off 
          (flag) [1mGag[22;0m text after [1mlogin[22;0m until the mud sends "Use the WHO 
          command", "### end of messages ###", or 25 lines.  Note: This will 
          not function correctly on MUDs which don't send those strings or 25 
          lines in the introductory text.  

#quitdone
#%quitdone
  [1mquitdone[22m=off 
          (flag) Quit upon disconnection from last [1msocket[22;0m.  

#redef
#%redef
  [1mredef[22m=on 
          (flag) Allows redefinition of existing worlds, keybindings, and 
          named [1mmacros[22;0m.  

#refreshtime
#%refreshtime
  [1mrefreshtime[22m=250000 
          The delay (in microseconds) for redisplaying your keyboard input 
          after it is overwritten by incoming text in [1mnon-visual[22;0m mode.  If you 
          you are on a slow modem, you may wish to increase this delay.  On a 
          fast connection, you may wish to decrease it.  The default is 250000 
          (1/4 second).  

#scroll
#%scroll
  [1mscroll[22m=on 
          (flag) In [1mvisual[22;0m mode, scroll output instead of wrapping from bottom 
          to top.  

#shpause
#%shpause
  [1mshpause[22m=off 
          (flag) Wait for a keypress after returning from [1m/sh[22;0m.  

#snarf
#%snarf
  [1msnarf[22m=off 
          (flag) Don't send empty lines to the server.  

#sockmload
#%sockmload
  [1msockmload[22m=off 
          (flag) Load [1mmacro[22;0m files when [1mforegrounding[22;0m a world ("[1m/dokey[22;0m 
          socketf", "[1m/dokey[22;0m socketb", or "[1m/fg[22;0m").  Normally, a world's [1mmacro[22;0m 
          file is loaded only when TF first connects to it.  (Note: the WORLD 
          [1mhook[22;0m is more useful than sockmload).  

#start_color
#%start_color
#start_color_name
#%start_color_name
#start_color_<name>
#%start_color_<name>
  [1mstart_color_<[4mname[24m>[22m 
          The code that should be sent to your terminal to produce [1mcolor[22;0m 
          <[4mname[24m>.  See: [1mcolor[22;0m.  

#status_attr
#%status_attr
  [1mstatus_attr[22m 
          The [1mattributes[22;0m used to display the [1mstatus line[22;0m in [1mvisual mode[22;0m.  See: 
          [1mstatus line[22;0m.  

#
  [1mstatus_fields[22m 
          The list of fields displayed on the [1mstatus line[22;0m in [1mvisual mode[22;0m.  
          See: [1mstatus line[22;0m.  

#status_pad
#%status_pad
  [1mstatus_pad[22m=_ 
          The padding character used in displaying the [1mstatus line[22;0m in [1mvisual 
          mode[22;0m.  See: [1mstatus line[22;0m.  

#tab
#%tab
#tabs
#tabsize
#%tabsize
  [1mtabsize[22m=8 
          Tabs will be replaced with spaces to pad to a multiple of 
          [1m%{tabsize}[22;0m.  

#telopt
#%telopt
  [1mtelopt[22m=off 
          (flag) Display [1mtelnet[22;0m option negotiations (for debugging purposes).  
          See also: [1m%emulation[22;0m=debug.  

#sub
#%sub
  [1msub[22m=off 

          "off" (0): 
                  input is not [1mexpanded[22;0m.  
          "on" (1): 
                  input "[1m%;[22;0m" is [1mexpanded[22;0m to newlines.  
          "full" (2): 
                  input undergoes full [1mmacro expansion[22;0m.  

#time_format
#%time_format
  [1mtime_format[22m=%H:%M 
          The format used to display times in [1m/recall[22;0m and [1m/time[22;0m.  The default 
          displays hours and minutes.  See [1mftime()[22;0m for a description of the 
          format.  

#visual
#%visual
  [1mvisual[22m=on 
          (flag) Divides the screen into an input window and an output window. 
          (See: [1mmode[22;0m) 

#watchdog
#%watchdog
  [1mwatchdog[22m=off 
          (flag) [1mGag[22;0m repeated lines.  (See: [1m/watchdog[22;0m) 

#watchname
#%watchname
  [1mwatchname[22m=off 
          (flag) [1mGag[22;0m overactive players.  (See: [1m/watchname[22;0m) 

#wordpunct
#%wordpunct
  [1mwordpunct[22m=_ 
          List of punctuation that will be considered to be part of a word 
          instead of delimiting the ends of a word, by [1mkbwordleft()[22;0m and 
          [1mkbwordright()[22;0m (and therefore by [1m/dokey[22;0m WLEFT, WRIGHT, etc).  

#wrap
#%wrap
  [1mwrap[22m=on 
          (flag) Enable wordwrap on the screen.  TF will try to break lines 
          between words to fit them within [1m%{wrapsize}[22;0m columns.  [1m%{wrap}[22;0m is 
          ignored if [1m%{emulation}[22;0m is "raw".  

#wraplog
#%wraplog
  [1mwraplog[22m=off 
          (flag) Enable wordwrap in log files.  See also: [1m%wrap[22;0m.  

#wrapsize
#%wrapsize
  [1mwrapsize[22m=79 
          Lines (input and output) extending past this column will be split.  
          Default value is one less than the number of columns on your 
          terminal (typically 80).  Output is not wrapped if [1m%{emulation}[22;0m is 
          "raw".  See also: [1m%wrap[22;0m, [1m%wrapspace[22;0m, [1mcolumns()[22;0m.  

#indent
#%indent
#wrapspace
  [1mwrapspace[22m=0 
          Wrapped text is indented by this many spaces.  See also: [1m%wrap[22;0m, 
          [1m%wrapsize[22;0m.  

#
  The builtin commands [1m/gag[22;0m, [1m/hilite[22;0m, [1m/hook[22;0m, [1m/nogag[22;0m, [1m/nohilite[22;0m, [1m/watchdog[22;0m, and 
  [1m/watchname[22;0m set the corresponding [1mvariables[22;0m, and also perform additional 
  functions.  

  The standard library also defines [1m/background[22;0m, [1m/bamf[22;0m, [1m/borg[22;0m, [1m/clearfull[22;0m, 
  [1m/cleardone[22;0m, [1m/gpri[22;0m, [1m/hpri[22;0m, [1m/insert[22;0m, [1m/isize[22;0m, [1m/login[22;0m, [1m/lp[22;0m, [1m/lpquote[22;0m, [1m/kecho[22;0m, 
  [1m/mecho[22;0m, [1m/more[22;0m, [1m/ptime[22;0m, [1m/qecho[22;0m, [1m/quiet[22;0m, [1m/quitdone[22;0m, [1m/redef[22;0m, [1m/shpause[22;0m, 
  [1m/sockmload[22;0m, [1m/sub[22;0m, [1m/visual[22;0m and [1m/wrapspace[22;0m [1mmacros[22;0m to set the values of the 
  corresponding [1mvariables[22;0m.  

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

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

&status
&status fields
&status_fields
&%status_fields
&visual bar
&visual line
&status bar
&status_line
&status line

status line

  In [1mvisual[22;0m mode, the input and output windows are separated by a status line, 
  which by default looks something like this: 

    [1;7mMore 156[22;27m_[4mWorldName[24m____________(Read)_(Active: [4mn[24m)_(Log)_(Mail)_(Over)_12:34

    * "[1mMore[22;0m" indicates how many [1mmore[22;0m lines of text are waiting to be seen. 
    * "<[4mWorldName[24m>" is the name of the [1mforeground[22;0m [1msocket[22;0m's world.  
    * "(Read)" indicates that keyboard input is being read by [1mread()[22;0m.  
    * The "(Active: [4mn[24m)" indicator shows the number of [1msockets[22;0m with unseen 
      text.  
    * "(Log)" indicates that there is one or more [1mlog[22;0m file open.  
    * "(Mail)" or "Mail [4mn[24m" indicates the number of files named by [1m%MAIL[22;0m or 
      [1m%MAILPATH[22;0m that contain unread mail.  
    * "(Over)" indicates that typed characters will overstrike instead of 
      insert (that is, [1m%insert[22;0m is off).  
    * The current time is displayed at the right end of the status line.  

Configuring the status line

  The [1mstatus_fields[22;0m [1mvariable[22;0m contains a list of descriptions of fields to be 
  displayed on the status line.  Each description consists of: 

    * an optional field name 
    * an optional ":" and number indicating the field width 
    * an optional ":" and [1mattribute[22;0m 

  Fields without names are used to indicate padding between named fields.  
  Field names enclosed in quotes (", ', or `) are displayed literally; use the 
  \ character to escape a quote inside the string.  Field names beginning with 
  "@" correspond to internal states.  Other field names correspond to the 
  [1mvariable[22;0m with the same name.  TF will monitor the internal state or [1mvariable[22;0m 
  corresponding to each internal and [1mvariable[22;0m field, and update those fields 
  whenever the monitored item changes.  Also, the entire status line will be 
  updated whenever the screen is redrawn or the [1mstatus_fields[22;0m [1mvariable[22;0m is 
  modified.  

  The actual format of an internal or [1mvariable[22;0m field displayed on the status 
  line is determined by evaluating the [1mexpression[22;0m contained in the [1mvariable[22;0m 
  status_int_<[4mname[24m> (for internal state @<[4mname[24m>) or status_var_<[4mname[24m> (for 
  variable <[4mname[24m>).  Also, for [1mvariable[22;0m fields, if status_var_<[4mname[24m> is not 
  set, the value of the [1mvariable[22;0m will be displayed directly.  Changing a 
  format variable will not cause the status line to update; to force an 
  update, you can "[1m/dokey[22;0m redraw" (^L), or "[1m/test[22;0m [1mstatus_fields[22;0m := 
  [1mstatus_fields[22;0m".  

  A field's width determines how many columns it will take up on the screen.  
  If the width of a string literal field field is omitted, it defaults to the 
  length of the string literal.  One other field width may be omitted, which 
  means that field will use whatever columns are unused by the other fields.  
  Normally, fields are left-justified within the width, but a negative field 
  width will right-justify the field within the absolute value of the width.  
  If the formatted text is wider than the field width, it will be truncated to 
  fit within the specified width.  Fields may also be truncated if they would 
  not fit on the screen.  

  The [1mattributes[22;0m are applied to the field text when it is displayed, but are 
  not applied to the padding used to bring the field to the specified width.  

  Any [1mvariable[22;0m may be monitored, but there is a fixed list of internal 
  statuses.  The internal statuses available are: 

  @more   Updated when the number of unseen lines changes.  
  @world  Updated when when the [1mforeground[22;0m [1mworld[22;0m changes.  During the 
          format expression, the [1mcurrent socket[22;0m is the new [1msocket[22;0m.  
  @read   Updated when entering or exiting a [1mread()[22;0m function call.  
  @active 
          Updated when the number of active [1mworlds[22;0m changes.  During the format 
          expression, the [1mcurrent socket[22;0m is the [1msocket[22;0m that became active.  
  @log    Updated when the number of open [1mlog[22;0m files changes.  
  @mail   Updated when mail arrives (See "[1mmail[22;0m").  
  @clock  Updated every minute, at 0 seconds past the minute.  

  The entire status line, including padding, is displayed with the [1mattributes[22;0m 
  given by [1m%status_attr[22;0m, which is none by default.  Individual field 
  [1mattributes[22;0m are combined with [1m%status_attr[22;0m [1mattributes[22;0m.  

  To bring fields up to their specified width, they are padded with 
  [1m%status_pad[22;0m, which is "_" by default.  By setting [1mstatus_pad[22;0m to " " and 
  [1mstatus_attr[22;0m to "r", you can create a status line that looks more like the 
  one in emacs or the irc client.  

  All this may sound rather complex, so an example might help.  The default 
  value of [1mstatus_fields[22;0m is: 

    @more:8:Br :1 @world :1 @read:6 :1 @active:11 :1 @log:5 :1 @mail:6 :1 insert:6 :1 @clock:5
    

  and the corresponding format [1mvariables[22;0m are: 

    [1m/set[22;0m status_int_more \
         [1mmoresize()[22;0m == 0 ? "" : \
         [1mmoresize()[22;0m > 9999 ? "MuchMore" : \
         [1mpad[22;0m("More", 4, [1mmoresize()[22;0m, 4)
    [1m/set[22;0m status_int_world   [1m${world_name}[22;0m
    [1m/set[22;0m status_int_read    [1mnread()[22;0m ? "(Read)" : ""
    [1m/set[22;0m status_int_active  [1mnactive()[22;0m ? [1mpad[22;0m("(Active:",0,[1mnactive()[22;0m,2,")") : ""
    [1m/set[22;0m status_int_log     [1mnlog()[22;0m ? "(Log)" : ""
    [1m/set[22;0m status_int_mail \
         ![1mnmail[22;0m() ? "" : \
         [1mnmail[22;0m()==1 ? "(Mail)" : \
         [1mpad[22;0m("Mail", 0, [1mnmail[22;0m(), 2)
    [1m/set[22;0m status_var_insert  [1minsert[22;0m ? "" : "(Over)"
    [1m/set[22;0m status_int_clock   [1mftime[22;0m("%I:%M", [1mtime()[22;0m)
    

  The first field is "@more:8:Br".  So, whenever the number of unseen lines 
  changes, TF looks for the [1mvariable[22;0m status_int_more, and evaluates the 
  [1mexpression[22;0m it contains.  The result of the [1mexpression[22;0m is printed in the 
  first 8 columns of the status line, with [1mattributes[22;0m "Br" (bold and reverse). 
  The [1mexpression[22;0m was carefully written so that it will never be more than 8 
  characters, because it would be confusing to generate something like 
  "More:12345" and then have it truncated to "More:123" because of the field 
  width of 8.  

  Since the "@world" field has no explicit width, its width is determined 
  dynamically.  The fields on its left are pushed to the left side of the 
  screen, the fields on its right are pushed to the right side of the screen, 
  and the "@world" field uses whatever space remains in the middle.  

  The unnamed fields with width 1 are used to display a pad character between 
  the named fields.  
#prompt example

  Another example: Say your mud has a [1mprompt[22;0m like "H:42 M:17> " that shows 
  your hit points and mana, and you want it displayed on the status line like 
  " 42, 17".  To do this, add "hp_mana:7" to the [1mstatus_fields[22;0m [1mvariable[22;0m, and 
  define a [1mprompt[22;0m [1mhook[22;0m: 

    [1m/def[22;0m [1m-mregexp[22;0m [1m-h[22;0m"PROMPT ^H:([^ ]*) M:([^ ]*)> $" hp_mana_hook = \
        [1m/set[22;0m hp=[1m%P1[22;0m%; \
        [1m/set[22;0m mana=[1m%P2[22;0m%; \
        [1m/set[22;0m hp_mana=[1m$[[22;0m[1mpad[22;0m(hp, 3, ",", 0, mana, 3)]%; \
        [1m/test[22;0m [1mprompt[22;0m([1m{*}[22;0m)

#

  See: [1mvisual[22;0m 

&subs
&substitution

substitution

  Before a [1mmacro[22;0m body or arguments to [1m/eval[22;0m are executed, special character 
  sequences are replaced with new text as described below.  

#%;
#newline
#command separator
Command separation. 
%;

  Separates commands within a [1mmacro[22;0m body.  See [1mevaluation[22;0m.  

#%|
Pipe. 
%|

  Separates commands within a [1mmacro[22;0m body, and connects the output of the first 
  to the input of the second.  See [1mevaluation[22;0m.  

#character substitution
#\n
#\\
#ascii
Character substitution. 
\[4mn[24m
\[4mc[24m

  In the first form, the character whose ASCII code is <[4mn[24m> is substituted.  If 
  <[4mn[24m> starts with "0x", it is interpreted as a hexadecimal number; otherwise, 
  if <[4mn[24m> starts with "0", it is interpreted as octal; otherwise, it is 
  interpreted as decimal.  In the second form, the character <[4mc[24m> is 
  substituted.  This is useful for escaping any special meaning <[4mc[24m> has; in 
  particular, "\\" is substituted with "\".  If the [1mvariable[22;0m [1m%{backslash}[22;0m is 
  off, the \[4mc[24m form does not have this special interpretation.  

#//
Slash compression. 
//... 

  If [1m%{oldslash}[22;0m is on, sequences of slashes are replaced with a sequence of 
  one fewer slashes.  A single slash, however, is left alone.  This feature 
  remains for backward compatibility only; you are encouraged to turn 
  [1m%{oldslash}[22;0m off to disable this.  

#$[
#$[]
[1mExpression[22;0m evaluation. 
$[[4m[1mexpression[22;0m[24m]

  The <[4m[1mexpression[22;0m[24m> is evaluated and its string value is substituted in its 
  place.  See "[1mexpressions[22;0m".  

#$(
#$()
#command subs
#command substitution
Command substitution. 
$([4mcommand[24m)

  <[4mCommand[24m> is [1mevaluated[22;0m as if it were the body of a [1mmacro[22;0m: it goes through 
  [1msubstitution[22;0m, and is executed in a new [1mscope[22;0m.  If <[4mcommand[24m> contains any ')' 
  characters, they must be escaped by preceding them with '\' so they are not 
  interpreted as the end of the substitution.  The echoed output of <[4mcommand[24m> 
  is substituted in place of the $(...) construct (much like `...` in most 
  shells).  If <[4mcommand[24m> produces more than one line of output, they will be 
  concatenated, with a space between each, to form one line.  

  Example: 

          [1m/def[22;0m showver = :is using tf version $([1m/ver[22;0m)

  could be used to tell other mudders what version of tf you're using.  

#$
#${
#${}
#macro subs
#macro substitution
[1mMacro[22;0m substitution. 
${[4mname[24m}
$[4mname[24m$

  The body of the [1mmacro[22;0m <[4mname[24m> is substituted.  The second form is supported 
  only for backward compatibility, and its use is discouraged.  In the first 
  form, the brackets may be omitted if the subsequent text could not be 
  confused as part of the name.  

  Example: The text "${foo}" would be replaced with the body of the [1mmacro[22;0m 
  named "foo".  

#$$
Dollar compression. 
$$... 

  Sequences of '$'s are replaced by a sequence of one fewer '$'s.  A single 
  '$', however, is left alone, unless it introduces one of the substitutions 
  described above.  This is used to put a literal '$' in text that goes 
  through macro substitution.  

#%
#%{
#%{}
#%n
#%0
#%1
#%R
#%L
#%*
#%#
#%?
#variable subs
#variable substitution
#positional parameters
#arguments
#parameters
#variables and parameters
Variable and Argument substitution. 
%[4mselector[24m
%{[4mselector[24m}
%{[4mselector[24m-[4mdefault[24m}

  The value of a [1mvariable[22;0m or an argument to the [1mmacro[22;0m is substituted, as 
  determined by <[4mselector[24m>.  The brackets are recommended for clarity, but may 
  be omitted if there is no default and the text following it can not be 
  misinterpreted as part of the selector.  The selector can be any of: 

  <[4mname[24m>  The value of the [1mvariable[22;0m <[4mname[24m> is substituted.  Names are 
          case sensitive.  

  0       selects the name of the executing macro.  (Before version 
          4.0, "0" was equivalent to "*").  

  #       selects the count of positional parameters.  

  *       selects all positional parameters.  

  ?       selects the return value of the most recently executed 
          command (builtin or macro).  

  1, 2, 3, etc.  
          selects the corresponding positional parameter.  There is no maximum 
          parameter number; any number greater than [1m%{#}[22;0m will simply produce 
          an empty substitution.  

  -1, -2, -3, etc.  
          selects all positional parameters except the first, all except the 
          first two, all except the first three, etc.  

  L1, L2, etc.  
          selects the last positional parameter, second-to-last, etc.  "L" is 
          the same as "L1".  

  -L1, -L2, etc.  
          selects all positional parameters except the last, all except the 
          last two, etc.  "-L" is the same as "-L1".  

  P[4mn[24m      selects the text matching the <[4mn[24m>th parenthesized 
          subexpression from the last [1mregular expression[22;0m match.  See [1m%P[4mn[24m[22;0m.  

  R       selects a positional parameter at random.  (see also: 
          [1mrand()[22;0m) 

  [1mVariable[22;0m names are case sensitive; "L", "R", and "P" selectors are not.  No 
  substitutions are performed on <[4mselector[24m>.  

  If the substitution determined by the <[4mselector[24m> would be empty, and a 
  <[4mdefault[24m> value is given, the default will be substituted instead.  Thus 
  "[1m%{1[22;0m-foofle}" is replaced with the first word if there is one, or "foofle" 
  if not.  The <[4mdefault[24m> value may contain [1mvariable[22;0m, [1mmacro[22;0m, [1mexpression[22;0m, and 
  [1mcommand[22;0m [1msubstitutions[22;0m.  

  The meaning of "positional parameters" depends on how the [1mmacro[22;0m was called.  
  If called with the traditional "/[4mname[24m ..." command syntax, each 
  space-separated word is a positional parameter.  If called with the 
  "[4mname[24m(...)" [1mfunction syntax[22;0m, each function argument is a positional 
  parameter; if more than one is selected, they are concatenated, with a space 
  between each.  If called as a [1mtrigger[22;0m, the positional parameters are the 
  words in the text that [1mtrigger[22;0med the [1mmacro[22;0m.  In a [1mhook[22;0m call, the positional 
  parameters are the hook arguments.  In an [1m/eval[22;0m statement, they are 
  inherited from the caller.  

  Note that in [1mexpressions[22;0m, it is easiest to omit the % and just use the 
  {[4mselector[24m[-[4mdefault[24m]} part.  If the selector is a variable name and no 
  default is desired, the name may be used directly in an [1mexpressions[22;0m without 
  % or {...}.  

#%{PL}
#%PL
#%{PR}
#%PR
#%{Pn}
#%Pn
#%P
#subexpressions
#regexp subexpressions
Regexp subexpressions. 
%{P[4mn[24m}
%{PL}
%{PR}

  This is actually a special case of [1mvariable substitution[22;0m.  The [1m%P[22;0m variables 
  get their values from the last successful regexp match in scope.  [1m%P0[22;0m 
  expands to the text matched by the entire [1mregexp[22;0m.  [1m%P[4mn[24m[22;0m expands to the text 
  matched by the <[4mn[24m>th parenthesised subexpression of the [1mregexp[22;0m.  [1m%PL[22;0m and [1m%PR[22;0m 
  expand to the text to the left and right, respectively, of the text matched 
  by the entire [1mregexp[22;0m.  The "scope" of a [1mregexp[22;0m match is the lifetime of the 
  [1mmacro[22;0m expansion it [1mtrigger[22;0med, [1mhook[22;0med, or in which it occurred (i.e., with 
  [1mregmatch()[22;0m).  

  For example, after the text "Jabba the Hutt goes east." matches the [1mregexp[22;0m 

    " goes ([^ ]*)\.$"

  then the following expansions will be available until the [1mmacro[22;0m exits: PL = 
  "Jabba the Hutt"; P0 = " goes east."; P1 = "east".  

  The number <[4mn[24m> can be anything from 0 to 9; other values will be silently 
  ignored.  If there is no subexpression corresponding to <[4mn[24m>, the 
  substitution will be ignored.  When parentheses are nested, <[4mn[24m> refers to 
  the order of the opening parentheses.  

  The [1m%P[4mn[24m[22;0m subs will always refer to the first [1mregexp[22;0m match on the line, even 
  if a partial [1mhilite[22;0m ([1m/def[22;0m -P) causes the [1mregexp[22;0m to be applied more than 
  once.  

#%%
#percent compression
Percent compression. 
%%... 

  Sequences of '%'s are replaced by a sequence of one fewer '%'s.  A single 
  '%', however, is left alone unless it introduces one of the substitutions 
  described above.  This is used to put a literal '%' in text that goes 
  through macro substitution.  

#
Examples 
  Here are a couple of simple examples.  

  Definition: [1m/def[22;0m advice = whisper [1m%1[22;0m = Let the wookie win. 
  Command: /advice R2D2
  Sends: whisper R2D2 = Let the wookie win. 

  Definition: [1m/set[22;0m ending=meister
  Definition: [1m/def[22;0m greet = :waves to [1m%{1[22;0m-Jack}%{ending}. 
  Command: /greet
  Sends: :waves to Jackmeister. 
  Command: /greet Dave
  Sends: :waves to Davemeister. 

  For some more complex examples, look at the files in TFLIBDIR.  

  See: [1mevaluation[22;0m, [1mexpressions[22;0m 

&summary

summary

  See "[1mintro[22;0m" for basic information on using TF.  See "[1mtopics[22;0m" for a list of 
  other help topics.  See "[1mcommands[22;0m" for a complete list of TF builtin 
  commands.  See "[1m/help[22;0m" for instructions on using [1m/help[22;0m.  

  If you are having problems with TF and wish to contact the author, see 
  "[1mproblems[22;0m".  

  If you are having trouble reading the help sections because text is 
  scrolling off the screen, try typing "[1m/more[22;0m on" before [1m/help[22;0m, and then press 
  [1mTAB[22;0m at a "[1m--More--[22;0m" prompt when you're ready to continue.  

&command line
&commandline
&startup
&initialization
&invocation
&tf

tf

  Syntax: 

  tf [-L<[4mdir[24m>] [-f[<[4mfile[24m>]] [-c<[4mcommand[24m>] [-vlqn] [<[4mworld[24m>]
  tf [-L<[4mdir[24m>] [-f[<[4mfile[24m>]] [-c<[4mcommand[24m>] [-vlq] <[4mhost[24m> <[4mport[24m> 
  ____________________________________________________________________________

  At startup, TF takes the following steps: 

    * Initializes [1mspecial variables[22;0m.  Any [1mvariables[22;0m defined in the 
      environment will override TF's default values for the [1mvariables[22;0m with the 
      same name.  
    * Loads commands from the [1mstandard macro library (stdlib.tf)[22;0m, the 
      optional [1mlocal macro library (local.tf)[22;0m, and your [1mpersonal configuration 
      file[22;0m (see [1mtfrc[22;0m).  
    * Executes <[4mcommand[24m>, if one was given.  
    * Enables [1mvisual mode[22;0m if -v was not given and [1m%visual[22;0m has not been 
      explicitly set to "off".  
    * Tries to connect to <[4mworld[24m>, or <[4mhost[24m> <[4mport[24m>.  If no [1mworld[22;0m is 
      given, and the -n option is not given, TF will try to connect to the 
      first [1mworld[22;0m defined with [1maddworld()[22;0m in the configuration file(s).  If no 
      [1mworlds[22;0m are defined, or TF can not connect to the specified [1mworld[22;0m, TF 
      will start up in unconnected mode.  

  [1mOptions:[22;0m 

  -L<[4mdir[24m> 
          Use <[4mdir[24m> instead of [1m%TFLIBDIR[22;0m as library directory.  
  -f<[4mfile[24m> 
          Load <[4mfile[24m> instead of the normal personal config file.  
  -f      Do not load any personal config file at startup.  
  -c<[4mcommand[24m> 
          Execute <[4mcommand[24m> after loading config file.  <[4mCommand[24m> is treated 
          as if it had been typed on the tf command line (i.e., the value of 
          [1m%sub[22;0m is significant).  
  -n      Do not connect to a [1mworld[22;0m automatically at startup if no 
          <[4mworld[24m> or <[4mhost[24m>/<[4mport[24m> are specified.  
  -l      Disable [1mautomatic login[22;0m.  (see: [1mlogin[22;0m) 
  -q      Enable [1mquiet login[22;0m.  (see: [1m%quiet[22;0m) 
  -v      Disable automatic switch to [1mvisual mode[22;0m.  

  The library directory is determined by the first of the following which has 
  a value: -L option; [1m%TFLIBDIR[22;0m environment [1mvariable[22;0m; or, compiled-in default. 
  The standard library file is determined by the first of the following which 
  has a value: [1mTFLIBRARY[22;0m environment [1mvariable[22;0m; or, appending "/stdlib.tf" to 
  [1m%TFLIBDIR[22;0m.  

  TF honors several [1mlocale[22;0m categories, which can be set to make TF work better 
  with languages other than English.  See [1mlocale[22;0m.  

  See [1mhttp://tf.tcp.com/~hawkeye/tf/[22;0m for the latest info on TF.  

  See also: [1mintro[22;0m, [1mtfrc[22;0m, [1mlibrary[22;0m, [1mworlds[22;0m, [1m/addworld[22;0m 

&tfout
&tferr
&streams
&tfio

tfio

  TF normally does its output through "streams", which are analagous to the 
  streams of C stdio.  

  Output from most tf commands, including [1m/echo[22;0m, are output to the "[1mtfout[22;0m" 
  stream, which is normally attached to the screen.  [1mtfout[22;0m may be redirected 
  with a [1mcommand /quote[22;0m, [1m$() command substitution[22;0m, or [1m%| pipe[22;0m.  

  Tf error messages, hook messages, and the output of "[1m/echo -e[22;0m" are output to 
  the "[1mtferr[22;0m" stream, which is always attached to the screen, and may not be 
  redirected.  

  Text from a world or "[1m/echo -w[22;0m" is sent to a [1mstream[22;0m for that world.  Text 
  sent to a world [1mstream[22;0m will be stored in the [1mhistory[22;0m of that world.  If that 
  world is the [1mforeground[22;0m world, the text is sent to the screen immediately; 
  otherwise, it will not be displayed until world is brought into the 
  [1mforeground[22;0m.  

  Commands that read input (using [1mtfread()[22;0m) read by default from "[1mtfin[22;0m", which 
  is normally attached to the keyboard.  [1mtfin[22;0m may be redirected with a [1m%| 
  pipe[22;0m.  

  All [1mstreams[22;0m have a handle which can be used as an argument to the [1mtfio[22;0m 
  functions.  The handles for [1mtfin[22;0m, [1mtfout[22;0m, and [1mtferr[22;0m are "i", "o", and "e", 
  respectively.  The handles for [1mstreams[22;0m opened with [1mtfopen()[22;0m are integers.  

tfopen()
  The [1mtfopen[22;0m([4mname[24m, [4mmode[24m) function can be used to open arbitrary [1mstreams[22;0m.  If 
  called with no arguments, [1mtfopen()[22;0m opens an unnamed "q" mode [1mstream[22;0m.  The 
  <[4mmode[24m> argument describes the usage of the [1mstream[22;0m: 

  "w"     Open a file "<[4mname[24m>" for writing.  Write operations will 
          overwrite existing file contents, if any.  
  "a"     Open a file "<[4mname[24m>" for appending.  Write operations will 
          occur after existing file contents, if any.  
  "r"     Open a file "<[4mname[24m>" for reading.  (see also: "[1m/quote '[22;0m").  
  "p"     Execute a shell command "<[4mname[24m>" and read its output (see 
          also: "[1m/quote ![22;0m").  
  "q"     Open a queue for reading and writing.  The <[4mname[24m> argument 
          will appear in the output of [1m/liststreams[22;0m, but has no other meaning. 

  A "q" mode [1mstream[22;0m may be thought of as a place to hold lines for passing 
  between two or more commands.  

  If successful, the [1mtfopen()[22;0m function returns a positive number which is the 
  handle of the new [1mstream[22;0m, which should be used in subsequent calls to 
  [1mtfread()[22;0m, [1mtfwrite()[22;0m, and [1mtfclose()[22;0m.  If it fails, the [1mtfopen()[22;0m function 
  returns -1.  

  A call to [1mtfwrite()[22;0m or [1mtfread()[22;0m on a [1mstream[22;0m opened with a mode that does not 
  allow that operation will return -1.  

  The [1m/liststreams[22;0m command will display a list of open [1mstreams[22;0m.  

tfclose()
  When a [1mstream[22;0m opened by [1mtfopen()[22;0m is no longer needed, it should be closed 
  with [1mtfclose[22;0m([4mhandle[24m), which will flush the [1mstream[22;0m and release its resources. 
  [1mtfclose()[22;0m can be used on the [1mtfout stream[22;0m (handle "o") within a [1mmacro[22;0m body 
  to prevent further output from subsequent commands in that [1mmacro[22;0m body; 
  closing the [1mtfin stream[22;0m (handle "i") will prevent further reads; and closing 
  the [1mtferr stream[22;0m (handle "e") is not allowed.  

tfwrite()
  The [1mtfwrite[22;0m([4mhandle[24m, [4mline[24m) function writes a <[4mline[24m> of text to the [1mstream[22;0m 
  designated by <[4mhandle[24m>.  If <[4mhandle[24m> is omitted, the [1mtfout stream[22;0m is used 
  (so [1mtfwrite[22;0m([4mline[24m) is equivalent to [1mecho[22;0m([4mline[24m)).  

  If an OS file (mode "w" or "a") is set to autoflush (the default), then each 
  line written is flushed to the file immediately.  If you are writing a large 
  number of lines, it is more efficient to disable autoflushing with 
  [1mtfflush[22;0m([4mhandle[24m, "off"), and manually force a flush with [1mtfflush[22;0m([4mhandle[24m) or 
  [1mtfclose[22;0m([4mhandle[24m) after writing the large block.  [1mtfflush()[22;0m has no meaning on 
  files of mode "p", "q", or "r".  [1mStreams[22;0m are flushed automatically when 
  closed.  

tfread()
  The [1mtfread[22;0m([4mhandle[24m, [4mvariable[24m) function reads a line from the [1mstream[22;0m 
  designated by <[4mhandle[24m>.  If <[4mhandle[24m> is omitted, the [1mtfin stream[22;0m is used.  
  If successful, the line is assigned to <[4mvariable[24m>, and [1mtfread()[22;0m returns the 
  (non-negative) length of the line.  If <[4mvariable[24m> did not already exist, it 
  is created at the global level, as if by [1m/set[22;0m.  If there are no lines 
  available to read, or an error occurs, [1mtfread()[22;0m returns -1.  For "r" and "p" 
  mode [1mstreams[22;0m, a -1 return value indicates end-of-file; the only valid 
  operation on the [1mstream[22;0m after that is [1mtfclose()[22;0m.  But for a "q" mode [1mstream[22;0m, 
  a -1 return value may just mean there are currently no lines in the queue; 
  more lines may be added by [1mtfwrite()[22;0m, and then [1mtfread()[22;0m will be able to read 
  them.  

Keyboard Reading
  [1mtfread()[22;0m from the keyboard is special.  It can only be done from a command 
  line command; trying to do it directly or indirectly from a trigger, hook, 
  keybinding, or process is an error, and will make the [1mtfread()[22;0m return -1.  
  It reads a line of input from the keyboard until the newline key is pressed 
  or "[1m/dokey[22;0m newline" is executed.  During the read, all existing [1mkeybindings[22;0m 
  continue to work normally.  Any text already in the input buffer is not 
  cleared when the read starts.  Text entered after the read starts is 
  appended to the existing text, and when the read ends, its result is the 
  entire input buffer.  Lines entered during a read are not saved in the input 
  [1mhistory[22;0m (but you can use "[1m/recordline[22;0m -i" to save them explicitly).  

  A read from the keyboard (and the [1mmacro[22;0m that called it) can be interrupted 
  with a SIGINT, normally generated by typing CTRL-C.  

  During a keyboard read, if a [1mmacro[22;0m calls [1m/dokey[22;0m newline, the newline will 
  not be executed immediately, but will be held until the rest of the commands 
  in the [1mmacro[22;0m are processed.  For example, consider the keybinding "[1m/def[22;0m 
  [1m-b[22;0m'^[^M' = /dokey newline%; /send go".  Normally, typing ^[^M would execute 
  the current input buffer, then send "go" to the server.  But during a 
  keyboard read, typing ^[^M would send "go" first, and then do the newline 
  that completes the read.  

  The library file [1mtextutil.tf[22;0m defines several commands that are useful with 
  [1mtfio[22;0m.  

  See: [1minterface[22;0m, [1m/liststreams[22;0m, [1m/input[22;0m, [1mexpressions[22;0m, [1mnread()[22;0m, [1mfunctions[22;0m, 
  [1mtextutil.tf[22;0m 

&config
&configuration
&customization
&customizing
&tfrc
&tinytalk
&.tinytalk
&.tfrc

.tfrc

  At [1mstartup[22;0m, TF attempts to load and execute commands from the personal 
  config file named "~/.tfrc", "~/tfrc", "./.tfrc" or "./tfrc".  This file can 
  contain any commands you want executed automatically when TF starts.  

  Some useful commands to include in your personal config file: 

  [1m/addworld[22;0m 
          Define a [1mworld[22;0m.  TF will automatically connect to the first [1mworld[22;0m if 
          not started with the "-n" option.  
  [1m/def[22;0m    Define a [1mmacro[22;0m (including [1mtriggers[22;0m, [1mhilites[22;0m, [1mgags[22;0m, 
          [1mkeybindings[22;0m, and [1mhooks[22;0m).  
  [1m/set[22;0m    Set a [1mvariable[22;0m.  There are many [1mspecial variables[22;0m that 
          change the behavior of tf, listed under "[1mspecial variables[22;0m".  
  [1m/load[22;0m   Load commands from another file.  
  [1m/require[22;0m 
          Load a library file.  

  [1m%TFLIBDIR[22;0m contains a sample "tfrc" file that you may want to copy and modify 
  to fit your tastes.  

  For backward compatibility, TF will load ~/.tinytalk if it exists.  The use 
  of ~/.tinytalk is discouraged.  

  See: [1mstartup[22;0m, [1mlibrary[22;0m, [1mspecial variables[22;0m, [1m/load[22;0m 

&timer
&timing

timing

  See: [1mprocesses[22;0m, [1m/repeat[22;0m, [1m/quote[22;0m, utilities ([1m/at[22;0m, [1m/tick[22;0m), [1m%clock[22;0m, [1m/time[22;0m.  
&tools
&/reedit
&/edmac
&/edvar
&/edworld
&/name
&/getline
&/xtitle
&xterm
&tools.tf

tools.tf

  Usage: 

  [1m/REQUIRE[22;0m tools.tf
  ____________________________________________________________________________

  [1m/EDMAC[22;0m <[4mmacroname[24m> 
  [1m/EDVAR[22;0m <[4mvariablename[24m> 
  [1m/EDWORLD[22;0m <[4mworldname[24m> 
          Stick an existing [1mmacro[22;0m, [1mvariable[22;0m, or [1mworld[22;0m definition in the input 
          window for editing.  

  [1m/NAME[22;0m [<[4mname[24m>] 
          Change your character name (on a TinyMUD style mud).  

  [1m/GETLINE[22;0m <[4mn[24m> 
          Grab the <[4mn[24m>th line from [1mhistory[22;0m and stick it in the input buffer.  

  [1m/XTITLE[22;0m <[4mtext[24m> 
          Put <[4mtext[24m> on the titlebar of an xterm.  

  See: [1m/sh[22;0m, [1m/edit[22;0m, [1m/recall[22;0m, [1mtfrc[22;0m 

&triggers

triggers

  Before we get into the gory details, here's a simple example of a trigger: 

    [1m/def[22;0m [1m-t[22;0m"{*} has arrived." greet = :waves to [1m%1[22;0m.

  This command defines a macro called "greet".  Whenever text like "Bob has 
  arrived." is received, /greet will be executed automatically, sending the 
  text ":waves to Bob." to the server.  

  Associated commands: 

  [1m/def[22;0m    define a [1mmacro[22;0m with any fields 
  [1m/trig[22;0m   define a [1mtrigger[22;0m [1mmacro[22;0m 
  [1m/trigp[22;0m  define a [1mtrigger[22;0m [1mmacro[22;0m with [1mpriority[22;0m 
  [1m/trigc[22;0m  define a [1mtrigger[22;0m [1mmacro[22;0m with probability 
  [1m/trigpc[22;0m 
          define a [1mtrigger[22;0m [1mmacro[22;0m with probability and [1mpriority[22;0m 
  [1m/gag[22;0m    define a [1mtrigger[22;0m [1mmacro[22;0m to [1mgag[22;0m text 
  [1m/hilite[22;0m 
          define a [1mtrigger[22;0m [1mmacro[22;0m to [1mhilite[22;0m text 
  [1m/trigger[22;0m 
          call a [1mtrigger[22;0m [1mmacro[22;0m manually 
  [1m/substitute[22;0m 
          modify the text that invoked the [1mtrigger[22;0m 

  [1mTriggers[22;0m are a method of calling a [1mmacro[22;0m based on incoming text.  When a 
  line of text from a [1msocket[22;0m matches the [1mtrigger[22;0m [1mpattern[22;0m of a [1mmacro[22;0m, that 
  [1mmacro[22;0m becomes a candidate for automatic execution.  

  If multiple [1mmacros[22;0m have [1mtriggers[22;0m which match the same text, one or more are 
  chosen for execution as described under "[1mpriority[22;0m".  

  The <[4mtext[24m> which [1mtriggers[22;0m a [1mmacro[22;0m is given to the [1mmacro[22;0m as arguments, as if 
  it had been called with ``/<[4mmacro[24m> <[4mtext[24m>''.  Positional parameters refer 
  the the corresponding word in the [1mtrigger[22;0ming text (see also: [1m%n[22;0m).  If the 
  [1mtrigger[22;0m is a [1mregexp[22;0m, subexpression parameters refer to the text matched by 
  the corresponding parenthesised subexpression (see also: [1m%Pn[22;0m).  

  If the selected [1mmacro[22;0m(s) have display [1mattributes[22;0m, the [1mattributes[22;0m are used to 
  display the text which [1mtrigger[22;0med the [1mmacro[22;0m.  

  If a [1mmacro[22;0m has the world field set, it can only be [1mtrigger[22;0med by text from 
  that world.  

  If a [1mmacro[22;0m has a probability less than 100%, it might not be executed even 
  if it is [1mtrigger[22;0med.  

  [1mTriggers[22;0m can be disabled by turning the [1m%{borg}[22;0m flag off.  

  If the [1m%{background}[22;0m flag is turned off, text from [1mbackground[22;0m [1msockets[22;0m will 
  not cause [1mtrigger[22;0ming until that [1msocket[22;0m is brought into the [1mforeground[22;0m.  

  [1mTriggers[22;0m can also be invoked manually with the command [1m/trigger[22;0m.  

  The [1m/def[22;0m command is the only way to define a multi-shot [1mtrigger[22;0m.  All other 
  commands which define [1mtriggers[22;0m will create permanent [1mtriggers[22;0m.  

  Note that tf may run slowly if there are many [1mtriggers[22;0m defined, since every 
  [1mtrigger[22;0m must be compared against every received line of text.  Choose your 
  [1mtriggers[22;0m carefully.  See also "[1mpatterns[22;0m".  

  [1mTriggers[22;0m are only matched against normal lines.  To have a macro invoked by 
  a [1mprompt[22;0m, use the [1mprompt[22;0m [1mhook[22;0m.  

  Triggers are not expanded for variable substitutions or anything else.  To 
  make a variable trigger, write a macro that redefines the trigger.  For 
  example, 

      /def set_victim = \
          /def -t"%{1} has arrived." kill_victim = \
              kill %%{1}
    

  Then, to change the victim to "Bill", execute "/set_victim Bill".  

  See also: [1mpatterns[22;0m, [1mmacros[22;0m, [1mgags[22;0m, [1mhilites[22;0m, [1mhooks[22;0m, [1mpriority[22;0m 

&util
&utils
&/alias
&/at
&/complete
&completion
&/putfile
&map
&/psh
&/rwho
&spell
&/spell_line
&space_page
&/speedwalk
&tintin
&/tick
&/watch
&worldqueue
&world-q
&esc-w
&utilities

utilities

  The library directory [1m%{TFLIBDIR}[22;0m contains many useful utility files ending 
  in ".tf".  To use any one of them, simply [1m/load[22;0m or [1m/require[22;0m the file.  For 
  example, to enable ESC-TAB completion automatically, just "[1m/require[22;0m 
  completion.tf" from your [1m.tfrc[22;0m file.  Some of the more useful files: 

  alias.tf 
          [1m/alias[22;0m, etc: create commands without '/'.  
  at.tf   [1m/at[22;0m: execute commands at a specified time.  
  complete.tf 
          Automagic word completion.  
  filexfer.tf 
          [1m/putfile[22;0m, [1m/getfile[22;0m: transfer files to/from a mud.  
  kb-bash.tf 
          Keybindings similar to those in bash.  
  kb-emacs.tf 
          Keybindings similar to those in emacs.  
  kb-os2.tf 
          Extra default key bindings for OS/2 keyboards.  
  kbbind.tf 
          Default [1mkeybindings[22;0m.  
  kbfunc.tf 
          Macros used by kbbind.tf.  
  map.tf  Mapping commands (like tintin).  
  psh.tf  [1m/psh[22;0m: like [1m/sh[22;0m, but uses your favorite shell.  
  [1mquoter.tf[22;0m 
          Various quoting [1mmacros[22;0m.  
  rwho.tf 
          Remote WHO from a mudwho server.  
  spc-page.tf 
          Old-style SPACE key scrolling at [1m--More--[22;0m prompt.  
  spedwalk.tf 
          Single character movement (like tintin).  
  spell.tf 
          Spelling checker.  
  tick.tf 
          Diku tick counter (like tintin).  
  tintin.tf 
          tintin-like commands.  
  tr.tf   [1m/tr[22;0m: character translation 
  watch.tf 
          [1m/watch[22;0m: Watch for a particular player.  
  world-q.tf 
          Keep track of active worlds.  

  There are also other files, not listed here.  

  For complete instructions on any of these utilities, see the help section 
  for that topic if there is one, or read the comments at the top of each 
  file.  Sorry, I haven't gotten around to documenting them very well.  

  Note to unix users: many library files were renamed in version 3.5, but the 
  old names still work (via soft links).  

&variables
&variable

variables

  Associated commands: 

  [1m/listvar[22;0m 
          list values of [1mvariables[22;0m.  
  [1m/set[22;0m    set the value of a global [1mvariable[22;0m 
  [1m/let[22;0m    set the value of a local [1mvariable[22;0m 
  [1m/setenv[22;0m 
          set the value of an environment [1mvariable[22;0m 
  [1m/unset[22;0m  unset a [1mvariable[22;0m 
  [1m/export[22;0m 
          move an global [1mvariable[22;0m to the environment 
  [1m/edvar[22;0m  edit a [1mvariable[22;0m's value 

  A TinyFugue [1mvariable[22;0m has a name and a value.  Names are case sensitive, and 
  should start with a letter and contain only letters, numbers, and 
  underscores.  A value can be any string, but special flag and numeric 
  [1mvariables[22;0m will automatically convert their value to an integer.  

  [1mVariables[22;0m may either be local, global, or exported.  Global [1mvariables[22;0m are 
  visible to all tf commands; they are defined with [1m/set[22;0m or [1m/setenv[22;0m, or 
  imported from the environment when tf starts.  Local [1mvariables[22;0m are created 
  with [1m/let[22;0m or assignment [1mexpressions[22;0m, and only exist in the scope in which 
  they were created.  Exported [1mvariables[22;0m are global [1mvariables[22;0m which are also 
  visible to subshells, so they can be used by commands [1m/sh[22;0m, the '!' option of 
  [1m/quote[22;0m, and file uncompression.  [1mVariables[22;0m are exported if they were defined 
  with [1m/setenv[22;0m, explicitly exported with [1m/export[22;0m, or imported from tf's parent 
  environment.  

  The value of a [1mvariable[22;0m can be obtained using a '%' substitution (see 
  "[1msubstitution[22;0m"), or by simply using its name in an [1mexpression[22;0m (see 
  "[1mexpressions[22;0m").  

  See "[1mspecial variables[22;0m" for a list of special variables.  

&worlds

worlds

  Associated commands: 

  [1m/addworld[22;0m 
          define a new world 
  [1m/world[22;0m  connect to a defined world 
  [1m/dc[22;0m     disconnect from a world 
  [1m/unworld[22;0m 
          undefine a world 
  [1m/purgeworld[22;0m 
          undefine a group of worlds 
  [1m/saveworld[22;0m 
          save world definitions to a file 
  [1m/loadworld[22;0m 
          load world definitions from a file 
  [1m/listworlds[22;0m 
          display world definitions 
  [1m/edworld[22;0m 
          edit a world definition 
  [1mworld_info()[22;0m 
          get world information 

#$world_name
#$world_character
#$world_password
#$world_host
#$world_port
#$world_mfile
#$world_type
#fields
  Fugue stores a list of "worlds" that it knows about.  Each world has several 
  fields associated with it: 

  name    a label used to refer to the world 
  type    an optional string for matching /def -T 
  character 
          optional login name 
  password 
          optional login password 
  host    server host address 
  port    server port number or name 
  mfile   optional [1mmacro[22;0m file 
  login   "1" if [1mautomatic login[22;0m is enabled for the world's [1msocket[22;0m, 
          "0" otherwise.  
  proxy   "1" if this world's [1msocket[22;0m is using a [1mproxy[22;0m, "0" otherwise.  

  The character name, password, and type are used by [1mautomatic login[22;0m, if the 
  [1m%{login}[22;0m flag is on.  

  The [1mmacro[22;0m file is [1mloaded[22;0m when a [1msocket[22;0m is opened to the world.  It can 
  contain any commands you want executed automatically when you connect to 
  that world.  If the flag [1m%{sockmload}[22;0m is on, this file will also be [1mloaded[22;0m 
  whenever you switch to a world with the SOCKETB and SOCKETF keys (see 
  [1msockets[22;0m, [1m/dokey[22;0m, [1mhooks[22;0m (CONNECT)).  

  World information can be accessed with the macro expansion 
  ${world_[4mfieldname[24m} or the [1mfunction[22;0m [1mworld_info[22;0m([4mworldname[24m, [4mfieldname[24m), where 
  <[4mfieldname[24m> is one of the fields described above.  

  For example: 
  [1m/eval[22;0m say I am [1m${world_character}[22;0m on [1m${world_name}[22;0m.  
  This would tell the rest of the world some stuff they probably don't care 
  about, namely the label your Fugue has assigned to the [1mcurrent[22;0m world and the 
  character name under which it logged on.  
#

  Fugue also keeps track of a world named "default", which is just a dummy 
  world with a character name and password, and optionally a [1mmacro[22;0m file.  If a 
  default world is defined, worlds without character, password, or file fields 
  will use the values from the default world.  

  See also: [1msockets[22;0m 

&
