Gameboy Development Forum

Hi there!

There's one feature I really want in an assembler, and even briefly entertained the idea of writing an assembler myself just to implement it. It's a convenience feature that's meant to help programmers add visual structure within their subroutines. I call them braced code blocks.

Within a subroutine, you may write a pair of curly braces (I chose curly braces because I spend a ton of time with C-family languages, so they're what comes naturally to me), with indented instructions within.

mySubroutine:
  ; Some instructions
  {
    ; Some more instructions
  }
  ; Even more instructions
  ret

On their own, these braces do nothing. In fact, internally they're just special temporary labels (and labels themselves are also just an assembler-level convenience). When execution reaches an opening brace, execution simply enters the block. When execution reaches the closing brace, it exits the block. Effectively, it's the same as if the braces weren't even there.

The utility comes from two new quasi-instructions, `continue` and `break`. These instructions resolve to jump instructions. The `continue` instruction jumps to the opening brace. The `break` instruction jumps to the closing brace.

So the braced code block feature is really just syntactic sugar around vanilla labels and jumps. But they enable visually distinct common code structures.

For example, an if statement:

mySubroutine:
  ; Some instructions
  {
    ; break if [address] != 0
    ld a, [address]
    cp a, 0
    break nz

    ; Body of the `if` statement here
  }
  ; Even more instructions
  ret

A `while` loop is identical to an `if` statement, just with a `continue` at the end.

mySubroutine:
  ; Some instructions
  {
    ; break if [address] != 0
    ld a, [address]
    cp a, 0
    break nz

    ; Body of the `while` loop here

    ; Loop
    continue
  }
  ; Even more instructions
  ret

I think something like that would make my code look far more structured than a continuous run of labels and seemingly-arbitrary jump statements all over the place. And since it just resolves to labels and jump statements, it's just syntactic sugar for old-fashioned assembly.

Well if you automatically jump to the top brace when you reach the end of the block you wouldn't need the `continue` instruction I inserted in my loop example, but you would need to add a `break` instruction at the end of the `if` example. I envisioned the feature as simply allowing code execution to pass through the end of a code block, no automatic looping, so you don't need anything at the end of an `if`, but do need a `continue` at the end of a loop. The braces are simply labels, and `break` and `continue` are simply aliases for jump instructions to the corresponding brace, there's no automatic insertion of jump instructions at the end of the block.

Last edited by DonaldHays (2016-08-12 21:21:23)

Yup, exactly!

Assembler level variables please.