Operators and precedence

Operators combine operands (variables, literals, function calls) into expressions. This page lists the operators logiccloud supports and the exact precedence and associativity used by the parser.

Assignment

Operator	Meaning
:=	Assignment. Assigns the value of an expression to a variable.
?=	Reference assignment attempt. Assigns a reference only if the runtime types are compatible, otherwise leaves the target NULL. See references.

Assignment is a statement, not an expression operator — it cannot appear inside a larger expression.

Arithmetic operators

Operator	Meaning
**	Exponentiation (power)
*	Multiplication
/	Division
MOD	Modulo (integer remainder)
+	Addition (binary) / unary plus
-	Subtraction (binary) / unary negation

Comparison operators

All comparison operators sit at the same precedence level and produce a BOOL result.

Operator	Meaning
=	Equal
<>	Not equal
<	Less than
>	Greater than
<=	Less than or equal
>=	Greater than or equal

Bitwise / boolean operators

These operate bit-by-bit on bit-string types and logically on BOOL. In the grammar & and AND are the same operator, and AND, &, OR and XOR all share a single precedence level.

Operator	Meaning
AND, &	Logical / bitwise AND
OR	Logical / bitwise OR
XOR	Logical / bitwise exclusive OR
NOT	Logical / bitwise negation (unary)

enabled := running AND NOT faulted;
mask    := flagsA & flagsB;        // & is AND

Precedence and associativity

From highest to lowest precedence. Within a precedence level the binary operators are left-associative (evaluated left to right); parentheses override precedence entirely.

Precedence	Operators	Notes
Highest	()	Parenthesized sub-expression
	Func(args)	Function / method call
	**	Exponentiation
	unary +, -, NOT	Applied to a single operand
	*, /, MOD
	+, - (binary)
	=, <>, <, >, <=, >=	All comparisons at one level
Lowest	AND / &, OR, XOR	All bitwise/boolean ops at one level

Caution

Unlike some IEC tools that give AND higher precedence than OR/XOR, in logiccloud AND, &, OR and XOR share a single precedence level and associate left to right. Likewise all six comparison operators are at one level. Use explicit parentheses when combining different boolean operators, or mixing comparisons, so the intent is unambiguous:

ok := (a > 0) AND (b < 10) OR done;   // parenthesize to be explicit

Note

The unary operators +, - and NOT bind tighter than the binary arithmetic operators but looser than **, matching the grammar’s unaryExpr rule sitting directly above primaryExpr.