Version blocks

Version blocks allows one to write platform-specific code. For example:

#!ooc
runThing: class {
  version (windows) {
    // use CreateProcess ...
    return
  }

  version (!windows) {
    // use something more unix-y
  }
}

Version blocks support complex binary expressions, like &&, ||, !, and any depth of parenthesis nesting. For example:

#!ooc
version (!(osx || linux)) {
  // not on osx, nor on linux
}

Available version blocks and their corresponding C defines are as follow:

The specs in italics are “complex” specs - they can’t be in a composed version expression, e.g. this is invalid:

#!ooc
version (64 && osx) {
    // code here
}

Consider doing this instead:

#!ooc
version (64) {
    version (osx) {
        // code here
    }
}

The reason for this is that osx, ios, and ios_simulator are not simple #ifdefs in the generated code, but they require an include and an equality test.

Line continuations

Any line can be broken down on several lines, by using the backslash character, \, as a line continuation:

#!ooc
someList \
map(|el| Something new(el))

If it wasn’t for that \ before the end of the line, map would be interpreted as a separate function call, and not a method call.

Constants

Some constants are accessible anywhere and will be replaced at compile time with strings. Those are:

• __BUILD_DATETIME__
• __BUILD_TARGET__
• __BUILD_ROCK_VERSION__
• __BUILD_ROCK_CODENAME__
• __BUILD_HOSTNAME__

Call chaining

While not technically a preprocessor feature, the following code:

#!ooc
a := ArrayList<Int> new(). add(1). add(2). add(3)

Is equivalent to:

#!ooc
a := ArrayList<Int> new()
a add(1). add(2). add(3)

Itself equivalent to:

#!ooc
a := ArrayList<Int> new()
a add(1)
a add(2)
a add(3)