You might have notice that during the past few months i’ve written a few articles about haXe, a language and compiler which pits itself as a “toolbox for the web developer”.

Recently i decided to test out haXe’s platform support. I did this by taking my SCUMM interpreter code – which i had previously written for flash 9 – and tried to get it to work on the other two major platforms haXe supports, javascript and neko.

To start off with, i had to remove its dependency on flash. This was achieved by making replacement classes and switching between the two using the conditional pre-processor. i.e.:

#if flash9
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.utils.ByteArray;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.utils.Timer;
import flash.events.TimerEvent;
#else neko
import noflash.ByteArray;
import noflash.Bitmap;
import noflash.BitmapData;
import noflash.Point;
import noflash.Rectangle;
import noflash.Timer;
import noflash.TimerEvent;
#end

Most of the modifications to the code looked like this, with liberal sprinklings of ”#if flash9 … #end” round the flash specific code.

Eventually i got to the point where things started to look like they were going to compile, or so i thought…

Problems

“Array too big”

The first problem i encountered was that it wouldn’t compile.

hiscumm/SCUMM6.hx:1870: lines 1870-2127 : This array declaration is too big, try to split it

Array declaration too big? What on earth was it going on about?

| TArrayDecl el ->
if List.length el > 115 then error "This array declaration is too big, try to split it" e.epos;
call p (field p (ident p "Array") "new1") [array p (List.map (gen_expr ctx) el); int p (List.length el)]

Oh, right. Seems i cannot have arrays declared with more than 115 elements. A seemingly arbitrary limitation that is not referenced anywhere in the documentation – great!

Not needing the opcode table for my little experiment, i commented most of it out. Problem solved.

“32bit? no, 31bit!”

Now the first time i got the interpreter to compile for neko, i thought “Wow, great! Looks like this is going to work.” Unfortunately though, it didn’t. Instead, i got a rather odd exception when reading out of my replacement ByteArray:

Uncaught exception - Overflow

Turns out the problem was with this code here, in neko.Input:

public function readInt32() {
var ch1 = readChar();
var ch2 = readChar();
var ch3 = readChar();
var ch4 = readChar();
if( (ch4 & 128) != 0 ) {
if( ch4 & 64 == 0 ) throw Error.Overflow;
return ch1 | (ch2 << 8) | (ch3 << 16) | ((ch4 & 127) << 24);
} else {
if( ch4 & 64 != 0 ) throw Error.Overflow;
return ch1 | (ch2 << 8) | (ch3 << 16) | (ch4 << 24);
}
}

So basically the reader was trying to stuff the whole 32 bit value into a neko Integer, which is actually 31 bits. Oddly enough though, the value being read was identical to a value i specified in the code.

But haXe never bothered to complain about an overflow!

This can be demonstrated by the following code, which prints “-766623411” instead of the expected “1380860237”.

trace(1380860237);

Thankfully, a solution exists. There is an “Int32” type which properly handles 32bit integers. However there is a really big snag with it – it’s a class.

That means you cannot use any fancy inbuilt operators with it – you have to use a set of functions instead.

import neko.Int32;

var result: Int = 1 + 2; // simple
var result32: Int32 = Int32.add(Int32.ofInt(1), Int32.ofInt(2)); // aaaarrrghh!!!

result += 1; // simple
result32 += 1; // don't even think about it, it won't work

And to top it all off, this “Int32” class only exists for the neko platform, you cannot use it with flash or javascript. Unless you write it yourself, but that is besides the point. It should at least have been there to fill in the gap.

Conclusion

If you are looking at writing code in haXe and want it to work across all 3 of its supported platforms (flash*, neko and javascript), then beware if you are reading, writing, or otherwise processing 32bit integers.

In addition watch out for mysterious arbitrary limitations such as the 115 item limit for declared arrays.

ShareThis