millfork/docs/lang/operators.md

< back to index

Operators

Unlike in high-level languages, operators in Millfork have limited applicability. Not every well-formed expression is actually compilable. Most expressions involving single bytes compile, but for larger types usually you need to use in-place modification operators.
Further improvements to the compiler may increase the number of acceptable combinations.

On 6502-like targets, certain expressions require the commandline flag -fzp-register (.ini equivalent: zeropage_register) to be enabled. They will be marked with (zpreg) next to them. The flag is enabled by default, but you can disable it if you need to.

Precedence

Millfork has different operator precedence compared to most other languages. From highest to lowest it goes:

• -> and []

• *, *'

• +, +', -, -', |, &, ^, >>, >>', <<, <<', >>>>

• :

• ==, !=, <, >, <=, >=

• &&

• ||

• 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 interpreted 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:

• enum means any enumeration type

• byte means any numeric one-byte type

• unsigned byte means any numeric one-byte type that is not signed

• word means any numeric two-byte type, or a byte expanded to a word; pointer is considered to be numeric

• long means any numeric type longer than two bytes, or a shorter 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 that can be assigned to

Split-word operator

Expressions of the shape h:l where h and l are of type byte, are considered expressions of type word.
If and only if both h and l are assignable expressions, then h:l is also an assignable expression.

Indirect field access operator

->

TODO

Binary arithmetic operators

• +, -:
  byte + byte
constant word + constant word
constant long + constant long
constant word + byte
word + word (zpreg)

• *: multiplication; the size of the result is the same as the size of the arguments
  byte * constant byte
constant byte * byte
constant word * constant word
constant long * constant long
byte * byte (zpreg)
  word * byte (zpreg)
  byte * word (zpreg) word * word (zpreg)

• /, %%: unsigned division and unsigned modulo
  unsigned byte / unsigned byte (zpreg)
  word / unsigned byte (zpreg)
  word / word (zpreg)
  constant word / constant word
constant long / constant long

Bitwise operators

• |, ^, &: OR, EXOR and AND
  byte | byte
constant word | constant word
constant long | constant long
word | word (zpreg)

• <<, >>: bit shifting; shifting pads the result with zeroes
  byte << byte
word << byte (zpreg)
  constant word << constant byte
constant long << constant byte

• >>>>: shifting a 9-bit value and returning a byte; a >>>> b is equivalent to (a & $1FF) >> b
word >>>> constant byte

Decimal arithmetic operators

These operators work using the decimal arithmetic (packed BCD).

On Ricoh-based targets (e.g. Famicom) they require the zeropage register to have size at least 4

• +', -': decimal addition/subtraction
  byte +' byte
constant word +' constant word
constant long +' constant long
word +' word (zpreg)

• *': decimal multiplication
  constant *' constant

• <<', >>': decimal multiplication/division by power of two
  byte <<' constant byte

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.

WARNING: Currently in cases like a < f() < b, f() may be evaluated an undefined number of times (the current implementation calls it twice, but do not rely on this behaviour).

The == and != operators also work for non-arithmetic types.

• ==: equality
  enum == enum
byte == byte
simple word == simple word
word == constant
simple word == word (zpreg)
  word == simple word (zpreg)
  simple long == simple long

• !=: inequality
  enum != enum
byte != byte
simple word != simple word
word != constant
simple word != word (zpreg)
  word != simple word (zpreg)
  simple long != simple long

• >, <, <=, >=: inequality
  byte > byte
simple word > simple word
simple word > word (zpreg)
  word > simple word (zpreg)
  simple long > simple long

Currently, >, <, <=, >= operators perform signed comparison if any of the types of their arguments is signed, and unsigned comparison otherwise.

Assignment and in-place modification operators

WARNING: Unlike other languages, Millfork does not provide any guarantees about how many times the left hand side will be evaluated. An expression of form a[f()] += b may call f an undefined number of times.

• =: normal assignment
  mutable enum = enum
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 <<= byte
mutable word <<= byte
mutable long <<= byte

• <<'=, >>'=: decimal 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
mutable byte *= byte (zpreg)
  mutable word *= unsigned byte (zpreg) mutable word *= word (zpreg)

• *'=: decimal multiplication in place
  mutable byte *'= constant byte

• /=, %%=: unsigned division and modulo in place
  mutable unsigned byte /= unsigned byte (zpreg)
  mutable word /= unsigned byte (zpreg) mutable word /= word (zpreg)

There are no ||=, &&= or >>>>= operators.

Indexing

While Millfork does not consider indexing an operator, this is a place as good as any to discuss it.

An expression of form a[i], where i is an expression of type byte, is:

• when a is an array that has numeric index type and T value type:
  an access to the i-th element of the array a

• when a is a raw pointer variable:
  an access to the byte in memory at address a + i

• when a is a typed pointer variable to a 1-byte type T:
  an access to the value pointed to by a

• when a is a typed pointer variable to a 2-byte type T and i is zero:
  an access to the value pointed to by a

• otherwise: a compile error

On 8080-like targets, and on 6502 if the zeropage register is enabled, i can also be of type word.

An expression of form a[i], where i is an expression of a enumeration type, is:

• when a is an array that has index type equal to the type of i: an access to the element of the array a at the location assigned to the key i

• otherwise: a compile error

Note that you cannot access a whole array element if it's bigger than 2 bytes (except in a simple assignment), but you can access its fields or take its pointer:

array(int32) a[6]

a[2]          // not ok
a[2] = 4      // ok, assignments are an exception
x = a[2]      // ok, assignments are an exception
a[2].b0       // ok
a[2].loword   // ok
a[2].pointer  // ok     
a[2].addr     // ok
a[2].b0.addr  // ok, equal to the above on little-endian targets

Built-in functions

• not: negation of a boolean expression
  not(bool)

• nonet: expansion of an 8-bit operation to a 9-bit operation
  nonet(byte + byte)
nonet(byte +' byte)
nonet(byte << constant byte)
nonet(byte <<' constant byte)
  Other kinds of expressions than the above (even nonet(byte + byte + byte)) will not work as expected.

• hi, lo: most/least significant byte of a word
  hi(word)
  Furthermore, any type that can be assigned to a variable can be used to convert either from one type either to another type of the same size, or from a 1-byte integer type to a compatible 2-byte integer type.
  byte → word
word → pointer
  some enum → byte
byte → some enum
  but not
  word → byte
  some enum → word

• sizeof: size of the argument in bytes; the argument can be an expression or a type, and the result is a constant of either byte or word type, depending on situation

• call: calls a function via a pointer;
  the first argument is the pointer to the function;
  the second argument, if present, is the argument to the called function.
  The function can have max one parameter, of size max 2 bytes, and may return a value of size max 2 bytes. You can't create typed pointers to other kinds of functions anyway.
  If the pointed-to function returns a value, then the result of call(...) is the result of the function.
  Using call on 6502 targets requires at least 4 bytes of zeropage pseudoregister.