= 2147483648.0) { $v -= 4294967296.0; } elseif ($v < -2147483648.0) { $v += 4294967296.0; } return (int) $v; } /** u32 value as a non-negative number (int on 64-bit, float above 2^31 on 32-bit). For display / compares only. */ function u32v(int $v): int|float { return $v < 0 ? $v + 4294967296 : $v; } function mul32(int $a, int $b): int { if (PHP_INT_SIZE === 8) { // exact in 64 bits when both fit 32 bits return s32(s32($a) * s32($b)); } $r = $a * $b; if (is_int($r)) { return $r; } // split multiply: (ah*2^16 + al) * b, keeping the low 32 bits $al = $a & 0xffff; $ah = ($a >> 16) & 0xffff; $lo = $al * ($b & 0xffff); $mid = s32($ah * ($b & 0xffff)) + s32($al * (($b >> 16) & 0xffff)); return s32((float) $lo + (float) (s32($mid) & 0xffff) * 65536.0); } function shl32(int $a, int $n): int { $n &= 31; if (PHP_INT_SIZE === 8) { return s32($a << $n); } return $a << $n; // 32-bit PHP shifts within the machine word } /** Logical shift right of a 32-bit value. */ function shr32(int $a, int $n): int { $n &= 31; if ($n === 0) { return s32($a); } if (PHP_INT_SIZE === 8) { return ($a & 0xffffffff) >> $n; } return ($a >> $n) & ~(-1 << (32 - $n)); } /** Unsigned 32-bit a < b. */ function ult(int $a, int $b): bool { if (PHP_INT_SIZE === 8) { return ($a & 0xffffffff) < ($b & 0xffffffff); } return ($a ^ PHP_INT_MIN) < ($b ^ PHP_INT_MIN); } function ule(int $a, int $b): bool { return $a === $b || ult($a, $b); } function udiv32(int $a, int $b): int { if ($b === 0) { return 0; } if (PHP_INT_SIZE === 8) { return s32(intdiv($a & 0xffffffff, $b & 0xffffffff)); } return s32(floor(u32v($a) / u32v($b))); } function umod32(int $a, int $b): int { if ($b === 0) { return 0; } if (PHP_INT_SIZE === 8) { return s32(($a & 0xffffffff) % ($b & 0xffffffff)); } return s32(fmod(u32v($a), u32v($b))); } /** C integer division (truncation toward zero), 0 when dividing by zero (the C would trap). */ function cdiv(int $a, int $b): int { if ($b === 0) { return 0; } if ($a === PHP_INT_MIN && $b === -1) { return $a; } return intdiv($a, $b); } function cmod(int $a, int $b): int { return $b === 0 ? 0 : $a % $b; } // --------------------------------------------------------------------------------------------- // Unified memory // --------------------------------------------------------------------------------------------- /** * Allocates a zeroed host block past the VM RAM; returns its offset in Alis::$mem. The memory string grows by * steps of at least 1 MB (each growth reallocates megabytes: rare is better, the browser never gives them back). */ function host_alloc(int $size): int { $len = strlen(Alis::$mem); if (Alis::$host_top === 0 || Alis::$host_top > $len) { Alis::$host_top = $len; // a new memory (alis_init): blocks start after it } $off = (Alis::$host_top + 15) & ~15; // 16-byte alignment, like malloc if ($off + $size > $len) { Alis::$mem .= str_repeat("\0", \max($off + $size - $len, 1 << 20)); } elseif ($size > 0) { mem_set($off, 0, $size); // a reused area: zeroed like calloc } Alis::$host_top = $off + $size; return $off; } function host_free(int $ptr): void { } function xread8(int $o): int { return ord(Alis::$mem[$o]); } function xread16(int $o): int { $m = Alis::$mem; if (Alis::$xle) { $v = ord($m[$o]) | (ord($m[$o + 1]) << 8); } else { $v = (ord($m[$o]) << 8) | ord($m[$o + 1]); } return ($v ^ 0x8000) - 0x8000; } function xread32(int $o): int { $m = Alis::$mem; if (Alis::$xle) { $v = ord($m[$o]) | (ord($m[$o + 1]) << 8) | (ord($m[$o + 2]) << 16) | (ord($m[$o + 3]) << 24); } else { $v = (ord($m[$o]) << 24) | (ord($m[$o + 1]) << 16) | (ord($m[$o + 2]) << 8) | ord($m[$o + 3]); } return PHP_INT_SIZE === 8 ? (($v ^ 0x80000000) - 0x80000000) : $v; } function xwrite8(int $o, int $v): void { Alis::$mem[$o] = chr($v & 0xff); } function xwrite16(int $o, int $v): void { if (Alis::$xle) { Alis::$mem[$o] = chr($v & 0xff); Alis::$mem[$o + 1] = chr(($v >> 8) & 0xff); } else { Alis::$mem[$o] = chr(($v >> 8) & 0xff); Alis::$mem[$o + 1] = chr($v & 0xff); } } function xwrite32(int $o, int $v): void { if (Alis::$xle) { Alis::$mem[$o] = chr($v & 0xff); Alis::$mem[$o + 1] = chr(($v >> 8) & 0xff); Alis::$mem[$o + 2] = chr(($v >> 16) & 0xff); Alis::$mem[$o + 3] = chr(($v >> 24) & 0xff); } else { Alis::$mem[$o] = chr(($v >> 24) & 0xff); Alis::$mem[$o + 1] = chr(($v >> 16) & 0xff); Alis::$mem[$o + 2] = chr(($v >> 8) & 0xff); Alis::$mem[$o + 3] = chr($v & 0xff); } } function xadd8(int $o, int $v): void { xwrite8($o, xread8($o) + $v); } function xadd16(int $o, int $v): void { xwrite16($o, xread16($o) + $v); } function xadd32(int $o, int $v): void { xwrite32($o, s32(xread32($o) + $v)); } function xsub8(int $o, int $v): void { xwrite8($o, xread8($o) - $v); } function xsub16(int $o, int $v): void { xwrite16($o, xread16($o) - $v); } function xsub32(int $o, int $v): void { xwrite32($o, s32(xread32($o) - $v)); } // HOST byte order (little endian): C dereferences of typed pointers into memory, e.g. *(s16 *)p, *alis.acc function hread8(int $o): int { return ord(Alis::$mem[$o]); } function hread16(int $o): int { return ((ord(Alis::$mem[$o]) | (ord(Alis::$mem[$o + 1]) << 8)) ^ 0x8000) - 0x8000; } function hread32(int $o): int { return read32le($o); } function hwrite8(int $o, int $v): void { Alis::$mem[$o] = chr($v & 0xff); } function hwrite16(int $o, int $v): void { Alis::$mem[$o] = chr($v & 0xff); Alis::$mem[$o + 1] = chr(($v >> 8) & 0xff); } function hwrite32(int $o, int $v): void { Alis::$mem[$o] = chr($v & 0xff); Alis::$mem[$o + 1] = chr(($v >> 8) & 0xff); Alis::$mem[$o + 2] = chr(($v >> 16) & 0xff); Alis::$mem[$o + 3] = chr(($v >> 24) & 0xff); } function read16be(int $o): int { return (ord(Alis::$mem[$o]) << 8) | ord(Alis::$mem[$o + 1]); } function read16le(int $o): int { return ord(Alis::$mem[$o]) | (ord(Alis::$mem[$o + 1]) << 8); } function read32be(int $o): int { $m = Alis::$mem; return s32((ord($m[$o]) << 24) | (ord($m[$o + 1]) << 16) | (ord($m[$o + 2]) << 8) | ord($m[$o + 3])); } function read32le(int $o): int { $m = Alis::$mem; return s32(ord($m[$o]) | (ord($m[$o + 1]) << 8) | (ord($m[$o + 2]) << 16) | (ord($m[$o + 3]) << 24)); } function read24be(int $o): int { $v = (ord(Alis::$mem[$o]) << 16) | (ord(Alis::$mem[$o + 1]) << 8) | ord(Alis::$mem[$o + 2]); return $v > 0x7fffff ? 0 : $v; // C _read_be_24 } function read24le(int $o): int { $v = ord(Alis::$mem[$o]) | (ord(Alis::$mem[$o + 1]) << 8) | (ord(Alis::$mem[$o + 2]) << 16); return $v > 0x7fffff ? 0 : $v; // C _read_le24 } /** Game-endian unsigned 16-bit read (C read16 function pointer). */ function read16(int $o): int { return Alis::$xle ? read16le($o) : read16be($o); } function read24(int $o): int { return Alis::$xle ? read24le($o) : read24be($o); } function read32(int $o): int { return Alis::$xle ? read32le($o) : read32be($o); } /** C write32(ptr, value): game endianness. */ function write32(int $o, int $v): void { xwrite32($o, $v); } /** C swap16(ptr): reads a u16 in the game byte order. */ function swap16(int $o): int { return read16($o); // C: host read + _convert16 = game byte order } function swap32(int $o): int { return read32($o); } function bswap16(int $v): int { return (($v & 0xff) << 8) | (($v >> 8) & 0xff); } function bswap32(int $v): int { return s32((($v & 0xff) << 24) | ((($v >> 8) & 0xff) << 16) | ((($v >> 16) & 0xff) << 8) | (($v >> 24) & 0xff)); } /** Values in game endianness <-> host value (the PHP host is "little endian"). */ function xswap16(int $v): int { return s16(Alis::$xle ? $v : bswap16($v & 0xffff)); } function xswap32(int $v): int { return Alis::$xle ? s32($v) : bswap32($v); } function xswap16be(int $v): int { return s16(bswap16($v & 0xffff)); } function xswap32be(int $v): int { return bswap32($v); } function xread16be(int $o): int { return s16(read16be($o)); } function xread32be(int $o): int { return read32be($o); } /** * PHP has no in-place memcpy on a string: substr_replace() rebuilds the whole memory (megabytes, and in the * browser such huge blocks are mmap()ed and never given back: "Out of memory" after a few hundred copies). So * bytes are written in place: the target is compared with the new bytes block by block (string compares run * in C) and only the blocks that differ are written, byte by byte. On the desktop (64-bit PHP), a write bigger * than 1/MEM_LOOP_RATIO of the memory still uses one substr_replace (faster there, no leak). */ const MEM_LOOP_RATIO = 300; const MEM_BLOCK = 256; /** Writes raw bytes at $dst (memcpy from a PHP string), in place. */ function mem_write(int $dst, string $bytes): void { $n = strlen($bytes); if ($n === 0) { return; } $m = &Alis::$mem; if ($n < 64) { for ($i = 0; $i < $n; $i++) { $m[$dst + $i] = $bytes[$i]; } return; } if (PHP_INT_SIZE === 8 && $n * MEM_LOOP_RATIO >= strlen($m)) { $m = substr_replace($m, $bytes, $dst, $n); return; } $old = substr($m, $dst, $n); if ($old === $bytes) { return; } for ($b = 0; $b < $n; $b += MEM_BLOCK) { $len = $n - $b < MEM_BLOCK ? $n - $b : MEM_BLOCK; if (substr_compare($old, $bytes, $b, $len) === 0) { continue; } for ($i = $b, $end = $b + $len, $d = $dst; $i < $end; $i++) { if ($old[$i] !== $bytes[$i]) { $m[$d + $i] = $bytes[$i]; } } } } function mem_move(int $dst, int $src, int $n): void { if ($n > 0) { mem_write($dst, substr(Alis::$mem, $src, $n)); } } function mem_set(int $dst, int $v, int $n): void { if ($n > 0) { mem_write($dst, str_repeat(chr($v & 0xff), $n)); } } function mem_read(int $src, int $n): string { return $n > 0 ? substr(Alis::$mem, $src, $n) : ''; } function mem_cmp(int $a, int $b, int $n): int { return strcmp(substr(Alis::$mem, $a, $n), substr(Alis::$mem, $b, $n)) <=> 0; } function mem_strlen(int $p): int { $end = strpos(Alis::$mem, "\0", $p); return $end === false ? strlen(Alis::$mem) - $p : $end - $p; } function mem_str(int $p): string { return substr(Alis::$mem, $p, mem_strlen($p)); } function mem_putstr(int $p, string $s): void { mem_write($p, $s . "\0"); } function mem_strcpy(int $dst, int $src): void { mem_putstr($dst, mem_str($src)); } // --------------------------------------------------------------------------------------------- // Script byte code // --------------------------------------------------------------------------------------------- function script_read8(): int { return ord(Alis::$mem[Alis::$script->pc++]); } function script_read16(): int { $s = Alis::$script; $v = read16($s->pc); $s->pc += 2; return $v; } function script_read24(): int { $s = Alis::$script; $v = read24($s->pc); $s->pc += 3; return $v; } function script_read32(): int { $s = Alis::$script; $v = read32($s->pc); $s->pc += 4; return $v; } function get_vram(int $offset): int { return Alis::$script->vram_org + $offset; } // --------------------------------------------------------------------------------------------- // Sprites (C: SPRITE_VAR, sprite memory of SPRITE_SZ-byte records) // --------------------------------------------------------------------------------------------- function sprite_var(int $x): ?Sprite { if ($x === 0) { return null; } $key = Img::$basesprite + ($x & 0xffff); return Img::$sprites[$key] ??= new Sprite($key); } // --------------------------------------------------------------------------------------------- // Misc // --------------------------------------------------------------------------------------------- final class UnsupportedFeature extends \RuntimeException { } /** A C path that was not ported (v6, 3D, video...): stops the VM with a message. */ function unsupported(string $what): void { throw new UnsupportedFeature("ALIS: '$what' is not supported by this port"); } /** Thrown to end the current frame; the VM resumes where it stopped at the next frame. */ final class VmYield extends \Exception { } /** For opcodes that must wait (text input): restart the current opcode at the next frame. */ function vm_yield_retry(): void { Alis::$script->pc = Alis::$opcode_pc; throw new VmYield(); } function BIT_CHK(int $v, int $b): int { return ($v >> $b) & 1; }