Expressions

The Klive Assembler has a rich syntax for evaluating expressions. You can use the same syntax with the #if directives, the Z80 instructions, and the compiler statements.

You can use operands and operators just like in most programming languages. Nevertheless, the Klive implementation has its particular way of evaluating expressions:

• Expressions can be one of these types:

  • Booleans (true or false)
  • integers (64-bit)
  • floating point numbers (64-bit precision)
  • strings (with 8-bit characters)

• The assembler applies implicit conversion whenever it's possible.

  • Floating point numbers are truncated to integer values.
  • The true Boolean literal is represented with the integer value 1; false with 0.
  • When the assembler needs a Boolean value, 0 is considered false, and any other values as true.
  • There is no implicit conversion between strings and any numeric values.

• When the compiler needs a 16-bit value (for example, ld hl,NNNN), it uses the rightmost 16 bits of an expression's value.

• When a Z80 operation (for example, ld a,NN) needs an 8-bit value, it utilizes the rightmost 8 bits.

• Besides the parentheses — ( and ) — you can use square brackets — [ and ] — to group operations and change operator precedence.

; This is valid
ld hl,(Offset+#20)*2+BaseAddr

; Just like this
ld hl,[Offset+#20]*2+BaseAddr

Instant and Late Expression Evaluation

Depending on the context in which an expression is used, the compiler evaluates it instantly or decides to postpone the evaluation. For example, when you use the .org pragma, the compiler applies immediate evaluation. Let's assume this is your code:

Start: .org #8000 + Later
; code body (omitted)
Later: .db #ff

The value of Later depends on the address in .org, and the .org address depends on Later, so this declaration could not be adequately resolved; it's like a deadlock. The .org pragma would raise an error to avoid such situations, as at the moment of its evaluation, the Later symbol's value is unknown.

For most Z80 instructions, the compiler uses late evaluation:

Start: .org #6000
    ld hl,(MyVar)
    ; code body omitted
    ret
MyVar: .defs 2

When the compiler reaches the ld hl,(MyVar) instruction, it does not know the value of MyVar. Nonetheless, it does not stop with an error but generates the machine code for ld hl,(0), namely #21, #00, and #00; takes a note (it is called a fixup) when MyVal gets a value, the two #00 bytes generated at address #6001 should be updated accordingly.

Operands

You can use the following operands in expressions:

• Boolean, Decimal and hexadecimal literals
• Character literals
• Identifiers
• The current assembly address

Note: String literals cannot be used as operands.

Operators

You can use about a dozen operators, including unary, binary, and ternary. In this section, you will learn about them. They will be introduced in descending order of their precedence.

Conditional Operator

The assembler supports using only one ternary operator, the conditional operator:

conditional-expression ? true-value : false-value

This operation results in -1:

2 > 3 ? 2 : -1

When the conditional-expression evaluates to true, the operation results in true-value; otherwise in false-value.

Note: Conditional expressions are evaluated from right to left, unlike binary operators, which use left-to-right evaluation.

Binary Bitwise Operators

Note: The & operator can be applied to two strings. If you do so, the compiler concatenates the two strings and puts a \r\n (new line) character pair between them.

Relational Operators

Shift Operators

The bits of the left operand are shifted by the number of bits given by the right operand.

Basic Arithmetic Operators

Min-Max operators

Unary operators

Do not forget, you can change the default precedence with ( and ), or with [ and ].

Functions

The Z80 assembler provides a number of functions that can have zero, one, or more arguments. Several functions (for example as rnd()) have overloads with different signatures. Each function has a name and a parameter list wrapped into parentheses, the parameters are separated by a comma. Of course, parameters can be expressions, and they may invoke other functions, too. Here are a few samples:

length("Hello" + " world")
max(value1, value2)
sin(pi()/2)
sqrt(pear + 3.0)

The Klive support these function signatures:

Functions have the same precedence as the unary operators (such as the unary + and -).

Parse Time Functions

The compiler provides a construct, parse time functions. These functions can receive a Z80 assembly language token and transform them into other language constructs. As the name suggests, these functions run in the parsing phase before the compiler emits code.

The lreg() and hreg() Parse Time Functions

These functions accept a 16-bit register pair token (BC, DE, HL, IX, or IY) and retrieve the lower or higher 8-bit register half of their input. Here is a sample code snippet:

ld a,lreg(bc)
ld c,hreg(hl)
ld a,lreg(ix)
ld l,hreg(de)

The compiler sees as if you wrote this:

ld a,c
ld c,h
ld a,ixl
ld l,d

The textof() Parse Time Function

You can use textof(), which accepts these kinds of tokens: mnemonic, register, register indirection, C port, or condition. This function translates these tokens into uppercase string constants that represent them. Here is a sample:

.dm textof(ldir)
.dm textof(bc)
.dm textof((de))
.dm textof((c))
.dm textof(nz)

The compiler sees as if you wrote this code:

.dm "LDIR"
.dm "BC"
.dm "(DE)"
.dm "(C)"
.dm "NZ"