An home-made interpreter written in Python3 and C++ and Haskell (all independent implementations) for a custom stack-based language heavily inspired from PostScript

1. Install python3 if you don't have it already
2. Clone the repo

python3 main.py examples/isprime.txt

Stacklang is a Stack based language, which mean it executes almost all operations using a global stack for the values

A basic introduction would be the way Reverse Polish Notation (or postfix notation) works.
An example of RPN is 3 2 + which add 3 and 2 in this order.

Basically 3 and 2 are pushed on the stack, and + is an operator that pop theses 2 items and push the result.

There are multiples cool operators defined below for manipulating, and adding data to the stack.

Comments work the same way as in Python, i.e using #
There are no multi lines comment for the moment.

As in any language there are variables in Stacklang, they use Dynamic Linking for the scoping system.
Defining is done by using /name, and assigning using the def operator.

Here is an example for defining a hundred :

/one_hundred 100 def # one_hundred is now 100
one_hundred 3 + # Pushed 103 to the stack

Note : There are no global variables for the moment.

Stacklang manages the functions and if and while etc. using blocks.
Blocks are simply a list of operations.

{
	3 2 + # This block is simply the commands push 3, push 2, add.
}

Warning : Blocks are not executed when they are simply put in the middle of a code, actually they are just pushed onto the stack as a "block reference" to use for other operators like def.

A function is just a variable that has been assigned a block, and when they are called they execute the block associated.

/add_3 {3 +} def
5 add_3 # The stack is now [8]

There are no booleans in Stacklang for the moment, so if there is a condition anywhere it is just testing an int with 0. i.e test = value != 0.

Conditions are done using the if operator.

The if operator works by taking 3 arguments from the stack :

• A condition
• A true block
• A false block.

If the condition is true (i.e different from 0) then the true block is executed, if not the false block is.

/value 3 def
value 3 eq # if value = 3 then value 3 eq = 1
{
	"Value is three" # This is the true block
}
{
	"Value is not three" # This is the false block
}
if
# Stack is now ["Value is three"]

There are 2 kinds of loops in Stacklang for the moment

The repeat loop gets 2 values from the stack :

• a number of repetition
• a block to repeat

5 {
	3
} repeat
# Stack is now [3, 3, 3, 3, 3]

The while loop gets 2 values from the stack :

• A condition block
• a block to execute if the condition is true

{ condition }
{ block }
while # Tests the condition and execute block if the condition is true, start over

#Example :
/i 3 def
{ i } # tests for i != 0
{
	/i 1 - def # i -= 1
	i # Puts i on the stack
}
while
# Stack is now [2, 1, 0]

## Recursion

Stacklang supports recursion

# Here is factorial using recursion :
/fact
{
	dup 1 - # "dup" duplicate the top of the stack (here, the input). Then tests for input != 1
	{
		dup 1 - fact * # Returns input * fact(input - 1)
	}
	{
		1 # Returns 1 since input = 1
	}
	if
} def

6 fact # Puts 120 on the stack

Here is an exhaustive list of all the basic operators in the standard library :

Maths operators (except "!") all work by popping 2 inputs and pushing 1 output corresponding to the result.

i is the number of input that are popped and o is the number of output pushed.
They respect the relation len(oldstack) - i + o = len(newstack)

These operators only manipulate the stack and don't add any additional data

Note : stoi is often used by doing /in input stoi def ### Debug

## Advanced function definition

Stacklang includes an arguments system for the function by cutting the stack in a specific way and returning a specific number of elements to the parent stack.

For example + takes 2 inputs and 1 output. So we could define add as

/add {2> + >1} def # Define add with 2 inputs and one output

Theses are of course optional and you need to do the enablelocalstack command to activate this feature
You can also disable it by doing disablelocalstack.
This is cool because it sandboxes the function letting it do its thing and returning only what is needed

enablelocalstack
/f {1>
	/n def #Set n to the input
	10 {
		n
	} repeat # Pushes 10 times n to the stack
	>2 # Only returns 2 of them (the 2 top ones)
} def

3 f 2 pack output # Prints pack [3, 3]