Tokay

Tokay is a programming language designed for ad-hoc parsing.

[!IMPORTANT] Tokay is under development and not considered for production use yet. Be part of Tokay's ongoing development, and contribute!

About

Tokay is intended to become a programming language that can be used to quickly implement solutions for text processing problems. This can involve either simple data extractions, but also the parsing of syntactical structures or parts thereof and the conversion of information into structured parse trees or abstract syntax trees for further processing.

Therefore, Tokay is becoming not only a practical tool for simple one-liners like matchers or recognizers, but also a language that can be used to implement code analyzers, refactoring tools, interpreters, compilers or transpilers. Actually Tokay's own language parser is implemented in Tokay itself.

Tokay is inspired by awk, has syntactic and semantic flavours from Python and Rust, but also follows its own philosophy, ideas and design principles. Thus, Tokay isn't directly compareable to other languages or projects, and stands on its own. It's an entirely new programming language.

Tokay is still a very young project and gains much potential. Volunteers are welcome!

Highlights

Interpreted, procedural and imperative scripting language
Concise and easy to learn syntax and object system
Stream-based input processing
Automatic parse tree construction and synthesis
Left-recursive parsing structures ("parselets") supported
Implements a memoizing packrat parsing algorithm internally
Robust and fast, as it is written entirely in safe Rust
Enabling awk-style one-liners in combination with other tools
Generic parselets and functions
Import system to create modularized programs (*coming soon)
Embedded interoperability with other programs (*coming soon)

Installation

By using Rusts dependency manager and build-tool cargo, simply install Tokay with

$ cargo install tokay

For Arch Linux-based distros, there is also a tokay and tokay-git package in the Arch Linux AUR.

Examples

Tokay's version of "Hello World" is quite obvious.

print("Hello World")

$ tokay 'print("Hello World")'
Hello World

Tokay can also greet any wor(l)ds that are being fed to it. The next program prints "Hello Venus", "Hello Earth" or "Hello" followed by any other name previously parsed by the builtin Word-token. Any other input than a word is automatically omitted.

print("Hello", Word)

$ tokay 'print("Hello", Word)' -- "World 1337 Venus Mars 42 Max"
Hello World
Hello Venus
Hello Mars
Hello Max

A simple program for counting words and numbers and printing a total afterwards can be implemented like this:

Word words += 1
Number numbers += 1
end print(words || 0, "words,", numbers || 0, "numbers")

$ tokay 'Word words += 1; Number numbers += 1; end print(words || 0, "words,", numbers || 0, "numbers")' -- "this is just the 1st stage of 42.5 or .1 others"
9 words, 3 numbers

By design, Tokay constructs syntax trees from consumed information automatically.

The next program implements a parser and interpreter for simple mathematical expressions, like 1 + 2 + 3 or 7 * (8 + 2) / 5. The result of each expression is printed afterwards.

Processing direct and indirect left-recursions without ending in infinite loops is one of Tokay's core features.

_ : Char< \t>+            # redefine whitespace to just tab and space

Factor : @{
    Int _                 # built-in 64-bit signed integer token
    '(' _ Expr ')' _
}

Term : @{
    Term '*' _ Factor     $1 * $4
    Term '/' _ Factor     $1 / $4
    Factor
}

Expr : @{
    Expr '+' _ Term       $1 + $4
    Expr '-' _ Term       $1 - $4
    Term
}

Expr _ print("= " + $1)   # gives some neat result output

$ tokay examples/expr_from_readme.tok
1 + 2 + 3
= 6
7 * (8 + 2) / 5
= 14
7*(3-9)
= -42
...

Calculate the fibonacci numbers from parsed integers:

fibonacci : @n {
    if n <= 1 n else fibonacci(n - 1) + fibonacci(n - 2)
}

Int print($1, "=>", fibonacci($1))

$ tokay examples/fibonacci2.tok
0
0 => 0
1
1 => 1
2
2 => 1
3
3 => 2
4
4 => 3
5
5 => 5
6
6 => 8
7
7 => 13
8
8 => 21
9
9 => 34
10
10 => 55

Documentation

The Tokay homepage tokay.dev provides links to a quick start and documentation. The documentation source code is maintained in a separate repository.

Building

To build Tokay, use Rust's standard build tool cargo:

# for debugging
$ cargo run -- PARAMS... -- INPUTS...

# for debug build
$ cargo build

# for optimized release-build
$ cargo build --release

Additionally, parts of Tokay's source code are generated using a Makefile-based tooling, which is described below.

`make builtins` - update Tokay's builtin registry from the Rust sources

Generate the file src/_builtins.rs using src/_builtins.tok.

make builtins updates the content of src/_builtins.rs using src/_builtins.tok from the Rust sources.
make show-builtins dumps what would be generated by make builtins
make reset-builtins resets src/_builtins.rs from git, if something went wrong.

`make parser` - update Tokay's parser from `tokay.tok`

Tokay uses a program written in itself (src/compiler/tokay.tok) to generate its own language parser (src/compiler/parser.rs) incrementally.

make parser updates the content of src/compiler/parser.rs from src/compiler/tokay.tok.
make show-parser dumps what would be generated by make parser
make reset-parser resets src/compiler/parser.rs from git, if something went wrong.

`make prelude` - update Tokay's prelude from `prelude.tok`

Tokay needs the prelude to provide general language features and defaults.

make prelude updates the content of src/compiler/prelude.rs from src/prelude.tok.
make show-prelude dumps what would be generated by make prelude
make reset-prelude resets src/compiler/prelude.rs from git, if something went wrong.

Debugging

For debugging, there are two methods to use.

Tracing using the `log`-crate

For Rust standard trace, use the env_logger facilities. Full trace is only compiled into debug executables, the release version only provides warning level and upwards.

$ RUST_LOG=tokay=debug tokay

Alternatively, tracing can be activated for the __main__-program by setting TOKAY_LOG. This is used to start tracing when the internal parser has been compiled and executed already, and parsed the actual program. TOKAY_LOG can be set to any RUST_LOG-compliant format, as it becomes RUST_LOG right after.

$ TOKAY_LOG=debug tokay

Built-in AST and VM debugger using `TOKAY_DEBUG` and `TOKAY_PARSER_DEBUG`

Set TOKAY_DEBUG to a debug level between 1-6. This can also be achieved using tokay -dddd where every d increments the debug level. Additionally, TOKAY_INSPECT can be set to one or a list of parselet name (-prefixes) which should be inspected in VM step-by-step trace (TOKAY_DEBUG=6).

Level	Mode
0	No debug
1	Print constructed AST
2	Print final intermediate program
3	Print compiled VM program
4	Print VM execution trace
5	Print VM stack contents
6	VM opcode debugger

View the parsed AST of a program in debug-level 1:

$ cargo run -q -- -d 'x = 42 print("Hello World " + x)'
main [start 1:1, end 1:33]
 sequence [start 1:1, end 1:33]
  assign_drop [start 1:1, end 1:8]
   lvalue [start 1:1, end 1:3]
    identifier [start 1:1, end 1:2] => "x"
   value_integer [start 1:5, end 1:7] => 42
  call [start 1:8, end 1:33]
   identifier [start 1:8, end 1:13] => "print"
   callarg [start 1:14, end 1:32]
    op_binary_add [start 1:14, end 1:32]
     value_string [start 1:14, end 1:28] => "Hello World "
     identifier [start 1:31, end 1:32] => "x"

TOKAY_PARSER_DEBUG sets the specific debug level for the parser, which is implemented in Tokay itself and is part of the compiler. Only levels > 2 can be recognized here, as the AST of the parser is built into the code.

Here's the VM debugger in action running the simple "Hello World"-program:

`$ TOKAY_INSPECT="__main__" cargo run -q -- 'print("Hello World")'`
__main__      --- Code ---
__main__       000 Offset(Offset { offset: 6, row: 1, col: 7 })
__main__      >001 LoadStatic(1)
__main__       002 Offset(Offset { offset: 0, row: 1, col: 1 })
__main__       003 CallStaticArg((2, 1))
__main__      --- Reader ---
__main__       offset=Offset { offset: 0, row: 1, col: 1 }
__main__       eof=false
__main__      --- Globals ---
__main__      --- Stack ---
__main__      --- Frames ---
__main__       000 capture: 0, reader: 0, fuse: None

__main__      ip = 1 state = Ok(Push([59d29e639f88] "Hello World" (10)))
__main__      --- Code ---
__main__       000 Offset(Offset { offset: 6, row: 1, col: 7 })
__main__       001 LoadStatic(1)
__main__       002 Offset(Offset { offset: 0, row: 1, col: 1 })
__main__      >003 CallStaticArg((2, 1))
__main__      --- Reader ---
__main__       offset=Offset { offset: 0, row: 1, col: 1 }
__main__       eof=false
__main__      --- Globals ---
__main__      --- Stack ---
__main__       000 [59d29e639f88] "Hello World" (10)
__main__      --- Frames ---
__main__       000 capture: 0, reader: 0, fuse: None

Hello World
__main__      ip = 3 state = Ok(Push([59d29e498fd8] void (10)))
__main__      exit state = Ok(Push([59d29e498fd8] void (10)))

Logo

The Tokay programming language is named after the Tokay gecko (Gekko gecko) from Asia, shouting out "token" in the night.

The Tokay logo and icon was thankfully designed by Timmytiefkuehl. Check out the tokay-artwork repository for different versions of the logo as well.

License

Tokay is free software under the MIT license. Please see the LICENSE file for details.

tokay 0.6.7