Diffusion Ant (type-hints-typescript) Code

ant/tests/stack.js
899dad6b8a9etype-hints-typescript

stack.js
View Options

			const STACK_SIZE = 256;
			const PROGRAM_SIZE = 1024;

			const Opcode = {
			OP_PUSH: 0,
			OP_POP: 1,
			OP_ADD: 2,
			OP_SUB: 3,
			OP_MUL: 4,
			OP_DIV: 5,
			OP_PRINT: 6,
			OP_JMP: 7,
			OP_JZ: 8,
			OP_LT: 9,
			OP_EQ: 10,
			OP_NEG: 11,
			OP_HALT: 12
			};

			const opcodeNames = {
			[Opcode.OP_PUSH]: 'OP_PUSH',
			[Opcode.OP_POP]: 'OP_POP',
			[Opcode.OP_ADD]: 'OP_ADD',
			[Opcode.OP_SUB]: 'OP_SUB',
			[Opcode.OP_MUL]: 'OP_MUL',
			[Opcode.OP_DIV]: 'OP_DIV',
			[Opcode.OP_PRINT]: 'OP_PRINT',
			[Opcode.OP_JMP]: 'OP_JMP',
			[Opcode.OP_JZ]: 'OP_JZ',
			[Opcode.OP_LT]: 'OP_LT',
			[Opcode.OP_EQ]: 'OP_EQ',
			[Opcode.OP_NEG]: 'OP_NEG',
			[Opcode.OP_HALT]: 'OP_HALT'
			};

			// Debug settings
			const DEBUG_ENABLED = true;

			class VM {
			constructor() {
			this.sp = -1;
			this.pc = 0;
			this.stack = new Array(STACK_SIZE).fill(0);
			this.program = new Uint8Array(PROGRAM_SIZE);
			}

			free() {
			this.sp = -1;
			this.pc = 0;
			}

			checkStackHasValues(count) {
			if (this.sp < count - 1) {
			throw new Error(`Stack Underflow! Need ${count} value(s), but stack has ${this.sp + 1}`);
			}
			}

			push(value) {
			if (this.sp >= STACK_SIZE - 1) {
			throw new Error('Stack Overflow!');
			}
			this.sp++;
			this.stack[this.sp] = value;
			this.tracePush(value);
			}

			pop() {
			this.checkStackHasValues(1);
			const result = this.stack[this.sp];
			this.sp--;
			this.tracePop(result);
			return result;
			}

			performBinary(op) {
			this.checkStackHasValues(2);
			const b = this.pop();
			const a = this.pop();
			let result;
			switch (op) {
			case '+':
			result = a + b;
			break;
			case '-':
			result = a - b;
			break;
			case '*':
			result = a * b;
			break;
			case '/':
			result = Math.trunc(a / b);
			break;
			}
			this.push(result);
			}

			performUnary(op) {
			this.checkStackHasValues(1);
			const a = this.pop();
			let result;
			switch (op) {
			case '-':
			result = -a;
			break;
			}
			this.push(result);
			}

			execute() {
			this.traceHeader();

			while (true) {
			const op = this.program[this.pc];
			this.traceInstruction(this.pc, op);
			this.pc++;

			switch (op) {
			case Opcode.OP_PUSH: {
			const val = this.readInt64();
			this.push(val);
			break;
			}
			case Opcode.OP_POP:
			this.pop();
			break;
			case Opcode.OP_HALT:
			this.traceHalt();
			return;
			case Opcode.OP_PRINT:
			this.checkStackHasValues(1);
			console.log(this.stack[this.sp]);
			break;
			case Opcode.OP_ADD:
			this.performBinary('+');
			break;
			case Opcode.OP_SUB:
			this.performBinary('-');
			break;
			case Opcode.OP_MUL:
			this.performBinary('*');
			break;
			case Opcode.OP_DIV:
			this.performBinary('/');
			break;
			case Opcode.OP_NEG:
			this.performUnary('-');
			break;
			default:
			throw new Error('Unknown Opcode!');
			}

			this.printStack();
			this.traceSeparator();
			}
			}

			readInt64() {
			// Read 8 bytes as little-endian 64-bit integer
			// JS doesn't handle 64-bit ints natively, but for small values this works
			let val = 0;
			for (let i = 0; i < 8; i++) {
			val \|= this.program[this.pc + i] << (i * 8);
			}
			this.pc += 8;
			return val;
			}

			// Debug/trace methods
			traceHeader() {
			if (!DEBUG_ENABLED) return;
			console.log('\n\x1b[96m\x1b[1m=== VM Execution Trace ===\x1b[0m\n');
			}

			traceInstruction(pc, opcode) {
			if (!DEBUG_ENABLED) return;
			const name = opcodeNames[opcode] \|\| 'UNKNOWN';
			console.log(`\x1b[94m[PC=${pc}]\x1b[0m \x1b[32m\x1b[1m${name}\x1b[0m`);
			}

			tracePush(value) {
			if (!DEBUG_ENABLED) return;
			console.log(`\x1b[2m \x1b[35mPUSH\x1b[0m \x1b[93m${value}\x1b[0m`);
			}

			tracePop(value) {
			if (!DEBUG_ENABLED) return;
			console.log(`\x1b[2m \x1b[31mPOP \x1b[0m \x1b[93m${value}\x1b[0m`);
			}

			traceHalt() {
			if (!DEBUG_ENABLED) return;
			console.log('\n\x1b[91m\x1b[1m=== Execution Halted ===\x1b[0m');
			}

			traceSeparator() {
			if (!DEBUG_ENABLED) return;
			console.log();
			}

			printStack() {
			if (!DEBUG_ENABLED) return;
			let stackStr = this.stack.slice(0, this.sp + 1).join(' ');
			console.log(`\x1b[2m Stack \x1b[36m[sp=${this.sp}]\x1b[0m: [ \x1b[33m${stackStr}\x1b[0m ]`);
			}
			}

			// Helper to write int64 to program
			function writeInt(program, pc, val) {
			for (let i = 0; i < 8; i++) {
			program[pc.value] = (val >> (i * 8)) & 0xff;
			pc.value++;
			}
			}

			// Main
			function main() {
			const v = new VM();
			const values = [10, 13, 6, 25, 42];
			const pc = { value: 0 };

			for (const val of values) {
			v.program[pc.value++] = Opcode.OP_PUSH;
			writeInt(v.program, pc, val);
			}

			v.program[pc.value++] = Opcode.OP_MUL;
			v.program[pc.value++] = Opcode.OP_ADD;
			v.program[pc.value++] = Opcode.OP_NEG;
			v.program[pc.value++] = Opcode.OP_DIV;
			v.program[pc.value++] = Opcode.OP_SUB;
			v.program[pc.value++] = Opcode.OP_PRINT;
			v.program[pc.value++] = Opcode.OP_HALT;

			v.execute();
			v.free();
			}

			main();

Owner Packages

No Owners