Arrays for reading and writing values in virtual memory. Virtual addresses are always used for indices regardless of type size.

var addr_power = 0x8033B21E

if(mem.u8[addr_power] < 1)
{
    mem.u8[addr_power] = 8
}

Returns a Buffer object from a block of data of size bytes at baseAddr in virtual memory.

Returns a string from a zero-terminated ASCII string at baseAddr in virtual memory.

Adds property name to obj and "binds" it to the virtual address specified by baseAddr. Valid types are: u8, u16, u32, s8, s16, s32, float, and double.

mem.bindvar(this, 0x8033B21E, 'power', u8)

if(power < 1)
{
    power = 8
}

Adds multiple virtual memory-bound properties to obj. Returns obj.

var mario = mem.bindvars({},
[
    [0x8033B1B0, 'y', float],
    [0x8033B21E, 'power', u8]
])

mario.power = 5
mario.y = 500.00

Adds multiple virtual memory-bound properties to obj. Addresses are determined by type sizes. Returns obj.

var marioPos = mem.bindstruct(this, 0x8033B1AC,
{
    x: float,
    y: float,
    z: float
})

Returns a "struct" class that may be constructed using the address of a real struct in virtual memory.

const Player = mem.typedef(
{
    health: u32,
    x: float,
    y: float,
    z: float
})

Player.prototype.move = function(x, y, z)
{
    this.x = x
    this.y = y
    this.z = z
}

Player.prototype.heal = function()
{
    this.health = 100
}

var player = new Player(0x8033B1AC)

player.move(100, 200, 300)
player.heal()

Arrays for reading values in cartridge ROM. Indexing works in a similar manner to mem's.

var crc1 = rom.u32[0x00000010]
var crc2 = rom.u32[0x00000014]

Returns a Buffer object from a block of data of size bytes at baseAddr in cartridge ROM.

Returns a string from a zero-terminated ASCII string at baseAddr in cartridge ROM.

var romName = rom.getstring(0x00000020)
console.log('Internal ROM name: ' + romName)

Adds a CPU execution callback for a virtual address or AddressRange and returns a callback ID. callback will be invoked at the beginning of a CPU step if the program counter is at address. callback receives the program counter address at which the event is fired.

events.onexec(0x802CB1C0, function()
{
    console.log('CPU is calling 0x802CB1C0')
})

events.onexec(ADDR_ANY, function(pc)
{
    // Log every step!
    console.log('CPU is executing 0x' + pc.hex())
})

Adds a CPU read callback for a virtual address or AddressRange and returns a callback ID. callback will be invoked at the beginning of a CPU step if the current instruction is going to read from address. callback receives the virtual address that the CPU is going to read.

events.onread(0x8033B1B0, function()
{
    console.log('CPU is reading 0x8033B1B0')
})

events.onread(ADDR_ANY_CART_ROM_UNC, function(addr)
{
    console.log('CPU is reading ROM 0x' + addr.hex())
})

Adds a CPU write callback for a virtual address or AddressRange and returns a callback ID. callback will be invoked at the beginning of a CPU step if the current instruction is going to write to address. callback receives the virtual address that the CPU is going to write to.

events.onwrite(0x8033B1B0, function()
{
    console.log('CPU is modifying 0x8033B1B0')
})

events.onwrite(ADDR_ANY_CART_ROM_UNC, function(addr)
{
    console.log(gpr.pc.hex() + ': wrote to cartridge ' + addr.hex())
})

Adds a CPU execution callback for a virtual address or AddressRange and returns a callback ID. callback will be invoked at the beginning of a CPU step if the program counter is at address and opcode is equal to the opcode to be executed. callback receives the program counter address at which the event is fired.

const JR_RA = 0x03E00008 // 'jr ra' command

events.onopcode(ADDR_ANY, JR_RA, function(pc)
{
    console.log(pc.hex()) // log pc at every 'jr ra'
})

Adds a CPU execution callback for a virtual address or AddressRange and returns a callback ID. callback will be invoked at the beginning of a CPU step if the program counter is at address and opcode is equal to the opcode to be executed ANDed with mask. callback receives the program counter address at which the event is fired.

const ADDIU_SP_SP = 0x27BD0000 // 'addiu sp, sp, 0x0000'
const NO_IMM16 = 0xFFFF0000 // mask off immediate field

events.onopcode(ADDR_ANY, ADDIU_SP_SP, NO_IMM16, function(pc)
{
    // log pc at every 'addiu sp, sp, x' regardless of the immediate value
    console.log(pc.hex())
})

const JAL = 0x0C000000 // 'jal 0x00000000'
const NO_TARGET = 0xFC000000 // mask off target field

events.onopcode(ADDR_ANY, JAL, NO_TARGET, function(pc)
{
    // log pc at every 'jal' regardless of the target address
    console.log(pc.hex())
})

Adds a CPU execution callback for a virtual address or AddressRange and returns a callback ID. callback will be invoked at the beginning of a CPU step if the program counter is at address and the lower 32 bits of the general purpose registers specified by registers are equal to value. callback receives the program counter address at which the event is fired, and the index of the first register that contains the value.

events.ongprvalue(ADDR_ANY, GPR_ANY, 0x49533634, function(pc, reg)
{
    // log pc whenever any general purpose register contains 0x49533634
    console.log(pc.hex(), asm.gprname(reg))
})

events.ongprvalue(ADDR_ANY, GPR_A0 | GPR_A1, 0x00001234, function(pc, reg)
{
    // log pc whenever A0 or A1 contains 0x00001234
    console.log(pc.hex(), asm.gprname(reg))
})

Valid registers:

GPR_R0 GPR_AT GPR_V0 GPR_V1 GPR_A0 GPR_A1 GPR_A2 GPR_A3
GPR_T0 GPR_T1 GPR_T2 GPR_T3 GPR_T4 GPR_T5 GPR_T6 GPR_T7
GPR_S0 GPR_S1 GPR_S2 GPR_S3 GPR_S4 GPR_S5 GPR_S6 GPR_S7
GPR_T8 GPR_T9 GPR_K0 GPR_K1 GPR_GP GPR_SP GPR_FP GPR_RA

GPR_ANY_ARG  -- Any of the 'A' registers
GPR_ANY_TEMP -- Any of the 'T' registers
GPR_ANY_SAVE -- Any of the 'S' registers
GPR_ANY      -- Any register

Adds a callback which will be invoked immediately after Project64 requests a screen update from the graphics plugin. Returns a callback ID.

events.ondraw(function()
{
    console.log('Frame drawn')
})

Removes a registered callback by its ID.

var callbackId = events.onexec(0x80000180, function()
{
    // Only invoked once
    console.log('Interrupt fired')
    events.remove(callbackId)
})

Pauses emulation and opens the debugger window. Useful for creating conditional breakpoints.

events.onexec(0x802CB1C0, function()
{
    if(gpr.a0 == 0)
    {
        console.log('0 passed to 0x802CB1C0, breaking')
        debug.breakhere()
    }
})

Returns the name of the general purpose register specified by regIndex.

asm.gprname(4) // 'a0'

Opens the file pointed to by path in the mode specified by mode. Returns a file descriptor on success or false if the operation failed.

var fd = fs.open('log.txt', 'w')

Valid modes:

r or rb           Open file for reading.
w or wb           Truncate to zero length or create file for writing.
a or ab           Append; open or create file for writing at end-of-file.
r+ or rb+ or r+b  Open file for update (reading and writing).
w+ or wb+ or w+b  Truncate to zero length or create file for update.
a+ or ab+ or a+b  Append; open or create file for update, writing at end-of-file.

http://pubs.opengroup.org/onlinepubs/009695399/functions/fopen.html

Closes the file referenced by fd.

Writes buffer to the file referenced by fd. Returns the number of bytes written.

var fd = fs.open('log.txt', 'w')
fs.write(fd, 'Hello world!\n')
fs.close(fd)

var buf = mem.getblock(0x8033B400, 4 * 32)
var fd = fs.open('data.bin', 'wb')
fs.write(fd, buf)
fs.close(fd)

Writes buffer to the file pointed to by path. Returns true if the operation was successful or false if the operation failed.

Reads the file referenced by fd into buffer. Returns the number of bytes read.

var buf = new Buffer(128)
var fd = fs.open('data.bin', 'rb')
var nBytesRead = fs.read(fd, buf, 0, buf.length, 0)
fs.close(fd)

Reads the file pointed to by path. Returns a Buffer object representing the file, or false if the operation failed.

Returns an fs.Stats object describing the file referenced by fd.

var stats = fs.fstat(fd)
console.log('size: ' + stats.size)

Returns an fs.Stats object describing the file or directory pointed to by path. Returns false if the operation failed.

Deletes a file. Returns true if the operation was successful.

Creates a directory. Returns true if the operation was successful.

Removes a directory. The directory must be empty. Returns true if the operation was successful.

Returns an array of file names in the directory pointed to by path. Returns false if the operation failed.

Returns true if the fs.Stats object describes a directory.

Returns true if the fs.Stats object describes a regular file.

Prints text to the script console.

console.print('Hello world\n')

Concatenates all provided text arguments with spaces and prints the result to the script console with a trailing newline.

console.log('Hello', 'world')

Clears all previously printed text from the script console.

Shows a message box with an optional caption. The calling thread will be blocked until the message box is dismissed.

alert('Hello world') // Blocks the script's thread

events.onexec(0x80000180, function()
{
    alert('Interrupt fired!') // Blocks the emulation thread
})

Prints text to the screen at the provided x and y coordinates. Should be called from an events.ondraw callback. (Unstable!)

events.ondraw(function()
{
    screen.print(20, 20, 'power: ' + mem.u8[0x8033B21E])
})

Variables representing the lower 32 bits of each general purpose register.

events.onexec(0x802CB1C0, function()
{
    if(gpr.a0 == 2)
    {
        gpr.a0 = 3
    }
})

Variable representing the CPU's program counter.

Variable representing the lower 32 bits of the HI register.

Variable representing the lower 32 bits of the LO register.

Variables representing the upper 32 bits of each general purpose register.

Variable representing the upper 32 bits of the HI register.

Variable representing the upper 32 bits of the LO register.

Variables representing the 32-bit floating point registers.

events.onexec(0x802CB1C0, function()
{
    if(gpr.f0 == 2.0)
    {
        gpr.f0 = 3.0
    }
})

Variables representing the 64-bit floating point registers.

Variable representing the Cause register. Updates interrupts when written.

Creates a new server socket. If port is provided in settings, the server will start listening immediately.

var server = new Server({port: 80})

Binds the server socket to a port and starts listening.

Starts accepting clients. When a client is accepted, a Socket object for it is created and passed to callback.

server.on('connection', function(socket)
{
    socket.on('data', function(data)
    {
        socket.write('hello')
    })
})

Creates a new socket object.

Connects the socket to the host and port specified by the settings object. The default values for the host and port are "127.0.0.1" and 80 respectively.

Writes data to the socket.

Closes the socket.

Starts reading data from the socket asynchronously. When data arrives, it is passed to callback as a Buffer object.

Creates an immutable object with start and end address properties.
The following AddressRange objects are defined globally:

ADDR_ANY              0x00000000 : 0xFFFFFFFF Any 32-bit address

ADDR_ANY_KUSEG        0x00000000 : 0x7FFFFFFF MIPS user mode TLB mapped segment
ADDR_ANY_KSEG0        0x80000000 : 0x9FFFFFFF MIPS cached unmapped segment
ADDR_ANY_KSEG1        0xA0000000 : 0xBFFFFFFF MIPS uncached unmapped segment
ADDR_ANY_KSEG2        0xC0000000 : 0xFFFFFFFF MIPS kernel mode TLB mapped segment

ADDR_ANY_RDRAM        0x80000000 : 0x807FFFFF Cached RDRAM
ADDR_ANY_RDRAM_UNC    0xA0000000 : 0xA07FFFFF Uncached RDRAM

ADDR_ANY_CART_ROM     0x90000000 : 0x95FFFFFF Cached cartridge ROM
ADDR_ANY_CART_ROM_UNC 0xB0000000 : 0xB5FFFFFF Uncached cartridge ROM

Returns a hexadecimal string representation of the number object. The resulting string is prepended with zeroes until its character length meets nChars or 8 by default.

var sm64EntryPC = rom.u32[0x00000008]
console.log('Entry: ' + sm64EntryPC.hex()) // "Entry: 80246000"