**ircII help: expressions**

This help file describes expresssions available in ${}, and the @, IF, WHILE, and FOREACH commands. Variable expressions are used to perform arithmetic, string and boolean operations. Their syntax is similar to the syntax of most computer languages, and is modelled on C syntax. A simple example of this, is that when ${A + 2} is used, and the ASSIGNed variable A has the value '3', the result is 5. Brackets can be used in these expressions, so (A+2)*3 would give a value of (3+2)*3 == 15, whereas A+2*3 would give a value of 9, because multiplication is performed before addition. The common arithmetic operations (+, -, *, /) are all available. Additionally, there is a string concatenation operator (##). This treats both sides as strings and pastes them together. Thus if A is 3 and B is 7, "A##B" becomes "37", but "A+B" becomes 10. You can also assign values to a variable in these expressions using the '=' operator. Thus if you have the expression "C = A+B", it will assign the value 10 to C. This has a number of affects. The most common case is the @ command, where you can enter this expression literally: @ C = A + B The '=' operator returns the value assigned. Thus you can extend this to: @ D = C = A + B Which will assign the value 10 to both C and D. In a $ expression, you might want to assign a value to a variable, and display it at the same time. Thus you might do the following: echo The value of C is now ${C = A+B} which would set C to 10 and display "The value of C is now 10". Comparison operations also exist. These return 1 if the comparison is valid (true) and 0 if it is invalid (false). The comparison operations available are: == (equal to) > (greater than) >= (greater than or equal to) < (less than) <= (less than or equal to) != (not equal to) Thus, the following expressions would result in the following results: ( recall A = 3 and B = 7 ) A == B FALSE 0 A == 3 TRUE 1 A > 3 FALSE 0 A >= 3 TRUE 1 A != 3 TRUE 1 These expressions can be combined with || (OR), && (AND) and ^^ (XOR). So (A == 3) || (B==3) would be TRUE, and (A == 2) && (B == 7) would be FALSE. You can also negate expressions with ! (NOT), so !(A == 3) would be FALSE. These boolean expressions are used primarily in IF and WHILE. A string expression is considered to be true if it is non empty. So if E has the value "word", then E || ( A > 3) is true, because E has a non empty value, and !E is false. Functions can also appear in expressions. The arguments to functions are evaluated as normal $ type expressions. Thus the following alias: alias test echo ${ MID(3 2 $0) + 5) } is executed with /test 123456, would give 34 (Two digits from position 3 in $0) + 5, giving 39. If the function returns another function name, that function name can be called with another set of brackets. Thus if you have the following set of aliases: alias fptr { if ( [$0] ) { @ function_return = func1 } { @ function_return = func2 } } alias func1 @ function_return = this is $0 alias func2 @ function_return = that is $0 alias check echo ${ fptr($0)($1) } then /check 0 1 would print "that is 1", and /check 1 0 would print "this is 0". Array expressions can also be used in this way. For example: assign A.1.1 One One was a racehorse assign A.1.2 Two Two was one too assign A.2.1 One One won one race assign A.2.2 Two Two won one too alias rhyme echo ${ A[$0][$1] } would cause /rhyme 2 1 to print "One One won one race". Function and array expressions can be combined to give a form of pointer arithmetic like that seen in C. If a function RhymeNum exists as follows: alias RhymeNum @ function_return = [A] and rhyme is changed to: alias rhyme echo ${ RhymeNum()[$0][$1] } /rhyme 2 1 still prints "One One won one race". This is because RhymeNum returns A, and the expression then becomes A[$0][$1]. The $0 is expanded to 2, so it becomes A.2[$1], and the $1 is expanded to 1, so it becomes A.2.1, which is then substituted as a variable for "One One won one race". The reverse is also possible. For example, a robot might have the following: alias thing.0 @ function_return = laughs his silly head off alias thing.1 @ function_return = growls menacingly alias thing.2 @ function_return = smiles like a crocodile alias thing.3 @ function_return = wails uncontrollably alias something SAY WereBot ${ thing[$RANDOM(4)]() } Will cause WereBot to say that it's laughing itself silly, growling menacingly, smiling like a crocodile or wailing uncontrollably. Assuming RANDOM(4) results in a value of 2, This expands to thing.2(), which is then considered to be a function and substituted to "smiles like a crocodile", the end result being that WereBot will say "WereBot smiles like a crocodile". Finally, there are occasions when you need to get back to the $ substitution level. This can be done by enclosing text to be used at this level in [..]. For example, [A] substitutes to a literal 'A', whereas A on its own substitutes to 3, and [$0] is needed to get argument 0, because 0 on its own is taken to be the number 0. Example: alias something SAY WereBot ${ [$0][$RANDOM(4)]() } will case /something thing to first expand [$0] to thing, giving thing[$RANDOM(4)](), and if $RANDOM(4) returns 1, this becomes thing.1(), which expands to "growls menacingly", and causes WereBot to say "WereBot growls menacingly". The following is the parse tree for expressions such as those NU_EXPR = NU_CONJ NU_CONJ = NU_CONJ && NU_CONJ | NU_CONJ || NU_CONJ | NU_CONJ ^^ NU_CONJ | NU_ASSN NU_ASSN = varexp = NU_ASSN | NU_COMP NU_COMP = NU_COMP == NU_COMP | NU_COMP != NU_COMP | NU_COMP > NU_COMP | NU_COMP >= NU_COMP | NU_COMP < NU_COMP | NU_COMP <= NU_COMP | NU_ADD NU_ADD = NU_ADD + NU_ADD | NU_ADD - NU_ADD | NU_ADD ## NU_ADD | NU_MULT NU_MULT = NU_MULT * NU_MULT | NU_MULT / NU_MULT | NU_UNIT NU_UNIT = token NUX_MODIF | unaryop token | ( NU_EXPR ) | [ expression ] NUX_MODIF NUX_MODIF = ( expression ) NUX_MODIF | [ expression ] NUX_MODIF Special cases: If a (...) or {...} construct is quoted with \(...\) or \{...\} then variable expansion will take place on the first available parse run. However, after parsed, the \'s are eaten. e.g. alias bonk echo ($0) will return "($*)" regardless of the argument to the alias. No expansion takes place. However, in alias bonk echo \($0\) expansion takes place as the special meaning of the () is taken away by \. This will return "(arguments to bonk)".

HTML Conversion by Kai 'Oswald' Seidler, osw@ld.pages.de. Last modified: 04. February 1997.