Hone logo
Hone
Problems

Simple Bytecode Interpreter in JavaScript

This challenge asks you to build a basic interpreter that executes a custom bytecode language. Bytecode interpreters are fundamental to many programming languages (like Java and Python) and provide a good understanding of how code execution works at a lower level. This exercise will help you solidify your understanding of stacks, instruction sets, and the overall interpreter design.

Problem Description

You are tasked with creating a JavaScript interpreter for a simplified bytecode language. The bytecode consists of a sequence of instructions, each represented by a number. Your interpreter should take a bytecode array as input and execute it, maintaining a stack to store intermediate values.

Instructions:

  • 1: PUSH <value> - Pushes the given value onto the stack. value will be the next element in the bytecode array.
  • 2: ADD - Pops the top two values from the stack, adds them, and pushes the result back onto the stack.
  • 3: SUB - Pops the top two values from the stack, subtracts the second from the first, and pushes the result back onto the stack.
  • 4: MUL - Pops the top two values from the stack, multiplies them, and pushes the result back onto the stack.
  • 5: DIV - Pops the top two values from the stack, divides the first by the second, and pushes the result back onto the stack.
  • 0: HALT - Stops the execution of the interpreter.

Key Requirements:

  • The interpreter should handle valid bytecode sequences.
  • The interpreter should throw an error if the bytecode is invalid (e.g., attempting an operation on an empty stack, encountering an invalid instruction, or missing a value after a PUSH instruction).
  • The interpreter should correctly execute the instructions and leave the final result on the stack.

Expected Behavior:

The interpreter should process the bytecode array sequentially. When the HALT instruction is encountered, the interpreter should terminate. The final value remaining on the stack is the result of the bytecode program.

Edge Cases to Consider:

  • Empty bytecode array.
  • Invalid instruction codes.
  • PUSH instruction without a subsequent value.
  • Arithmetic operations on an empty stack or with insufficient values.
  • Division by zero.

Examples

Example 1:

Input: [1, 2, 1, 3, 2]
Output: 5
Explanation:
1: PUSH 2 (Stack: [2])
2: PUSH 1 (Stack: [2, 1])
3: ADD (Stack: [3])
4: PUSH 3 (Stack: [3, 3])
5: MUL (Stack: [9])
6: HALT (Result: 9)

Example 2:

Input: [1, 5, 1, 2, 4]
Output: 15
Explanation:
1: PUSH 5 (Stack: [5])
2: PUSH 1 (Stack: [5, 1])
3: SUB (Stack: [4])
4: PUSH 2 (Stack: [4, 2])
5: MUL (Stack: [8])
6: PUSH 7 (Stack: [8, 7])
7: ADD (Stack: [15])
8: HALT (Result: 15)

Example 3: (Division by Zero)

Input: [1, 10, 1, 0, 5]
Output: Error: Division by zero
Explanation:
1: PUSH 10 (Stack: [10])
2: PUSH 1 (Stack: [10, 1])
3: DIV (Stack: [10/1 = 10])
4: PUSH 0 (Stack: [10, 0])
5: DIV (Attempt to divide 10 by 0 - throws error)

Constraints

  • The bytecode array will contain only integers.
  • The values pushed by the PUSH instruction will be integers.
  • The bytecode array will not exceed a length of 1000.
  • The interpreter should handle division by zero gracefully by throwing an error.
  • The interpreter should be reasonably efficient (avoid unnecessary loops or complex data structures where simpler alternatives exist).

Notes

  • Consider using a stack data structure (an array can be used as a stack in JavaScript) to manage the values.
  • Think about how to handle errors gracefully and provide informative error messages.
  • Start with a small, simple bytecode program and gradually increase the complexity as you test your interpreter.
  • The order of operations is determined by the bytecode sequence.
  • Focus on clarity and readability in your code. Good commenting is encouraged.
Loading editor...
javascript