Operators

Report a language bug | Report a documentation error

Like algebra from school where x=4, y=6-2, and z=x+y; the characters =, -, and + are operators.

Example:

+ is used to add numbers.

$ is used to concatenate strings.

AND is used to compare values.

Miva Script provides the following types of operators:

Arithmetic operators
Comparison operators
Logical operators
Text string operators
Bitwise operators

Miva Script operators have a built-in precedence that determines which operator gets processed first when two or more operators are expressed.

You can also override the built-in precedence by surrounding sub-expressions with parentheses

From highest to lowest MivaScript Operators:

++ -- (New in 5.17. See Example 1)
NOT
ROUND, CRYPT, MOD, SUBSTR, POW
/, *
+,-,$
IN, CIN, EIN, ECIN, EQ, NE, GE, LE, LT, GT, ISNULL
AND, OR

Increment ++ and decrement -- operators are now supported inside MivaScript expressions. Both pre and post increment/decrement are allowed.

IMPORTANT:

Pre-increment/decrement always happens before other operations:
Post-increment/decrement always happens after other operations:
When used within a dynamic expression (MvDO EXPR, MvFILTER EXPRESSION, etc..), the generated MivaScript file will be incompatible with Empresa versions prior to 5.17. When compilation includes a compatibility flag, for example "-C 5.16", a compiler warning will be generated when an increment or decrement operator is detected inside a dynamic expression.

Example 1:

<MvEVAL EXPR = "{ l.var++ }">
<MvASSIGN NAME = "l.array" INDEX = "{ ++l.pos }" VALUE = "{ l.var }">

Pre-increment/decrement always happens first:

l.row * ++l.col: Increment happens before multiplication
--l.col + l.row: Decrement happens before addition

Operator Precedence:
l.row * l.col++: Increment happens after multiplication
l.col++ + l.row: Increment happens after addition

You might incorrectly assume the expression below is calculated right to left.

Example 2:

"{ 10 + 8 * 0.3366 ROUND 2 }"

10 + 8 = 18
18 * .3333 = 5.9994
5.9994 ROUND 2 = 5.99

Wrong Result: 5.99

Changing the expression to match the operator precedence order illustrates the issue.

Example 3:

"{ 0.3366 ROUND 2 * 8 + 10 }"

0.3366 ROUND 2 = 0.34
0.34 * 8 = 2.72
2.72 + 10 = 12.72

Actual Result: 12.72

However, neither of these is the result we wanted. Use parenthesis to explicitly declare how the formula should be evaluated and remove all ambiguity. Parenthesis are evaluated first.

Example 4:

{ 10 + ((8 * 0.3366) ROUND 2) }

(8 * 0.3366) = 2.6928
(2.6928 ROUND 2) = 2.69
10 + 2.26 = 12.69

Correct Result: 12.69

These operators are used with numbers or numeric expressions. Miva Script also provide many built-in numerical functions. Note: A minus sign can precede a literal number to make it negative (for example, -3.14), but using - before of a variable will return null. (for example, - g.x ). To express the negative of a numeric value, use "{ -1 * x }" or "{ 0 - x }". Using +, /, or * as a unary operator results in a compiler expression error.

Added in 5.17: Increment (++) and decrement (--) operators are now supported inside MivaScript expressions. Both pre and post increment/decrement are allowed.

Note: When used within a dynamic expression (MvDO EXPR, MvFILTER EXPRESSION, etc..), the generated MivaScript file will be incompatible with Empresa versions prior to 5.17. When compilation includes a compatibility flag, for example "-C 5.16", a compiler warning will be generated when an increment or decrement operator is detected inside a dynamic expression.

Example:

<MvEVAL EXPR = "{ l.var++ }">
<MvASSIGN NAME = "l.array" INDEX = "{ ++l.pos }" VALUE = "{ l.var }">

Operator	Name	Description / Example
+	Addition	expression1 + expression2 / "{ 10 + 2 }" = 12
++	Incriment	{ variable++ } or { ++variable }
-	Subtraction	expression1 - expression2 / "{ 12 - 2 }" = 10
++	Decrement	{ variable-- } or { --variable }
*	Multiplication	expression1 * expression2 / "{ 10 * 2 }" = 20
/	Division	expression1 * expression2 / "{ 20 / 2 }" = 10
POW	Power	expr1 POW expr2 Raise expr1 to the power expr2 For example, 3 POW 4 is 34, or 81.
MOD	Modulo	expr1 MOD expr2 / "{ 4 POW 2 }" = 16 Returns the integer remainder from expr1/expr2 / 21 MOD 5 is 1. See also the function fmod(), which returns floating point remainders.
ROUND	Number Rounding	number ROUND places Rounds number up or down to places decimal places. For example, "{ 1.494 ROUND 2 }" returns 1.49 "{ 1.495 ROUND 2 }" returns 1.50 See also function floor() and ceil()

These operators are used to compare two numeric or strings expressions. Comparisons always return a value of 1 (true) or 0 (false). In MivaScript a zero, null string, or null value is considered false, all other values are considered true.

Text string comparisons are case sensitive, e.g. "Tree" is not equal to 'tree". Use the function toupper() or tolower() to compare string where the case is irrelevant. "{ tolower("TRee") EQ 'tree' }" returns true.

Lowercase letters are greater than uppercase letters.. "{ 'T' LT 't' }" returns true.

Operator	Name	Description / Example
EQ	.Equal to	expression1 EQ expression2 / "{ 12 EQ 12 }"
GT	Greater Than	expression1 GT expression2 / "{ 12 GT 2 }"
LT	.Less Than	expression1 LT expression2 / "{ 2 LT 12 }"
NE	Not Equal	expression1 NE expression2 / "{ 12 NE 2 }"
GE	Greater Than or Equal	expression1 GE expression2 / "{ 12 GE 12 }"
LE	Less Than or Equal	expression1 LE expression2 / "{ 2 LE 12 }"

In this example the loop continues while "{ l.posn is Less than or Equal to 10 }".
The variable l.posn creates an incrementing number e.g. l.posn = l.posn + 1
On each pass through the loop "{ l.posn MOD 2 }" alternates between true and false.

Example:

<MvASSIGN NAME="l.posn" VALUE="{ 1 }">
<MvWHILE EXPR="{ l.posn LE 10 }">
    <MvIF EXPR="{ l.posn MOD 2 }">
        l.posn is Odd<br>
    <MvELSE>
        l.posn is Even<br>
    </MvIF>
    <MvASSIGN NAME="l.posn" VALUE="{ l.posn + 1 }">
</MvWHILE>

paragraph

Logical operators are used to determine the logic between variables or values. Using parentheses to group separate logic operations often increases clarity in complex expressions.

Operator	Name	Description / Example
NOT	Logical NOT	NOT expression Acts on one expression. Returns the opposite of expression "{ NOT ( 0 LT 2 ) }" Returns false..
AND	Logical AND	expression1 AND expression2 Returns true if all conditions are true "{ (1 LT 2) AND (3 GT 2) }" Returns true.
OR	Logical OR	expression1 OR expression2 Returns true if any condition is true "{ (1 LT 2) OR (1 GT 2) }" Returns true.
ISNULL	Tests NULL value	ISNULL expression2 Returns true is the value tested is null. "{ ISNULL '' }" Returns true.

Example:

<MvIF EXPR="{ ISNULL g.Email }">
    Please enter and email address.<br>
<MvELSEIF EXPR="{ g.Subject AND g.Message AND g.PhoneNumber }">
    ...Sending your email...
<MvELSE>
    Please enter a Subject, Message, and PhoneNumber<br>
</MvIF>

Note:
"{ g.Subject AND g.Message AND g.PhoneNumber }" returns true if all items have values. In contrast,
"{ (ISNULL g.Subject) OR (ISNULL g.Message) OR (ISNULL g.PhoneNumber) }" Returns true if any item is empty


<MvIF EXPR="{ (g.Screen EQ 'CTGY') OR (g.Screen EQ 'PROD') }">
one of these condition is true.
</MvIF>

In this example, we test for an end of file (eof) condition in a products table. Although both sections of script do the exact same thing, using NOT Products.d.eof makes more sense.

Example:

<MvIF EXPR="{ Products.d.eof }">
<MvELSE>
    process this record...
</MvIF>

<MvIF EXPR="{ NOT Products.d.eof }">
    process this record...
</MvIF>

These operators are used with strings or string expressions. Miva Script also supports a rich set of string functions.

Operator	Name	Description / Example
$	Concatenate strings	expression1 $ expression2 / "{ 'Scooby ' $ 'Doo' }" Result 'Scooby Doo'. Concatenates (joins) the strings expression1 and expression2 together.
IN / CIN	Beginning position	expression1 IN expression2 / "{ 'oo' IN 'Scooby Doo' }" Result 3 / "{ 'OO' IN 'Scooby Doo' }" Result 0 Case sensitive search for expression1 contained in expression2 returns the position of the first matching character in expression 2. If no match is found returns 0. expression1 IN expression2 / "{ 'Oo' CIN 'Scooby Doo' }" Result 3 Case insensitive search for expression1 contained in expression2 returns the position of the first matching character in expression 2. If no match is found returns 0.
EIN / ECIN	End position	expression1 EIN expression2 / "{ 'y D' EIN 'Scooby Doo' }" Result 8 the position of the letter "D" / "{ 'Y D EIN 'Scooby Doo' }" Result 0 Case sensitive search for expression1 contained in expression2 returns the last position of matching characters in expression 2. If no match is found returns 0. expression1 ECIN expression2 / "{ 'Y d' ECIN 'Scooby Doo' }" Result 8 the position of the letter "D" Case insensitive search for expression1 contained in expression2 returns the last position of matching characters in expression 2. If no match is found returns 0.
CRYPT	Encrypt a string	string_expression CRYPT string_key / "{ user_password CRYPT ( substring( s.dyn_time_t, 8, 2 ) ) }" Performs a one-way encryption. The string_expression is encrypted using the string key. The first eight characters of string_expression and the first two characters of key is used in the encryption CRYPT always yields the same result when applied to a particular expression and key .

Example:

<MvASSIGN NAME="g.name" VALUE="{ 'Scooby' $ ' ' $ 'Doo' }">

<MvASSIGN NAME="g.first_name" VALUE="{ substring(g.name, 1, (' ' IN g.name) - 1) }">
<MvASSIGN NAME="g.last_name" VALUE="{ substring(g.name, (' ' IN g.name) + 1, len(g.name)) }">

Mr. <MvEVAL EXPR="{ g.last_name $ ', ' $ g.first_name }"><br>

Result: Mr. Doo, Scooby

These operators act on numbers at the binary or 'bit' level.

Operator	Name	Description / Example
BITAND	Bitwise AND	expression1 BITAND expression2 / Perform a logical AND on the bits of expr_a and expr_b.
BITOR	Bitwise OR	expr_a BITOR expr_b Perform a logical OR on the bits of expr_a and expr_b.
BITXOR	Bitwise Exclusive OR	expr_a BITXOR expr_b Perform a logical exclusive OR on the bits of expr_a and expr_b (return the number whose bits are equal to 1 in either, but not both, of the original numbers).
BITOC	Bitwise ones complement	BITOC expr Flip the bits of expr (including the 'sign bit'). This operator is unary: it acts on one number, not two. Example: {BITOC 9}. 9 in binary form is '1001'; including the 'sign bit' (left most bit), which indicates that the number is positive, it is '01001'. Flipping these bits gives '10110'. Since the sign bit is now '1', the number is negative. According to the rules of binary arithmetic, '0110' interpreted as a negative number is '-10'.
BITSL	Bitwise shift-left	expr_a BITSL expr_b Shift the bits of expr_a to the left by expr_b places. The leftmost bits are lost, and the rightmost bits are replaced by zeroes.'{23 BITSL 2}' is interpreted as follows: 23 is 00010111 in binary form; shifting these bits left two places gives 01011100, or 92 in decimal format.
BITSR	Bitwise shift-right	expr_a BITSR expr_b Shift the bits of expr_a to the right by expr_b places. The rightmost bits are lost, and the leftmost bits are replaced by zeroes.

This example converts a single text character to a Hexadecimal character string.

Example:

<MvASSIGN NAME="l.character" VALUE="z">
<MvASSIGN NAME="l.byte" VALUE="{ asciivalue(l.character) }">

<MvASSIGN NAME = "l.msb" VALUE = "{ ( l.byte BITAND 240 ) BITSR 4 }">
<MvIF EXPR = "{ l.msb GT 9 }">
    <MvASSIGN NAME = "l.msb" VALUE = "{ asciichar( 97 + ( l.msb - 10 ) ) }">
</MvIF>

<MvASSIGN NAME = "l.lsb" VALUE = "{ l.byte BITAND 15 }">
<MvIF EXPR = "{ l.lsb GT 9 }">
    <MvASSIGN NAME = "l.lsb" VALUE = "{ asciichar( 97 + ( l.lsb - 10 ) ) }">
</MvIF>

<MvEVAL EXPR="{ l.character }"> = HEX <MvEVAL EXPR="{ l.msb $ l.lsb }">

+ Add a note

User Annotations: operators

BITXOR is a useful operator if you want to generate alternating true/false values.
If the value is undefined or zero, the following example will return 1 otherwise it will return one.
A practical use would be to apply alternating row colours using an array of two elements with either a CSS class name or hex colour value.
Since Mivascript arrays are 1 based, it is necessary to add one to the result of the BITXOR to get the array index.

<mvassign name = "l.rowclass" value = "{miva_array_deserialize('row1,row2'}">
<mvfor count = "{ 10 }">
<mvassign name = "l.alternate" value = "{l.alternate BITXOR 1}">
<tr class = "{l.rowclass[l.alternate + 1]}"><td>Some text</td></tr>
</mvfor>

MivaScript Basics

MivaScript Reference

MivaScript Advanced

Operators

Example:

Operator Precedence

Example 1:

Example 2:

Example 3:

Example 4:

Arithmetic Operators

Example:

Comparison Operators

Example:

Logic Operators

Example:

Example:

Text String Operators

Example:

Bitwise Operators

Example: