2018-01-10 12:08:24 +00:00
|
|
|
# Operators
|
|
|
|
|
|
|
|
Unlike in high-level languages, operators in Millfork have limited applicability.
|
|
|
|
Not every well-formed expression is actually compilable.
|
2018-01-10 12:17:09 +00:00
|
|
|
Most expressions involving single bytes compile,
|
|
|
|
but for larger types usually you need to use in-place modification operators.
|
2018-01-10 12:08:24 +00:00
|
|
|
Further improvements to the compiler may increase the number of acceptable combinations.
|
|
|
|
|
|
|
|
## Precedence
|
|
|
|
|
|
|
|
Millfork has different operator precedence compared to most other languages. From highest to lowest it goes:
|
|
|
|
|
|
|
|
* `*`, `*'`
|
|
|
|
|
|
|
|
* `+`, `+'`, `-`, `-'`, `|`, `&`, `^`, `>>`, `>>'`, `<<`, `<<'`, `>>>>`
|
|
|
|
|
|
|
|
* `:`
|
|
|
|
|
|
|
|
* `==`, `!=`, `<`, `>`, `<=`, `>=`
|
|
|
|
|
|
|
|
* `&&`
|
|
|
|
|
|
|
|
* `||`
|
|
|
|
|
|
|
|
* assignment and in-place modification operators
|
|
|
|
|
|
|
|
You cannot use two different operators at the same precedence levels without using parentheses to disambiguate.
|
|
|
|
It is to prevent confusion about whether `a + b & c << d` means `(a + b) & (c << d)` `((a + b) & c) << d` or something else.
|
|
|
|
The only exceptions are `+` and `-`, and `+'` and `-'`.
|
|
|
|
They are interpeted as expected: `5 - 3 + 2 == 4` and `5 -' 3 +' 2 == 4`.
|
|
|
|
Note that you cannot mix `+'` and `-'` with `+` and `-`.
|
|
|
|
|
|
|
|
## Argument types
|
|
|
|
|
|
|
|
In the descriptions below, arguments to the operators are explained as follows:
|
|
|
|
|
|
|
|
* `byte` means any one-byte type
|
|
|
|
|
|
|
|
* `word` means any two-byte type, or a byte expanded to a word
|
|
|
|
|
|
|
|
* `long` means any type longer than two bytes, or a shorted type expanded to such length to match the other argument
|
|
|
|
|
|
|
|
* `constant` means a compile-time constant
|
|
|
|
|
|
|
|
* `simple` means either: a constant, a non-stack variable,
|
|
|
|
a pointer indexed with a constant, a pointer indexed with a non-stack variable,
|
|
|
|
an array indexed with a constant, an array indexed with a non-stack variable,
|
|
|
|
an array indexed with a sum of a constant and a non-stack variable,
|
|
|
|
or a split-word expression made of two simple expressions.
|
|
|
|
Examples: `1`, `a`, `p[2]`, `p[i]`, `arr[2]`, `arr[i]`, `arr[i+2]`, `h:l`, `h[i]:l[i]`
|
|
|
|
Such expressions have the property that the only register they may clobber is Y.
|
|
|
|
|
|
|
|
* `mutable` means an expression than can be assigned to
|
|
|
|
|
|
|
|
## Binary arithmetic operators
|
|
|
|
|
|
|
|
* `+`, `-`:
|
|
|
|
`byte + byte`
|
2018-01-10 12:17:09 +00:00
|
|
|
`constant word + constant word`
|
|
|
|
`constant long + constant long`
|
2018-01-10 12:08:24 +00:00
|
|
|
|
2018-01-10 12:17:09 +00:00
|
|
|
* `*`: multiplication; the size of the result is the same as the size of the arguments
|
2018-01-10 12:08:24 +00:00
|
|
|
`byte * constant byte`
|
2018-01-10 12:17:09 +00:00
|
|
|
`constant byte * byte`
|
|
|
|
`constant word * constant word`
|
|
|
|
`constant long * constant long`
|
2018-01-10 12:08:24 +00:00
|
|
|
|
|
|
|
There are no division, remainder or modulo operators.
|
|
|
|
|
|
|
|
## Bitwise operators
|
|
|
|
|
|
|
|
* `|`, `^`, `&`: OR, EXOR and AND
|
2018-01-10 12:17:09 +00:00
|
|
|
`byte | byte`
|
|
|
|
`constant word | constant word`
|
|
|
|
`constant long | constant long`
|
2018-01-10 12:08:24 +00:00
|
|
|
|
2018-01-10 12:17:09 +00:00
|
|
|
* `<<`, `>>`: bit shifting; shifting pads the result with zeroes
|
|
|
|
`byte << constant byte`
|
|
|
|
`constant word << constant byte`
|
|
|
|
`constant long << constant byte`
|
2018-01-10 12:08:24 +00:00
|
|
|
|
|
|
|
* `>>>>`: shifting a 9-bit value and returning a byte; `a >>>> b` is equivalent to `(a & $1FF) >> b`, but the latter doesn't compile yet
|
|
|
|
`word >>>> constant byte`
|
|
|
|
|
|
|
|
## Decimal arithmetic operators
|
|
|
|
|
|
|
|
These operators work using the decimal arithmetic and will not work on Ricoh CPU's.
|
|
|
|
|
|
|
|
* `+'`, `-'`: decimal addition/subtraction
|
|
|
|
`byte +' byte`
|
2018-01-10 12:17:09 +00:00
|
|
|
`constant word +' constant word`
|
|
|
|
`constant long +' constant long`
|
2018-01-10 12:08:24 +00:00
|
|
|
|
|
|
|
* `*'`: decimal multiplication
|
|
|
|
`constant *' constant`
|
|
|
|
|
|
|
|
* `<<'`, `>>'`: decimal multiplication/division by power of two
|
2018-01-10 12:09:38 +00:00
|
|
|
`byte <<' constant byte`
|
2018-01-10 12:08:24 +00:00
|
|
|
|
|
|
|
## Comparison operators
|
|
|
|
|
|
|
|
These operators (except for `!=`) can accept more than 2 arguments.
|
|
|
|
In such case, the result is true if each comparison in the group is true.
|
|
|
|
Note you cannot mix those operators, so `a <= b < c` is not valid.
|
|
|
|
|
|
|
|
* `==`: equality
|
|
|
|
`byte == byte`
|
|
|
|
`word == word`
|
|
|
|
`long == long`
|
|
|
|
|
|
|
|
* `!=`: inequality
|
2018-01-10 12:09:38 +00:00
|
|
|
`byte != byte`
|
|
|
|
`word != word`
|
|
|
|
`long != long`
|
2018-01-10 12:08:24 +00:00
|
|
|
|
|
|
|
* `>`, `<`, `<=`, `>=`: inequality
|
|
|
|
`byte > byte`
|
|
|
|
`word > word`
|
|
|
|
`long > long`
|
|
|
|
|
|
|
|
Currently, `>`, `<`, `<=`, `>=` operators perform unsigned comparison
|
|
|
|
if none of the types of their arguments is signed,
|
|
|
|
and fail to compile otherwise. This will be changed in the future.
|
|
|
|
|
2018-01-10 12:17:09 +00:00
|
|
|
## Assignment and in-place modification operators
|
2018-01-10 12:08:24 +00:00
|
|
|
|
|
|
|
* `=`: normal assignment
|
|
|
|
`mutable byte = byte`
|
|
|
|
`mutable word = word`
|
|
|
|
`mutable long = long`
|
|
|
|
|
|
|
|
* `+=`, `+'=`, `|=`, `^=`, `&=`: modification in place
|
|
|
|
`mutable byte += byte`
|
|
|
|
`mutable word += word`
|
|
|
|
`mutable long += long`
|
|
|
|
|
|
|
|
* `<<=`, `>>=`, `<<'=`, `>>'=`: shift in place
|
|
|
|
`mutable byte <<= constant byte`
|
|
|
|
`mutable word <<= constant byte`
|
|
|
|
`mutable long <<= constant byte`
|
|
|
|
|
|
|
|
* `-=`, `-'=`: subtraction in place
|
|
|
|
`mutable byte -= byte`
|
|
|
|
`mutable word -= simple word`
|
|
|
|
`mutable long -= simple long`
|
|
|
|
|
|
|
|
* `*=`: multiplication in place
|
|
|
|
`mutable byte *= constant byte`
|
|
|
|
|
2018-01-10 12:17:09 +00:00
|
|
|
There is no `*'=` operator yet.
|
|
|
|
|