| NAME |
| operators |
| |
| DESCRIPTION |
| |
| These are the operators availailable in LPC. They are listed |
| in the order of precedence (low priority first): |
| |
| |
| expr1 , expr2 Evaluate 'expr1' and then 'expr2'. The |
| returned value is the result of 'expr2'. The |
| returned value of 'expr1' is thrown away. |
| |
| var = expr Evaluate 'expr', and assign the value to |
| 'var'. The new value of 'var' is the result. |
| |
| var += expr Assign the value of 'expr' + 'var' to 'var'. |
| This is mostly equivalent to "var = var + expr". |
| |
| var -= expr Similar to '+=' above. |
| var &= expr |
| var |= expr |
| var ^= expr |
| var <<= expr |
| var >>= expr |
| var >>>= expr |
| var *= expr |
| var %= expr |
| var /= expr |
| var &&= expr |
| var ||= expr |
| |
| expr1 ? expr2 : expr3 |
| Evaluates 'expr1' and branches according to |
| its truth value. If it is true, the 'expr2' is |
| evaluated and returned as result, else |
| 'expr3'. |
| |
| expr1 || expr2 The result is true if 'expr1' or 'expr2' is |
| true. 'expr2' is not evaluated if 'expr1' was |
| true. |
| |
| expr1 && expr2 The result is true i 'expr1' and 'expr2' is |
| true. 'expr2' is not evaluated if 'expr1' was |
| false. |
| |
| expr1 | expr2 The result is the bitwise or of 'expr1' and |
| 'expr2'. |
| For arrays, the union set is computed: all elements |
| from <expr1> plus all those from <expr2> which |
| are not in <expr1>. |
| |
| expr1 ^ expr2 The result is the bitwise xor of 'expr1' and |
| 'expr2'. |
| For arrays, the symmetric difference is computed: |
| all elements from <expr1> which are not in <expr2>, |
| plus all those from <expr2> which are not in <expr1>. |
| |
| expr1 & expr2 The result is the bitwise and of 'expr1' and |
| 'expr2'. |
| |
| For arrays and strings, the intersection set |
| (all elements resp. characters from expr1 which |
| which are also in the expr2) is computed. |
| Note: "aab" & "a" -> "aa" |
| but ({ 'a','a','b' }) & ({ 'a' }) -> ({ 'a' }) |
| Eventually the array behaviour will be changed |
| to match the string behaviour. |
| |
| Intersecting an array with a mapping is equivalent |
| to intersecting the array with the indices of the |
| mapping: array & mapping = array & m_indices(mapping) |
| |
| Mappings can be intersected with another mapping |
| or an array. The resulting mapping holds all |
| those entries from the first mapping, which are |
| also mentioned in the second mapping (as index) |
| resp. in the array. |
| |
| expr1 == expr2 Compare values. Valid for strings, numbers, |
| objects and closures. |
| |
| expr1 != expr1 Compare values. Valid for strings, numbers, |
| objects and closures. |
| |
| expr1 > expr2 Valid for strings and numbers. |
| |
| expr1 >= expr2 Valid for strings and numbers. |
| |
| expr1 < expr2 Valid for strings and numbers. |
| |
| expr1 <= expr2 Valid for strings and numbers. |
| |
| expr1 << expr2 Shift 'expr1' left by 'expr2' bits; the sign |
| bit is not preserved. |
| |
| expr1 >> expr2 Shift 'expr1' right by 'expr2' bits. |
| This shift preserves the sign of 'expr1'. |
| |
| expr1 >>> expr2 Shift 'expr1' right by 'expr2' bits. |
| This shift does not preserve the sign of 'expr1', |
| instead it shifts in 0 bits. |
| |
| expr1 + expr2 Add 'expr1' and 'expr2'. If numbers, then |
| arithmetic addition is used. If one of the |
| expressions are a string, then that string is |
| concatenated with the other value. |
| If the expressions are arrays, the result is |
| the right array appended to the left. |
| If the expressions are mappings of equal width, |
| the result is merger of the two mappings. If one |
| key exists in both mappings, the element from the |
| right mapping appears in the result. If the two |
| mappings are of different width, the result is |
| <expr1> if non-empty, and <expr2> otherwise. |
| |
| expr1 - expr2 Subtract 'expr2' from 'expr1'. Valid for |
| numbers, strings, arrays, mappings. |
| For arrays and strings, all occurrences of the |
| elements resp. characters in 'expr2' are removed |
| from 'expr1', and the result is returned. |
| For mapping, all occurances of elemens in 'expr1' |
| which have a matching key in 'expr2' are removed, and |
| the result is returned. |
| |
| expr1 * expr2 Multiply 'expr1' with 'expr2'. |
| If strings or arrays are multiplied with a number |
| (zero or positive), the result is a repetition of the |
| original string or array. |
| |
| expr1 % expr2 The modulo operator of numeric arguments. |
| |
| expr1 / expr2 Integer division. |
| |
| ++ var Increment the value of variable 'var', and |
| return the new value. |
| |
| -- var Decrement the value of variable 'var', and |
| return the new value. |
| |
| - var Compute the negative value of 'var'. |
| |
| ! var Compute the logical 'not' of an integer. |
| |
| ~ var The boolean 'not' of an integer. |
| |
| ( type ) var Return the value of <var> converted to <type>. |
| <type> can be 'string', 'int', 'object', 'float' |
| or 'int*'. <var> must be of a specific type |
| for a conversion to take place; if <var> is 'mixed' |
| or unknown, the cast is purely declarative. |
| Also, if the declared type of <var> is that of <type>, |
| the value is not changed. |
| |
| NB. The literal number 0 is of unknown type, as |
| it doubles as 'not initialized' for strings, objects, |
| and arrays. |
| |
| The operator acts like the efuns |
| to_string(), to_int(), to_object(), to_float() |
| and to_array(). It is advisable to use the |
| efuns directly instead of the cast. |
| |
| ({ type }) var <var> is now assumed to have the type <type>. |
| This is purely declarative, the actual value |
| of <var> is not changed. |
| |
| var ++ Increment the value of variable 'var', and |
| return the old value. |
| |
| var -- Decrement the value of variable 'var', and |
| return the old value. |
| |
| expr1[expr2] The array or mapping given by 'expr1' is |
| indexed by 'expr2'. |
| |
| expr1[expr2..expr3] Extracts a |
| piece from an array or string. |
| expr2 or expr3 may be omitted, default is the begin |
| or end of expr1. |
| Negative numbers for expr2 or expr3 |
| mean ``count from before the beginning'', i.e. |
| foo[-2..-1] is an empty array or string. |
| foo[<2..<1] gives the 2nd and last element of |
| the array resp. chars of the string. |
| |
| expr1->name(...) The symbolic form of call_other(). 'expr1' |
| gives either an object or a string which is |
| used as the file_name of an object, and calls |
| the function 'name' in this object. |
| |
| ident::name(...) |
| Call the inherited function 'name' with the |
| given parameters in the parent 'ident'. |
| 'ident' may be given as string containing the |
| full pathname, or as identifier containing the |
| pure basename. |
| If 'ident' is omitted, the last inherited |
| function of this 'name' is called. |
| |
| ({ }) Array constructor. |
| ([ ]) Mapping constructor. |
| |
| NOTE |
| The closure operators are not described here. |
| |
| HISTORY |
| LDMud 3.2.9 added '>>>', '>>>=', '&&=' and '||='. |
| LDMud 3.2.10 extended '&' to mappings. |
| LDMud 3.3 extended '|' and '^' to arrays. |
| |
| SEE ALSO |
| arrays(LPC), alists(LPC), mappings(LPC), closures(LPC) |