LEO Operators and Functions ​

The following sections contain a list and descriptions of the various operators and functions that can be used in LEO expressions.

Logical Operators ​

Logical operators deliver 0 ("false") or 1 ("true"). Concerning the operators null values are interpreted as "false" and all other values are "true".

Comparison Operators ​

When evaluating a comparison operator, the value of the left operator must be of the same type as the value of the right operator. The result is 0 ("false") or 1 ("true").

Arithmetical Operators ​

For arithmetic operators the operands and the results are either of numeric type, of type measure or of type time.

Arithmetical Functions ​

String Operators ​

String Functions ​

Search ​

search ( source , pattern , start )

source and pattern are of type string, start from type figure. The result is of type figure. It will be searched in source after pattern, but the start has a specified position. The identification starts with the character 0. If the search was successful the position will be shown, if not it will return -1.

Backwards search ​

bsearch ( source , pattern , start )

source and pattern are of type string, start from type figure. The result is of type figure. It will be searched backwards in source after pattern,start is the specific position in which it will be started. The identification of a character starts with 0, -1 is the end of the text. If the search was successful the position will be shown, if not it will return -1.

Copy ​

copy ( source , from , count )

source of type string, from and count are of type figure. The result is of type figure. The part-text which will be delivered back by source, is the starting position starting at from and continuing for the length of count. For count the value -1 will be displayed, the part-text from source starting from from to the end of the string.

Replace ​

replace ( source , pattern , new )

source, pattern and new are of type string. The result is source, where the first appearance of pattern via new is set. If the pattern is not in the source, the unchanged value of the source is provided.

Replace all ​

replall ( source , pattern , new )

source, pattern and new are of type string. The result is of type string. The text displayed is created as a result of replacing (in the source) all patterns with news.

To lower case ​

lower ( source )

The string will be returned, but all capital letters in source will bhe replaced with the appropriate lower-case letters.

To upper case ​

upper ( source )

The string will be returned, but all small letters in source will be replaced with the appropriate capital letters.

Mask string ​

mstr ( source )

The returned string will be passed as a parameter in inverted commas returned with required masks.

Escape characters for URI ​

encodeuri ( content [ , allowed ])

The returned string will have it's characters escaped using typical URI encoding (%xx, "percent-encoding"). The optional allowed parameter specifies all characters that are allowed to appear normally (not encoded) in the result. If allowed is omitted then the same characters are allowed as in the encodeURI() function from JavaScript.

Be careful where the input comes from. This function does not consider the string to have any specific structure. If parts of it have already been encoded (from encodeuri() or tourlquerystring()) then they will be encoded again!

Examples for some strings that can be used for allowed:

# Characters allowed by JS encodeURIComponent(). It should be safe to encode
# specific parts of a URL.
"!'()*-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~"

# Characters allowed by JS encodeURI(). It should be safe to use for encoding
# an entire URL.
"!#$&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~"

# Based on several sources from the internet, including the URI specification.
"!\"$'()*,-./0123456789;ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~"

# All except non-ASCII characters, ASCII control characters (0x00 to 0x20 and
# 0x7F), # (0x23), % (0x25), & (0x26), + (0x2B), = (0x3D) and ? (0x3F)
"!\"$'()*,-./0123456789:;<>@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

# All except non-ASCII characters, ASCII control characters (0x00 to 0x20 and
# 0x7F), % (0x25), & (0x26) and = (0x3D)
"!\"#$'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

# Characters allowed by JS encodeURIComponent(). It should be safe to encode
# specific parts of a URL.
"!'()*-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~"

# Characters allowed by JS encodeURI(). It should be safe to use for encoding
# an entire URL.
"!#$&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~"

# Based on several sources from the internet, including the URI specification.
"!\"$'()*,-./0123456789;ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~"

# All except non-ASCII characters, ASCII control characters (0x00 to 0x20 and
# 0x7F), # (0x23), % (0x25), & (0x26), + (0x2B), = (0x3D) and ? (0x3F)
"!\"$'()*,-./0123456789:;<>@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

# All except non-ASCII characters, ASCII control characters (0x00 to 0x20 and
# 0x7F), % (0x25), & (0x26) and = (0x3D)
"!\"#$'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

Regular expression ​

regex ( regExpr , source )

The comparison of source with the regular expression_regExpr_. It corresponds to the regular expression source, it gets the value 1 or 0.

Token count ​

tokcnt ( source , [ separator ])

Returns the number of tokens in source separaetd by separator.

Get token ​

token ( source , index , separator )

The token in source with the index index will be returned, but with the beginning of the token starting at 0. separator is a single character which separates the tokens.

Index of token ​

tokindex ( source , token [, separator ])

The result is the index of token in source (starting with 0). A result of -1 means that token is not a token in source. Example: tokindex("this@is@a@simple@test", "simple", "@") = 3

Token concatenation ​

tokcat ( source1 , source2 [, separator ])

From the strings source1 and source2 a new string is generated, which contains all the tokens from source1 and source2.

Token union ​

tokunion ( source1 , source2 [, separator ])

The set union of the second string. The result contains all tokens which appear in source1 and/or in source2.

Token intersection ​

tokisect ( source1 , source2 [, separator ])

The intersection of the second string. The result contains all tokens, which appear both in source1 and in source2.

Token difference ​

tokdiff ( source1 , source2 [, separator ])

The difference between two strings. The result contains all tokens from source1, which do not occur in_source2_.

Array to token string ​

tokstr ( a [, separator ])

Changing an array into a token string. a must be of type array, separator must be of type string with a length of 1 (otherwise the separator is a blank). The result is a text string containing the sequence of array elements which are seperated in the same order as before, separated by separator. Example: tokstr({4711, 4712, 4713}) -> "4711 4712 4713". Example: tokstr({"first", 1.23}, ",") -> "first,1.23".

Array to LEO text token string ​

valtokstr ( a [, separator ])

Conversion of an array into a LEO text token string. a must be of type array, separator must be of type string with a length of 1 (otherwise the separator is a blank). valtokstr() should be used instead of tokstr() if the tokens contain the separator character, or belong to the different types. The result is a string, where all array elements in the same order are separated with separator. Example: valtokstr({"first", 1.23,","}, ",") -> "\ "first\",1.23,\",\"".

Token string to array ​

strarray ( str [, separator ])

Conversion of a token string into an array. str and separator must be of type string (separator with a length of 1, otherwise a blank is the separator). The result is an array, where all elements are of type string, containing the tokens in the same sequence as before. Example: strarray("begin 4711 end") -> {"begin", "4711", "end"}.

LEO text token string to array ​

valarray ( str [, separator ])

Conversion of a token string into an array. str and separator must be of type string (separator with a length of 1, otherwise a blank is used as the separator). This function must be used instead of strarray( ) if the tokens are LEO values (strings in apostrophes). For the result, each token is interpreted as a value and all the values are united in one array. Thus, values in an array can be of different types. Example: valarray("4711 4712 4713") -> {4711, 4712, 4713}.

Array Operators ​

Array Functions ​

Map Operators ​

Map Functions ​

Create map ​

map ()

Construction of an empty map. A new map with certain key-value pairs can be constructed like the following: { 1780: "Sim", 1920: "Sala", 2007: "Bim" }. A key and a related value are separated by a colon ("😊, multiple key-value pairs are separated by comma (","), the set of pairs is enclosed in curly parentheses ("{" and "}").

Erase from map ​

merase ( m,k )

Erases the element with key k from a map m. Return value is the value of element which has been erased.

Unpack to URL query format ​

tourlquerystring ( amap [ , allowed ] )

This function "unpacks" the contents of a map into a URL query string format. It makes it easier to build URL query strings by transforming a map. The map is considered to be shallow, i.e. any of its other structured elements are treated as their string representation. Characters are encoded / escaped using typical URI encoding (%xx), based on the value of allowed.

The optional allowed parameter specifies all characters that are allowed to appear normally (not encoded) in the result. If allowed is omitted then the same characters are allowed as in the encodeURIComponent() function from JavaScript. Otherwise it works the same way as in the encodeuri() function.

Conversion Operators ​

Conversion operators change a quoted value into a value of another type.

RGB Colour Values Functions ​

LEO Colours ​

The following colours are defined in LEO:

aliceblue | antiquewhite | aqua | aquamarine | azure | beige | bisque | black | blanchedalmond | blue | blueviolet | brown | burlywood | cadetblue | chartreuse | chocolate | coral | cornflowerblue | cornsilk | crimson | cyan | darkblue | darkcyan | darkgoldenrod | darkgray | darkgreen | darkkhaki | darkmagenta | darkolivegreen | darkorange | darkorchid | darkred | darksalmon | darkseagreen | darkslateblue | darkslategray | darkturquoise | darkviolet | deeppink | deepskyblue | dimgray | dodgerblue | firebrick | floralwhite | forestgreen | fuchsia | gainsboro | ghostwhite | gold | goldenrod | gray | green | greenyellow | honeydew | hotpink | indianred | indigo | ivory | khaki | lavender | lavenderblush | lawngreen | lemonchiffon | lightblue | lightcoral | lightcyan | lightgoldenrodyellow | lightgreen | lightgray | lightmagenta | lightpink | lightsalmon | lightseagreen | lightskyblue | lightslategray | lightsteelblue | lightyellow | lime | limegreen | linen | magenta | maroon | mediumaquamarine | mediumblue | mediumorchid | mediumpurple | mediumseagreen | mediumslateblue | mediumspringgreen | mediumturquoise | mediumvioletred | midnightblue | mintcream | mistyrose | moccasin | navajowhite | navy | oldlace | olive | olivedrab | orange | orangered | orchid | palegoldenrod | palegreen | paleturquoise | palevioletred | papayawhip | peachpuff | peru | pink | plum | powderblue | purple | red | rosybrown | royalblue | saddlebrown | salmon | sandybrown | seagreen | seashell | sienna | silver | skyblue | slateblue | slategray | snow | springgreen | steelblue | tan | teal | thistle | tomato | turquoise | violet | wheat | white | whitesmoke | yellow | yellowgreen

Comma Operators ​

All expressions of the expressions' sequence (the sequence should be separated through commas) are evaluated and the result of the last expression is returned. These expression sequences are used when a more complicated task is required and multiple expressions need to be used to accomplish it, each building on the last expressions changes (e.g. to while). Should the comma operator in the parameter list of a function call be used, the comma operator contained in the expression must be written in round brackets. Otherwise the comma would be interpreted as a parameter separator.

Example:

fcall (ex1, (ex2, ex3))

leads to a call of

fcall (ex1, ex3).

Assignment Function (set) ​

Syntax:

set ( lvalue , expr )

Assigns a constant or the result of an expression to a variable or an array element.

Condition Function (cond) ​

Syntax:

cond ( cond 1 , expr 1 , ... , cond n , expr n , expr n+1 )n > 0

The parameter number of the cond call has to be an odd number >= 3. The shortest form (n = 1) is cond ( cond 1**,** expr 1**,** expr 2 ).

The parameters cond i quotes the conditions that are checked one after the other. As soon as one condition evaluation is "true", the expression of the condition will be evaluated and the result is returned. Further conditions are not checked anymore. If none of the conditions is evaluated to "true", the result of the last expression is returned. From the entered expr i parameters, exactly one is evaluated in any case. The result can be of integer, double, measure value, time or string types.

Examples:

cond(x > 5, "x is larger than 5", "x is smaller than or equal 5")
cond(x > 5, "x is larger than 5", x < 5, "x is smaller than 5", "x equals 5")

cond(x > 5, "x is larger than 5", "x is smaller than or equal 5")
cond(x > 5, "x is larger than 5", x < 5, "x is smaller than 5", "x equals 5")

Loop Function (while) ​

Syntax:

while ( cond , loopexpr [ , resultexpr ] )

While the condition cond is true, the expression loopexpr is evaluated. The expression loopexpr must have side effects, so that the condition can become false. The optional resultexpr is evaluated and its result returned when the loop is exited or if cond is already false at the beginning. while(a, b, c) is the same as (while(a, b), c).

Example:

The following expressions calculate the factorial of 5:

set(r, 1), set(i, 1),
while(i <= 5, (set(r, r * i), set(i, i + 1))),
r

set(r, 1), set(i, 1),
while(i <= 5, (set(r, r * i), set(i, i + 1))),
r

Loop Function (for) ​

Syntax:

for ( lvalue , from , to , loopexpr [ , resultexpr ] )

This function evaluates an expression for each value running from one value to another value. The run variable is increased by 1 after each step, until it is larger than the to-value, so the number of loops is (to - from + 1).

Example:

The following code returns "ABCDEFG":

set(s, ""),
for(i, 65, 71, (set(s, s + CHR i))),
s

set(s, ""),
for(i, 65, 71, (set(s, s + CHR i))),
s

Loop Function (fortok) ​

Syntax:

fortok ( lvalue , source , separator , loopexpr [ , resultexpr ] )

The variable Ivalue runs through all tokens in source separated by separator. Each run means that loopexpr is evaluated.

if resultexpr is specified, its value will be returned. Otherwise the fortok expression has no result (i.e. a result of type undefined).

Example:

The following expression calculates the factorial of 5:

set(r, 1),
fortok(t, "2 3 4 5", " ", set(r, r * VAL t)),
r

set(r, 1),
fortok(t, "2 3 4 5", " ", set(r, r * VAL t)),
r

Error Handling (try, error) ​

If errors occur during calculation, the function try() allows for handling them. This function has two parameters. During the calculation, the system tries to evaluate the first parameter. If successful, the result will be returned. If an error occurs, the second parameter is evaluated and the appropriate result is returned.

Example:

In the following code 1 will be returned, if an error like dividing by zero happens:

try(pow(x, y) / (x * y), 1)

try(pow(x, y) / (x * y), 1)

The opposite is the function error() which has a string as parameter. It generates the error message with the parameter as the message text.

Lambda Expression (lambda) ​

Syntax:

lambda({ident ,}expr )

A lambda expression is a value and a function. As it is a value, it can be assigned to variables. As it is a function it can be called. A lambda expression can be called like a normal function by appending an (eventually empty) parameter list enclosed in parentheses. The definition of a lambda expression consists of formal parameters and an expression. The formal parameter list is an (eventually empty) list of identifiers. The expression computes something of these parameters.

Example:

The following expression defines a function incr and calls it afterwards. After evaluationg this expression, m has the value m+1:

set(successor, lambda(n, n + 1)), set(m, successor(m))

set(successor, lambda(n, n + 1)), set(m, successor(m))

Without assigning the lambda expression to a value, this could also be written that way:

set(m, lambda(n, n + 1)(m))

set(m, lambda(n, n + 1)(m))

In AdoScript it is not possible to define a function with FUNCTION which accesses a global variable. This problem can be solved by assigning a lambda expression to a global variable instead.

Eval Expression (eval) ​

Syntax:

eval( { strOrExprValue } )

eval() makes it possible to create and evaluate expressions dynamically. The passed parameter must be a string or an expression value. If it is a string, the value is at first parsed to an expression value. The expression value which results from the parsing or which has been passed directly is then evaluated in the current context and the result of that evaluation is returned.

Example:

The expression returns the result of STR LEN "STR", which is "3".

set(op, eval("upper(\"str\")")),
set(y, eval(op + "LEN op")),
y

set(op, eval("upper(\"str\")")),
set(y, eval(op + "LEN op")),
y

Type Finding (type) ​

Syntax:

type( anyExpr )

With the function type(), the type of an expression can be determined. One of the following values is returned: "string", "integer", "real", "measure", "time", "expression", "array", "map", "lambda", "undefined".

Valuation (valofvar) ​

Syntax:

valofvar( strValue )

The function valofvar( ) returns the value of a variable with a given name.

This function is needed if a variable with a name containing minus signs shall be accessed within an expression. If you simply write a variable name with minus signs within an expression, these minus signs would be interpreted as minus operators. Writing a question mark before a variable name has the same effect as calling valofvar() with the variable name in a string.

Variable List (curvars) ​

Syntax:

curvars()

The function curvars( ) returns a string, containing the names and values of all variables used in the current context. For each variable used, the result contains a line with the format <varname>:<value>. In conjunction with a keyword at the beginning, this is valid LEO text.

Line Numbering (curlineno) ​

Syntax:

curlineno()

The function curlineno( ) provides the line number of the LEO element containing the expression. This function is useful in AdoScripts, to get the currently executed code line. However, it can be used in any LEO code (like GraphRep).

Example:

CC "AdoScript" INFOBOX
    ("We are now in line no. " + STR curlineno())

CC "AdoScript" INFOBOX
    ("We are now in line no. " + STR curlineno())

Duration Determination (getTickCount) ​

Syntax:

getTickCount()

The function getTickCount( ) returns the time passed (in milliseconds) since the system was started. It is used for example in performance monitoring.

Example:

SET t1:(getTickCount())
CC "AdoScript" SLEEP ms:(3000)
SET t2:(getTickCount())
SET sec:((t2-t1) * 0.001)
CC "AdoScript" INFOBOX ("The calculation took " + STR sec + " seconds.")

SET t1:(getTickCount())
CC "AdoScript" SLEEP ms:(3000)
SET t2:(getTickCount())
SET sec:((t2-t1) * 0.001)
CC "AdoScript" INFOBOX ("The calculation took " + STR sec + " seconds.")

set(tickCount, getTickCount()),
cond((tickCount < 0) AND (lastExec >= 0),
  abs(lastExec + tickCount) > delay,
  tickCount > (lastExec + delay)
)

set(tickCount, getTickCount()),
cond((tickCount < 0) AND (lastExec >= 0),
  abs(lastExec + tickCount) > delay,
  tickCount > (lastExec + delay)
)

Internal Values (internal) ​

Syntax:

internal( strValue )

The function internal() provides access on internal values. By now, these values can be read:

• internal("APPWIN") returns the address (HWND) of the application window.
• internal("TOPWIN") returns the address (HWND) of the top window.

A window address is a value of type long, which can be passed to external DLLs and used there as a parent window for a dialogue.

Example:
Calling an external DLL containing a dialogue via AdoScript

SET hwnd:(internal("APPWIN"))
CALL dll:"extdlg.dll" function:"void showdlg(long hwnd)" hwnd:(hwnd)

SET hwnd:(internal("APPWIN"))
CALL dll:"extdlg.dll" function:"void showdlg(long hwnd)" hwnd:(hwnd)