ubclaunchpad / durian Goto Github PK

🍍 A scripting language halfway between bash and python

CMake 11.38% C++ 88.25% C 0.10% Shell 0.27%

durian's Introduction

🍍 durian

Anatomy of a Durian

Dependencies

git submodule update --init --recursive

Building

If you use CLion IDE, the project should "just work" if you import it as a new project (since CMake is integrated into CLion), and you should be able to click the build/run button, which will put build artifacts into the cmake-build-debug/ directory by default.

If you are using a Unix-based system (i.e. Linux or macOS) and you would like to build from the command line, you can do so with the following set of commands in the repo's main directory:

mkdir build
cd build/
cmake ..
make

To briefly explain, this:

Creates a new directory named build/ and enters it.
Calls CMake to create the build system in the current directory (i.e. build/), telling it that the CMakeLists.txt config file is in the parent directory (i.e. ..).
Calls make (i.e. the generated build system) in the build/ directory to compile the code.

Durian Sample Code

$ durian example.dur shit
         88                        88
         88                        ""
         88
 ,adPPYb,88 88       88 8b,dPPYba, 88 ,adPPYYba, 8b,dPPYba,
a8"    `Y88 88       88 88P'   "Y8 88 ""     `Y8 88P'   `"8a
8b       88 88       88 88         88 ,adPPPPP88 88       88
"8a,   ,d88 "8a,   ,a88 88         88 88,    ,88 88       88
 `"8bbdP"Y8  `"YbbdP'Y8 88         88 `"8bbdP"Y8 88       88

@ UBC Launch Pad 2018!

thiabaud is eaten!
Delicious!
Yikes!

durian's People

Contributors

Stargazers

Watchers

Forkers

rwblickhan

durian's Issues

Implement string literal compiling

String literals still need to be compiled. In particular, we would like to have (immutable) shared string literals in the static data section of the bytecode. To do so, the compiler will store a dictionary of string literals/static data indices, and when compiling of an entire source file is finished, the string literals will be written as appropriate to the static data section. The actual string literal nodes, then, will simply determine the appropriate index, push this onto the stack, and then output the NEWSTR8 opcode.

design vm objects

tagged union of type and value

Parser

Write parser.

Bytecode int length and VM int length is differs

32 vs 64

Decided on to use 64 across the board.

Implement lexer

Implement the actual lexer, taking a string and producing a list of tokens (as defined in #13).

Implement code generator

Implement a code generator that implements the Visitor interface.

Create MVP Project

Write a small command-line game or utility in our new programming language.

EBNF

Write EBNF for Durian, in file grammar.ebnf.

Add strings to VM

Implement optimizer

Implement an optimizer that implements the Visitor interface.

Create token definition

Create a class to represent different types of tokens, storing the token type, value (if an identifier), literal (if a literal), and line number (at least).

TextMate theme

Design bytecode format

Lexer

Write lexer.

Setup build system and Travis

Set up a build system (possibly CMakeLists?) and hook it up to Travis for continuous integration.

It would also be good to have a basic main file and maybe a sample unit test (GTest?).

Design

finish design of Durian.

Implement parser

implement vm

Implement pretty printer

Implement a pretty printer that implements the Visitor interface.

Implement bytecode file loading for VM

The VM currently takes a pointer to bytecode, but doesn't include the metadata or static data described on the wiki. Now that we have at least some bytecode being written to a file, we need to write the metadata at the top of every bytecode file, load the file after writing and pass it to the VM, and change the VM to take into account the metadata.

STORE, LOAD, LSTORE, LLOAD

STORE:  top -> index
LOAD:   top -> index

LSTORE/LLOAD for functions

dependent on #57