Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/nkottary/vm
Bytecode interpreter for a stack machine
https://github.com/nkottary/vm
Last synced: about 2 months ago
JSON representation
Bytecode interpreter for a stack machine
- Host: GitHub
- URL: https://github.com/nkottary/vm
- Owner: nkottary
- Created: 2014-12-07T11:22:50.000Z (about 10 years ago)
- Default Branch: master
- Last Pushed: 2015-04-04T17:16:49.000Z (almost 10 years ago)
- Last Synced: 2024-10-19T05:48:17.311Z (3 months ago)
- Language: C
- Homepage:
- Size: 203 KB
- Stars: 3
- Watchers: 3
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
- AwesomeInterpreter - vm
README
# Assembly Language for a stack machine
## Resources
1. Stack of size 1000 elements each 4 bytes.
2. A boolean bit.
3. A program counter.
## Example hello world program
```
# Hello world program
__CODE__ # start code segment
# PUSH the string Hello World! in reverse order.
# 0 indicates end of string.
PUSH &end # the return address.
PUSH 0
PUSH 10 # new line.
PUSH '!'
PUSH 'D'
PUSH 'L'
PUSH 'R'
PUSH 'O'
PUSH 'W'
PUSH 32 # space
PUSH 'O'
PUSH 'L'
PUSH 'L'
PUSH 'E'
PUSH 'H'
PUSH Ah # new line. (in hexadecimal).
PUSH &print # call print function.
GOTO
:end
END
########## PRINT SUBROUTINE ###########
:print
PUSH 0
EQU
POP # pop the 0.
PUSH &ret # If top of stack is zero stop printing.
GOIF
WRTC # print the character.
PUSH &print # loop.
GOTO
:ret
POP # POP the 0.
GOTO # TOS is return address, so go to it.
:end
```
## Instructions without args
```
REAH - read a hexadecimal byte from stdin
to top of stack
READ - read a decimal to top of stack.
REAC - read a character to top of stack.
WRTH - write a hexadecimal byte to stdout.
WRTD - write a decimal to stdout.
WRTC - write a character to stdout.
ADD - add top 2 elems of stack and put sum
in stack
SUB - subtract topmost element by 2nd
topmost element from stack and put
difference in top of stack
MUL - multiply top 2 elems os stack and
put product in top of stack
DIV - Divide topmost elem by 2nd topmost
elem and put quotient in top of
stack and remainder below top.
POP - pop topmost elem from stack
EQU - if top 2 elems are equal boolean
flag set to 1 else 0
GRT - is top is greater than second top
boolean flag set to 1 else 0
LST - is top is smaller than second top
boolean flag set to 1 else 0
GOTO - go to instruction number given by
top of stack.
GOIF - like GOTO but only if boolean flag
set.
GOUN - like GOTO but only if boolean flag
not set.
END - end execution.
DUP - Duplicate the topmost element on
the stack.
FLIP - Flip the top two elements on the
stack.
GET - Push the element at data segment
address given by the top of stack.
PUT - Put the second in top of stack to
the location given by top of stack.
NOP - No operation.
```
## Instructions with arguments
```
PUSH - push a byte to top of stack. Byte may
be entered as a decimal or a hexadecimal
with a suffix 'h'.
```
## Bytecodes used for compiler hints
```
LAB - Defines a label at this point.
IND - Indirection, defines that next 4 bytes
is an address.
```
In a second pass of compilation LAB is replaced by NOP
and IND is compiled to PUSH .
## Labels
A label can be defined with the ':' character, and can be
jumped to with GOTO, GOIF or GOUN instructions, for example-
```
....code....
:start \# Definition of a label.
....code....
GOTO &start \# Jump to label
```
To push data from data segment to stack, first push the
address to the stack then use GET, for example-
```
:my_data 123
__CODE__
PUSH &my_data
GET
```
Similarly, PUT can be used to write data from the stack
to the data segment.
## comments
Use the \# character for comments.
## How to run the example programs
First compile file to byte code.
```
./compiler hw.vm
```
Then run the compiled .vmc file in the vm.
```
./vm hw.vmc
```
To decompile the code to a .vm file use decompiler.
```
./decompiler hw.vmc
```