EPIC
Enhanced
Programmable
IRC-II
Client

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
======Special Variables and Expandos======

In addition to normal variables created with [[ASSIGN]], and
the built-in [[SET]] variables, EPIC also supports a number
of reserved, dynamic variables, sometimes referred to as expandos.  They
are special in that the client is constantly updating their values
automatically.  There are also numerous variable modifiers available.

^     Modifier     ^    Description                                           ^
|$variable         |A normal variable, expanding to the first match of: \\ 1) a variable created with [[ASSIGN]] or @ \\ 2) an internal [[SET]] variable \\ 3) an environment variable \\ 4) an empty string              |
|$[num]variable    |Expands to the variables value, with 'num' width.  If the number is negative, the value is right-aligned. The value is truncated or padded to meet the width.              |
|$#variable        |Expands to the number of words in $variable. If $variable is omitted, it assumes $*              |
|$@variable        |Expands to the number of characters in $variable. if $variable is omitted, it assumes $*              |
|$($subvariable)   |This is somewhat similar to a pointer, in that the value of $subvar is taken as the name of the variable to expand to.  Nesting is allowed.              |
|${expression}     |Expands to the return value of the expression.  In addition, ${} permits the value to be embedded in another string unambiguously.              |
|$!history!        |Expands to a matching entry in the client's command history, wildcards allowed.              |
|$"some text"      |Uses 'text' as an input prompt, and returns the next line of text the user types (up to a <return>)              |
|$'some text'      |Uses 'text' as an input prompt, and returns the next key that the user presses.              |

Whenever an alias is called, these expandos are set to the arguments passed
to it.  If none of these expandos are used in the alias, or the $() form
shown above, any arguments passed will automatically be appended to the last
command in the alias.

^   Expando  ^     Description                                                  ^
|$*          |expands to all arguments passed to an alias                       |
|$n          |expands to argument 'n' passed to an alias (counting from zero)   |
|$n-m        |expands to arguments 'n' through 'm' passed to an alias           |
|$n-         |expands to all arguments from 'n' on passed to an alias           |
|$-m         |expands to all arguments up to 'm' passed to an alias             |
|$~          |expands to the last argument passed to an alias                   |

These variables are set and updated dynamically by the client.  The case of
$A .. $Z is important.  Also note that $A .. $Z can be overridden by [[ASSIGN]],
so it is usually good practice to make variable names 2 or more characters
long.

^   Variable    ^      Description                                               ^
|$,             |last person who sent you a [[MSG]]                 |
|$.             |last person to whom you sent a [[MSG]]                 |
|$:             |last person to join a channel you are on                 |
|$;             |last person to send a public message to a channel you are on                 |
|$A             |text of your [[AWAY]] message, if any                 |
|$B             |body of last [[MSG]] you sent                 |
|$C             |current channel                 |
|$D             |last person that [[notify command|NOTIFY]] detected a signon for                 |
|$E             |idle time                 |
|$F             |time client was started, $[[time function|time]]() format                 |
|$G             |value of [[set banner|BANNER]], expanded if [[set banner_expand|BANNER_EXPAND]] is on.                 |
|$H             |current server numeric being processed                 |
|$I             |channel you were last [[INVITE]]d to                 |
|$J             |client version text string                 |
|$K             |current value of [[set cmdchars|CMDCHARS]]                 |
|$L             |current contents of the input line                 |
|$M             |modes of current channel, if any                 |
|$N             |current nickname                 |
|$O             |value of [[set status oper|STATUS_OPER]] if you are an irc operator                 |
|$P             |if you are a channel operator in $C, expands to a '@'                 |
|$Q             |nickname of whomever you are [[QUERY]]ing                 |
|$R             |version of current server                 |
|$S             |current server name                 |
|$T             |target of current input (channel or [[QUERY]] nickname)                 |
|$U             |value of cutbuffer                 |
|$V             |client release date (numeric version string)                 |
|$W             |current working directory                 |
|$X             |your /[[userhost command|userhost]] $N address (user@host)                 |
|$Y             |value of REALNAME                 |
|$Z             |time of day (hh:mm)                 |
|$$             |a literal '$'                 |

For example, assume you have the following alias:

   alias blah { msg $D Hi there!  }

If /blah is passed any arguments, they will automatically be appended to the
[[MSG]] text.  For example:

   /blah oops                          /* command as entered */
   "Hi there! oops"                    /* text sent to $D */

One of the more confusing expandos to look at is the $() form.  It evaluates
the variable or function inside the parenthesis, and whatever is returned is
used as the name of the variable to expand.  For example:

   assign foo blah                     /* inside variable */
   assign blah 10                      /* real variable */
   /eval echo $($foo)                  /* $foo expands to "blah" */
   "10"                                /* $blah expands to "10" */

Another useful form is ${}.  In general, variables can be embedded inside
strings without problems, assuming the surrounding text could not be
misinterpreted as part of the variable name.  This form guarantees that
surrounding text will not affect the expression's return value.

   /eval echo foo$Nfoo                 /* breaks, looks for $nfoo */
   /eval echo foo${N}foo               /* ${N} returns current nickname */
   fooYourNickfoo                      /* returned by above command */
   /eval echo ${[foo]}bar              /* expression parser may be used */
   foobar                              /* returned by above command */