Built-in functions

ABORT(x)

Aborts script execution by triggering runtime error, with message x.

A=5;B=0;
IF(B==0, ABORT("Cannot divide by zero"), A/B)

BLEN(x)

Length of scalar input in bytes.

This might be different from LEN in cases where higher Unicode characters occur.

A="Łódź";
LEN(A) & " < " & BLEN(A) # 4 < 7

BTL(x)

Creates a list of numbers representing bytes (numbers in range 0-255) in the input

Printtree(BTL("ABC"))

Outputs [
1 => 65
2 => 66
3 => 67
]

COUNT(x)

Count array/list elements of x.

A=(1,2,1,3);
COUNT(A) # evals to 4

INDEXES(x)

Returns a list of x array indexes.
Useful to iterate over arrays with string-based keys.

B[“APPLES”] = 1; B[“BANANS”] = 2;
IND = INDEXES(B)
IND[2] # evals to “BANANAS”

DEFUN(x, y, z)

Defines a new named function.

Read more in section Defining your own

Read more in section Defining your own

HASH(x)

Calculates SHA256 message digest (known also as hash) of the scalar value provided in x.

LAMBDA(x, y)

Defines a new in-place function, not named.

Read more in section Defining your own

Read more in section Defining your own

LEN(x)

Returns the length (number of characters) of x when interpreted as a scalar value.

If x is a list/table, the length of the first element will be returned.

A='123'; LEN(A) # evaluates to 3
A=123; LEN(A) # evaluates to 3
LEN(123) # evaluates to 3 as well
A=(123456789,2,3,4);
LEN(a) & "," & COUNT(A);
# evaluates to 9,4
# where 9 is lenght of '123456789'
# and 4 is count of A list elements

LOCALS(x, y)

Controls variables' lexical scope.

Read more in section Defining your own

Read more in section Defining your own

LTB(x)

Creates a byte string from the provided list of bytes

A=(64,66,68); LTB(A) # &BD

QSORT(x, y)

Applies Quicksort algorithm and user defined comparison function y to sort a list or table, returns a sorted copy of x.

B=(7,3,5);
DEFUN("CMP",("A","B"),A<B);
A = QSORT(B, "CMP");
A[1] & A[2] & A\3 # returns 357

STL(x)

Scalar to list - takes a scalar value of the variable and separates it into single characters, returning a list of them.

COUNT(STL(“ABC”)) # evals to 3
STL(“ABC”)[2] # evals to B
# Unicode is respected
STL("ałć")[2] # ł

UNDEF(x)

Un-defines a function named x.

UNDEF(“UNDEF”);UNDEF(“A”)
# error - function not found

UNSET(x)

Removes array/list element by provided access definition in x.

A=(1,2,3); UNSET(A[1]); COUNT(A)
# evals to 2

WITH(x, y)

Controls variables' lexical scope.

Read more in section Defining your own

Read more in section Defining your own

Name

Description

Usage Example

COMP_GZIP(x)

Executes GZIP compression algorithm on the provided scalar data in x and returns the compressed byte string.

A="test";
COMPRESSED=COMP_GZIP(A);

CRC32(x)

Calculates the Cyclic Redundancy Code for provided input string/bytes.

Follows the CRC-32/ISO-HDLC standard, same as used in PKZIP, Gzip, WIFI and other common standards.

More on the CRC: https://en.wikipedia.org/wiki/Cyclic_redundancy_check

Reference example: https://crccalc.com/?crc=TEST&method=CRC-32/ISO-HDLC&datatype=ascii&outtype=hex

TO_HEX(CRC32("TEST"))

# returns EEEA93B8

DECODE_BASE64(x)

Executes Base64 decoding algorithm on the provided scalar string in x, assuming it’s Base64 encoded. Fails if provided data is not compliant with Base64 encoding.

E=”VEVTVA==”;
T=DECODE_BASE64(E);

T $== “TEST”

DECOMP_GZIP(x)

Executes GZIP decompression algorigthm on the provided scalar data in x, assuming it’s GZIP compressed. Fails otherwise.

A="test";
C=COMP_GZIP(A);
D=DECOMP_GZIP(C);

A $== D

ENCODE_BASE64(x)

Executes Base64 encoding algorithm on the provided scalar data in x.

A=”test”;
E=ENCODE_BASE64(A);
D=DECODE_BASE64(E);

D $== A
# E $== “dGVzdA==”

FROM_HEX(x)

Converts provided hex string in x into byte block

UCHAR(65) ~= FROM_HEX("41")

# Returns TRUE (X)

TO_HEX(x)

Converts provided byte block in x into it’s hexadecimal representation

TO_HEX("ABCM") # 4142434D

ZIP(x, [y])

Compresses and packs provided inputs in PKZIP compatible compression and file format.

x may be a list of filenames with content, as in the example. Eventually x could be a filename and y it’s content

ZIP("name.txt", "text in the file")

OR

A["file1.txt"] = "content of file 1";
A["file2.bin"] = FROM_HEX("DEADBEEF");
ZIP(A)

BACKWARDS(x)

Puts x characters in reverse order.

BACKWARDS(“ABC”) # evals “CBA”

CREGEX(x,y[,z])

Runs a full regular expression matching on y using string x as the regular expression.

Returns a complex table with matches and subgroups, offsets, indexes and values.

Optionally parameter z may be provided, to control the regular expression engine behaviour.

Control params

• U - not greedy matching + and *

• G - global (find all matches)

For further information, read here: More details on Regular Expressions processing

Greedy

V=CREGEX(
"([^ABC]+)",
"ABCDEFABCDEFG", "G");

# V[1]["SUB"][1]["STR"] $== "DEF"
# V[2]["SUB"][1]["STR"] $== "DEFG"

Not greedy

V=CREGEX(
"([^ABC]+)",
"ABCDEFABCDEFG", "UG");

# V[1]["SUB"][1]["STR"] $== "D"
# V[2]["SUB"][1]["STR"] $== "E"
# …
# V[7]["SUB"][1]["STR"] $== “G”
# COUNT(V) == 7

CXML_PARSE(x, y)

Parses XML text in x into a tree structure that allows manipulation and browsing.

Parameter y represents optional control parameters. Provide S for strict operation - throws an error for invalid input.

CXML_RENDER(x, y)

Converts a tree structure, as created by CXML_PARSE (or manually, if conforming) to XML representation.

Parameter y represents optional control parameters. None supported in this version.

CXPATH(x,y)

Runs XPath matching on XML string y using string x as the XPath expression. Returns a list of matching nodes.

<codedb><cl id="3">
'<enumeration value="AAA"/><enumeration value="AAB"/>
'<enumeration value="AAC">AAC value</enumeration>
'<enumeration value="AAD"/><enumeration value="AAE"/>
</cl></codedb>

XP='//cl[@id=3]/enumeration[@value="AAC"]'
R=CXPATH(XP,XML);
# R[1] == “AAC value"

CXSLT(x,y,z)

Runs a XSLT Transformation defined in x on XML data in y, using optionally provided XSLT parameters in z. Returns the result of transformation execution.

FIND(x,y)

Finds position of first occurence of x in y , zero based. Returns -1 if not found.

FIND("A","BACA") # evals to 1

JSON_PARSE(x, y)

Parses JSON text in x into a tree structure that allows manipulation and browsing.

Parameter y represents optional control parameters. Provide S for strict operation - throws an error for invalid input.

Similar to CXML_PARSE / CXML_RENDER example above.

JSON_RENDER(x, y)

Converts a tree structure, as created by JSON_PARSE (or manually, if conforming) to JSON representation.

Parameter y represents optional control parameters. None supported in this version.

LEFT(x,y)

Gets y leftmost characters from x.

LEFT(“abc”,2) # evals “ab”

LOWER(x)

Converts x to lower case.

LOWER(“Abc”) # evals “abc”

REPLACE(x, y, z)

Replaces all occurrences of x in z with y.

REPLACE("ABC","DEF","ABCDEF")
# “DEFDEF”

RFIND(x, y)

Finds position of first occurence of x in y , zero based. Returns -1 if not found. Uses POSIX-based regular expression matching.

RFIND("[cde]+","BAcA") # evals to 2

RIGHT(x,y)

Gets y rightmost characters from x.

RIGHT(“abc”,2) # evals “bc”

RREPLACE(x, y, z)

Replaces all occurrences of x in z with y. Uses POSIX-based regular expression matching.

RREPLACE("[ABC]","DEF","ABCDEF")
# “DEFDEFDEFDEF”

SUBSTR(x,y,z)

Gets z characters from x, after skipping first y characters.

SUBSTR("abc",1,2) # evals "bc"

UCHAR(x)

Returns a character based on provided 32 bit Unicode character number x
Unicode Map.com - Public Map of Unicode Characters.

UCHAR(65) # evals to A

UPPER(x)

Converts x to upper case.

UPPER(“Abc”) # evals “ABC”

ABS(x)

Absolute value of the number x.

ABS(-3) # evals to 3

CEIL(x)

Returns closest integer not smaller than x.

CEIL(3.1) # evals to 4

FLOOR(x)

Returns closest integer
not larger than x.

FLOOR(3.7) # evals to 3

LOG(x,y)

Calculates the logarithm in base x of the number y.

LOG(10, 1000)
# evals to approx. 3 (2.999…)

POWER(x,y)

Calculates the y-th power of x.

POWER(2,3) # evals to 8

RANDOM(x,y)

Draws a decimal number between [x, y).

never less than x, surely less than y

x = RANDOM(5,10) # 5<=x<10

ROUND(x, y)

Rounds the number x, leaving up to ydecimal numbers.

ROUND(3.5, 0) # evals to 4
ROUND(3.14, 1) # evals to 3.1

SIGN(x)

Returns number sign (1 or -1) of x.

SIGN(-3) # evals to -1

SQRT(x)

Calculates the square root of x.

SQRT(25) # evals to 5

TRUNC(x)

Truncates the decimal value of x.

TRUNC(3.14) # evals to 3