# Stack-Based Virtual Machine in AWK

A simple stack-based virtual machine implementation in AWK, inspired by Forth. The VM provides basic stack manipulation, arithmetic operations, register access, and memory operations.

## Architecture

The VM consists of:
- A data stack (100 elements)
- Main memory (1000 cells)
- Three registers:
  - A: General purpose register
  - B: Often used as memory pointer
  - P: Program pointer, used for sequential memory operations

## Instruction Set

### Stack Operations
- `DROP` - Remove top item from stack
- `DUP` - Duplicate top stack item
- `OVER` - Copy second item to top of stack
- `SWAP` - Exchange top two stack items
- Numbers are automatically pushed onto the stack

### Arithmetic Operations
- `+` - Add top two stack items (a b -- a+b)
- `*` - Multiply top two stack items (a b -- a*b)
- `AND` - Bitwise AND of top two items
- `XOR` - Bitwise XOR of top two items
- `NOT` - Bitwise NOT of top item
- `2*` - Multiply top item by 2 (shift left)
- `2/` - Divide top item by 2 (shift right)

### Register Operations
- `A` - Push value of A register onto stack
- `A!` - Store top stack value into A register
- `B!` - Store top stack value into B register

### Memory Operations
- `@` - Fetch from memory address on stack (addr -- value)
- `!` - Store to memory address on stack (value addr --)
- `@+` - Fetch from memory at P, then increment P
- `!+` - Store to memory at P, then increment P
- `@B` - Fetch from memory address in B register
- `!B` - Store to memory address in B register
- `@P` - Fetch from memory address in P register
- `!P` - Store to memory address in P register

### Debug & Control
- `.` - NO-OP (does nothing)
- `BYE` - Exit program
- `SHOW` - Display current machine state (stack, registers, memory)

## Memory Model

- Memory is zero-based
- Each cell can hold a numeric value
- Memory is accessed either directly (using @ and !) or through registers
- P register is typically used for sequential memory operations
- B register is typically used as a memory pointer

## Example Programs

### Store and retrieve a value
```
5 DUP 0 ! # Store 5 at address 0
3 DUP 1 ! # Store 3 at address 1
0 @ 1 @ + # Load both values and add them
2 ! # Store result at address 2
```

### Using registers
```
42 A! # Store 42 in A register
A # Push A's value onto stack
100 B! # Set B to address 100
42 !B # Store 42 at address 100
@B # Read from address 100
```

## Usage

```bash
# Run a program directly
echo "5 3 + SHOW" | awk -f vm.awk

# Compile and run a program
./compiler.py program.coffee | awk -f vm.awk

# Run test suite
./vm_tests.sh
```