# Hase Paper Computer

A simple language for [paper-computing](https://wiki.xxiivv.com/site/paper_computer.html).

Although the language is designed to be executed by a human, this repo provides an interpreter where programs can be run much faster than by hand.

## Example

```
; define registers
l:[1 2 3 0]
s:1

; sum the values
1svl
l>
ln1
=s
```

## Installation

```bash
cargo install --git https://git@git.sr.ht/~jummit/hase
```

## Getting Started

### Defining Registers

The hase virtual machine is initialized with a set of registers, which have one-character long names.

They can be specified to be a set size like this:

```hase
; Register with five empty slots:
r:5
```

Registers initialy have empty slots (value 0).

Registers can also be pre-filled with values:

```hase
; Register with the values 1, 2 and 3:
r:[1 2 3]
```

Each register has a movable pointer which starts at the first slot.

```hase
; pointer on the first slot
; r:[[1] 2 3]
r:[1 2 3]

; move right instruction
r>

; pointer on the second slot
; r:[1 [2] 3]
```

### Instructions

Each line begins with a register name, followed by an instruction.

```hase
; move the pointer of register a one slot to the right
a>
```

Most operations also require a value, which can be a number or the current value of a register:

```hase
; add one
a+1
; add the value a register is pointing to
a+b
```

**Move Right (>)**

Move the pointer of a register to the right by the given amount.

When no parameter is given, the pointer is moved by one.

The cursor wraps around (the slots are arranged in a circle).

**Move Left (<)**

Same as move right, just backwards.

**Take (v)**

Move values from the second register to the first (empty the second, add it to the first).

**Add (+)**

Add the value to the register.

**Subtract (-)**

Subtract the value from the register.

Values can never be lower than zero.

**Jump (n)**

Jump to the given label when the register is not empty.

Labels are defined by adding a number to a line:

```hase
5a+b; line labeled "5"
```

```hase
a+1
an1; jump to label one
=0; was zero
1=1; was one
```

The jump instruction can be unconditional:

```hase
n10
```

**Result (=)**

Stops the program and returns the result.

This instruction can be used in two different ways:

**Returning a value:**

```hase
=1
=a
```

**Returning an entire register:**

```hase
a=
```

When the virtual machine runs out of instructions, every register is returned for inspection.