prelude.qat

.start-lua
    local function validate_equals_order(r1, r2, r3)
        if order_of_reg(r3) < order_of_reg(r1) or
            order_of_reg(r3) < order_of_reg(r2) then
            error("Register 3 must not be the minimum order (" ..
                order_of_reg(r3) .. " < min(" .. order_of_reg(r1) .. ", " ..
                order_of_reg(r2) .. ")"
            )
        end

        -- functions that do not output qat must otherwise return nil
        return nil
    end

    function validate_same_orders(...)
        local args = {...}
        local first = order_of_reg(args[1])

        for i = 2, #args do
            if order_of_reg(args[i]) ~= first then
                error("Arguments are not all the same value")
            end
        end

        return nil
    end

    function subtract_order_relative(r1, n)
        return { { "add", r1, order_of_reg(r1) - n } }
    end
end-lua

.macro sub {
    ($R:reg $N:int) => lua subtract_order_relative($R, $N)
}

.macro inc {
    ($R:reg) => add $R 1
}

.macro dec {
    ($R:reg) => sub $R 1
}

.macro move {
    ($R1:reg to $R2:reg) => {
        zero_loop:
            solved-goto $R1 move_done
            dec $R1
            inc $R2
            goto zero_loop
        move_done:
    }
}

.macro set {
    ($R1:reg to $R2:reg) => {
        set $R1 to 0
        move $R2 to $R1
    }

    ($R:reg to $N:int) => {
        zero_loop:
            solved-goto $R move_done
            dec $R
            goto zero_loop
        move_done:
            add $R $N
    }
}

.macro if {
    (solved $R:reg $code:block) => {
            solved-goto $R do_if
            goto after_if
        do_if:
            $code
        after_if:
    }
    (not-solved $R:reg $code:block) => {
            solved-goto $R after_if
            $code
        after_if:
    }
    (solved $R:reg $code1:block else $code2:block) => {
        if not-solved $R {
            $code2
        } else {
            $code1
        }
    }
    (not-solved $R:reg $code1:block else $code2:block) => {
            if not-solved $R {
                $code1
                goto over_else
            }
            $code2
        over_else:
    }
    (equals $R:reg $N:int $code:block) => {
        if equals $R $N {
            $code
        } else {}
    }
    (not-equals $R:reg $N:int $code:block) => {
        if not-equals $R $N {
            $code
        } else {}
    }
    (equals $R:reg $N:int $code1:block else $code2:block) => {
        if not-equals $R $N {
            $code2
        } else {
            $code1
        }
    }
    (not-equals $R:reg $N:int $code1:block else $code2:block) => {
        sub $R $N
        if not-solved $R {
            add $R $N
            $code2
        } else {
            add $R $N
            $code1
        }
    }
    (equals $R1:reg $R2:reg using $R3:reg $code:block) => {
            lua validate_equals_order($R1, $R2, $R3)
            set $R3 to 0
        equals_loop:
            solved-goto $R1 first_zero
            solved-goto $R2 fail_loop
            dec $R1
            dec $R2
            inc $R3
            goto equals_loop
        first_zero:
            solved-goto $R2 success_loop
        fail_loop:
            solved-goto $R3 fail
            inc $R1
            inc $R2
            dec $R3
            goto fail_loop
        success_loop:
            solved-goto $R3 success
            inc $R1
            inc $R2
            dec $R3
            goto success_loop
        success:
            $code
        fail:
    }
    (not-equals $R1:reg $R2:reg using $R3:reg $code:block) => {
            lua validate_equals_order($R1, $R2, $R3)
            set $R3 to 0
        equals_loop:
            solved-goto $R1 first_zero
            solved-goto $R2 fail_loop
            dec $R1
            dec $R2
            inc $R3
            goto equals_loop
        first_zero:
            solved-goto $R2 success_loop
        fail_loop:
            solved-goto $R3 fail
            inc $R1
            inc $R2
            dec $R3
            goto fail_loop
        success_loop:
            solved-goto $R3 success
            inc $R1
            inc $R2
            dec $R3
            goto success_loop
        -- Only change is to swap these two labels
        fail:
            $code
        success:
    }
    (equals $R1:reg $R2:reg using $R3:reg $code1:block else $code2:block) => {
            if equals $R1 $R2 using $R3 {
                $code1
                goto over_else
            }
            $code2
        over_else:
    }
    (not-equals $R1:reg $R2:reg using $R3:reg $code1:block else $code2:block) => {
        if equals $R1 $R2 using $R3 {
            $code2
        } else {
            $code1
        }
    }
}

.macro loop {
    ($code:block) => {
        !continue:
            $code
            goto continue
        !break:
    }
}

.macro while {
    (solved $R:reg $code:block) => {
            goto continue
        do_iteration:
            $code
        !continue:
            solved-goto $R do_iteration
        !break:
    }
    (not-solved $R:reg $code:block) => {
        !continue:
            solved-goto $R break
            $code
            goto continue
        !break:
    }
    (equals $R:reg $N:int $code:block) => {
        loop {
            if not-equals $R $N {
                goto break
            }
            $code
        }
    }
    (not-equals $R:reg $N:int $code:block) => {
        loop {
            if equals $R $N {
                goto break
            }
            $code
        }
    }
    (equals $R1:reg $R2:reg using $R3:reg $code:block) => {
        loop {
            if not-equals $R1 $R2 using $R3 {
                goto break
            }
            $code
        }
    }
    (not-equals $R1:reg $R2:reg using $R3:reg $code:block) => {
        loop {
            if equals $R1 $R2 using $R3 {
                goto break
            }
            $code
        }
    }
}

.start-lua
    -- `repeat` is a lua keyword
    function repeat_(code, start, end_, var)
        local output = {}

        for i = start, end_ do
            if var ~= nil then
                output[#output + 1] = { ".define", "$" .. var, i }
            end
            output[#output + 1] = { code }
        end

        return output
    end
end-lua

.macro repeat {
    ($times:int $code:block) => lua repeat_($code, 1, $times)

    ($times:int $var:ident $code:block) => lua repeat_($code, 1, $times, $var)

    -- should parse nested for loops such as `repeat j from $i to 10 { ... }`
    -- because the outer $i should be evaluated first
    ($times:int $var:ident from $start:int to $end:int $code:block) => {
        lua repeat_($code, $start, $end, $var)
    }
}

.start-lua
    function multiply(r1, r2, r3)
        validate_same_orders(r1, r2, r3)
        local output = {}
        -- TODO: Implement multiplication. Result in register r1, nullify r2/r3
        return output
    end
end-lua

.macro multiply {
    ($R1:reg $R2:reg using $R3:reg) => {
        lua multiply($R1, $R2, $R3)
    }
    ($R1:reg $N:int at $R2:reg) => {
            set $R2 to 0
        multiply_loop:
            solved-goto $R1 multiply_done
            add $R2 N
            dec $R1
            goto multiply_loop
        multiply_done:
    }
}