legit

by blinry

blinry / legit

An esoteric programming language where programs are defined by the graph of commits in a Git reposit...

128 Stars 1 Forks Last release: Not found 30 Commits 0 Releases

Available items

No Items, yet!

The developer of this repository has not created any items for sale yet. Need a bug fixed? Help with integration? A different license? Create a request here:

Programs written in legit are defined entirely by the commits in a Git repository. The content of the repository is ignored. legit is designed so that all relevant information is visible when running

git log --graph --oneline
, see the examples below.

Influences: Folders, Befunge, Brainfuck, Elymas.

Memory

In each legit program, two data structures are available: A stack, and a brainfuck-like endless tape, with a head moving on it. Both hold signed integers.

Control flow

Execution starts at the commit pointed to by the master branch. Commit messages can contain a series of instructions, seperated with spaces, which are executed one by one. Only the first line is considered, so lines after that can be used for comments.

  • If a commit has only one parent, execution will continue there after executing all instructions in the current commit.
  • If a commit has multiple parents (numbered 0, 1, 2, ...), the top stack element will be popped. If that element is n, to go n-th parent, or to the last one, if n is outside of the available range.

Instructions

For all instructions, popping from the empty stack will return a value of 0.

Control flow:

  • []
    : jump to the specified Git tag. For example,
    [loop]
    will jump to the tag loop.
  • quit
    : stop the program.

I/O:

  • get
    : read a char from standard input and place its ASCII value on the stack. On EOF, push a 0.
  • put
    : pop top stack value and write it to standard output as a char. The value is always truncated to an unsigned byte.
  • : push the specified integer on the stack. For example, 
    42
    will push the value 42.
  • ""
    : unescape string, then push the individual ASCII characters on the stack. For example,
    "Hi\n"
    will push the numbers 72, 105, and 10.

Stack operations:

  • dup
    : duplicate top stack value
  • pop
    : pop top stack value and discard it
  • add
    : pop two topmost stack values, add them, push result on the stack
  • sub
    : pop two topmost stack values, subtract top one from bottom one, push result on the stack
  • cmp
    : pop two topmost stack values, pushes 1 if bottommost one is larger, 0 otherwise

Tape operations:

  • read
    : place value of current tape cell on the stack
  • write
    : pop top stack value and write it to the current tape cell
  • left
    : pop top stack value, move tape head left for that many places
  • right
    : pop top stack value, move tape head right for that many places

Examples

legit
comes with some examples: You can generate them like this:
make -C examples

Alternatively, you can also clone them directly from GitHub:

hello

A simple hello world program.

rot13

A ROT13 implementation.

brainfuck

A fully-functioning Brainfuck interpreter!

quine

This program outputs the Git commands required to create itself.

This doesn't actually exist yet. I challenge you to write it! :)

Implementations

This repository provides both an interpreter (better suited for development and debugging purposes) and a compiler (which produces highly efficient binaries).

For both, you'll need Ruby, and the "rugged" Gem:

gem install rugged

Running the interpreter

To execute a program, run

ruby interpreter.rb examples/hello/

Running the compiler

The compiler compiles a legit program to LLVM IR. You can then use LLVM tools to build binaries for all plaforms where you have a C standard library available (legit will be linked with

exit
,
getchar
and
putchar
).

First, run the compiler to create a .ll file:

ruby compiler.rb examples/hello/

And then, run a tool like

clang
to optimize it and produce a binary:
clang -O3 hello.ll -o hello

As an alternative to the second step, you can use the provided Makefile and simply run

make hello
.

License

The legit logo is a modification of Jason Long's original Git logo. The original as well as the modification are available under the terms of CC BY 3.0.

All other files in this repository are available under the terms of CC0.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.