An expression is:

• an integer or floating point number, with or without a sign prefixed (+ or -); a floating point number must begin with '0' if it is lesser than one (e.g. .31 must be written as 0.31);
• a constant string, enclosed between double quotes (e.g. "string", "12");
• a variable name;
• a function call.

Integer numbers are long integers, floating point numbers are doubles.

All methods and functions accept expressions as their parameters - the number expected is specified in the definition you will find in this manual. The only exception to this rule is represented by:

PUB(id) 

require a variable name as its only parameter

and by the functions which require a function name as their parameter (e.g. SORTUDF).

It is possible to nest a function within a function, as in this example:

SET P = LEFT(RTRIM(LTRIM(S, " "), " "), INC(MUL(R, 2))) 

Proteus determines the type of the variable according to the function being applied; strings and numbers are managed in the same way.

The numeric value of a string is determined by using this rule:

• if the string includes 'e', 'E' or a decimal point ('.'), the number is considered floating point; its integer value corresponds to the truncated value; if the number is not representable as an integer, its value is set to LONG_MIN or LONG_MAX, according to the sign;
• if the string begins with '0x', the number is considered an hexadecimal integer number and intepreted accordingly; its floating point value corresponds to the nearest value as a double;
• if the string begins with '0' and includes only the digits 0-7, the number is considered an octal integer and interpreted accordingly; its floating point value corresponds to the nearest value as a double;
• if the number begins with a sign or does not fall in the previous cases, it it interpreted as in the first case.

A few examples:

CONSOLELN 1.23

1.23

CONSOLELN "1.23"

1.23

CONSOLELN 123

123

CONSOLELN "123"

123

CONSOLELN -123

-123

CONSOLELN "-123"

-123

CONSOLELN 0XFF

255

CONSOLELN "0XFF"

0XFF

CONSOLELN 070

56

CONSOLELN "070"

070

CONSOLELN INC(LTRIM("070", "0"))

71

CONSOLELN INC("070")

57

CONSOLELN INC(070)

57 

Every string can include C-like constants, to specify control characters.
The following escape sequences are supported:

\a \b \f \n \r \t \v \\ \? \' \" 

and the octal, hexadecimal and decimal constants specified in this way:

• \... where ... are 1 to 3 octal digits (0-7)
• \x.. where .. are 1 or 2 hexadecimal digits (0-9, a-f, A-F)
• \d... where ... are 1 to 3 decimal digits (0-9)

By using one of the last three notations it is possible to specify every character between 0 and 255; in every case, if a constant out of the range is specified, the last digit will be discarded and considered as a character by itself.

e.g. \d512 will be interpreted as [51] [50] (the brackets are to be read as 'character corresponding to'; 50 is the ASCII code of the character '2')

At the same time, take care not to create a constant within the range by chaining a constant and a literal value.

Proteus can deal with strings including NULL characters (Ascii 0), but many functions stop interpreting the string at the first NULL; these are:

ADDDATE(s, n)
ADDMONTH(s, n)
BOM(s)
CDOW(s)
CMONTH(s)
CONVDATE(s, n1, n2)
DAY(s)
DCONVDATE(s, n)
DIFFDATE(s1, s2)
DOW(s)
DOY(s)
EOM(s)
FULLDATE(s)
ISDATE(s)
ISLEAP(s)
MONTH(s)
NEXTDAY(s, n)
PREVDAY(s, n)
SHRINKDATE(s)
WOM(s)
WOY(s)
YEAR(s) 

CENTER(s, n)
JUSTIFY(s, n)
PFORMAT(s1, s2)
DETAB(s, n)
ENTAB(s, n)

GETENV(s)
PUTENV(s1, s2) 

MATCH(s1, s2)
IMATCH(s1, s2)
REXMATCH(s1, s2)
REXIMATCH(s1, s2)
REXSTRTRAN(s1, exp, s3)
REXISTRTRAN(s1, exp, s3)
REXFSTRTRAN(s1, exp, func)
REXIFSTRTRAN(s1, exp, func)
REXTOKNEW(s1, exp)
REXITOKNEW(s1, exp)
REXTOKEN(s1, n, exp)
REXITOKEN(s1, n, exp)
REXPOSTOKEN(s1, n, exp)
REXIPOSTOKEN(s1, n, exp)
REXNUMTOKEN(s1, exp)
REXINUMTOKEN(s1, exp)
VECREXSPLIT(s, exp)
VECREXISPLIT(s, exp)
VECREXMATCH(s, exp)
VECREXIMATCH(s, exp)

DIRGET(s)
DIRMAKE(s)
DIROPEN(s, n)
DIRREMOVE(s)
DIRSET(s)
FATTRIB(s)
CHMOD(s, f)
LINK(s1, s2)
FCOPY(s1, s2)
FINSERT(s)
FOPEN(s, n)
FREMOVE(s)
FRENAME(s1, s2)
FRESET(s)
ISFILE(s)
MKTEMP(s)
S2BIN(s)
SYSTEM(s)
CAPTURE(s1, s2, s3, s4)
EXEC(s)
UMASK(s)
ISTIME(s)
TIMETOSEC(s)

Many Windows™-specific functions consider only NULL terminated strings, like their system counterparts, while all other functions operate correctly on strings including NULLs; these are, for example, the routines for extracting tokens and substrings, for joining strings, etc.