The Berry Script Language.

Introduction

Berry is a ultra-lightweight dynamically typed embedded scripting language. It is designed for lower-performance embedded devices. The Berry interpreter-core's code size is less than 40KiB and can run on less than 4KiB heap (on ARM Cortex M4 CPU, Thumb ISA and ARMCC compiler).

The interpreter of Berry include a one-pass compiler and register-based VM, all the code is written in ANSI C99. In Berry not every type is a class object. Some simple value types, such as int, real, boolean and string are not class object, but list, map and range are class object. This is a consideration about performance. Register-based VM is the same meaning as above.

Berry has the following advantages:

• Lightweight: A well-optimized interpreter with very little resources. Ideal for use in microprocessors.
• Fast: optimized one-pass bytecode compiler and register-based virtual machine.
• Powerful: supports imperative programming, object-oriented programming, functional programming.
• Flexible: Berry is a dynamic type script, and it's intended for embedding in applications. It can provide good dynamic scalability for the host system.
• Simple: simple and natural syntax, support garbage collection, and easy to use FFI (foreign function interface).
• RAM saving: With compile-time object construction, most of the constant objects are stored in read-only code data segments, so the RAM usage of the interpreter is very low when it starts.

Documents

Reference Manual: Read the docs

Short Manual: berry_short_manual.pdf.

Berry's EBNF grammar definition: tools/grammar/berry.ebnf

Features

• Base Type
  • Nil: nil
  • Boolean: true and false
  • Numerical: Integer (int) and Real (real)
  • String: Single quotation-mark string and double quotation-mark string
  • Class: Instance template, read only
  • Instance: Object constructed by class
  • Module: Read-write key-value pair table
  • List: Ordered container, like [1, 2, 3]
  • Map: Hash Map container, like { 'a': 1, 2: 3, 'map': {} }
  • Range: include a lower and a upper integer value, like 0..5
• Operator and Expression
  • Assign operator: =, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
  • Relational operator: <, <=, ==, !=, >, >=
  • Logic operator: &&, ||, !
  • Arithmetic operator: +, -, *, /, %
  • Bitwise operator: &, |, ~, ^, <<, >>
  • Field operator: .
  • Subscript operator: []
  • Connect string operator: +
  • Conditional operator: ? :
  • Brackets: ()
• Control Structure
  • Conditional statement: if-else
  • Iteration statement: while and for
  • Jump statement: break and continue
• Function
  • Local variable and block scope
  • Return statement
  • Nested functions definition
  • Closure based on Upvalue
  • Anonymous function
  • Lambda expression
• Class
  • Inheritance (only public single inheritance)
  • Method and Operator Overload
  • Constructor method
  • Destructive method
• Module Management
  • Built-in module that takes almost no RAM
  • Extension module support: script module, bytecode file module and shared library (like *.so, *.dll) module
• GC (Garbage collection)
  • Mark-Sweep GC
• Exceptional Handling
  • Throw any exception value using the raise statement
  • Multiple catch mode
• Bytecode file support
  • Export function to bytecode file
  • Load the bytecode file and execute

Build and Run

1. Install the readline library (Windows does not need):

   sudo apt install libreadline-dev # Ubuntu
   brew install readline            # MacOS

2. Build (The default compiler is GCC):

   make
   

3. Run:

   ./berry # Bash or PowerShell
   berry   # Windows CMD

4. Install (Only Unix-like):

   make install

Editor plugins

Visual Studio Code plugin are in this directory: ./tools/plugins/vscode.

Examples

After compiling successfully, use the berry command with no parameters to enter the REPL environment:

Berry 0.0.1 (build in Dec 24 2018, 18:12:49)
[GCC 8.2.0] on Linux (default)
>

Now enter this code:

print("Hello world!")

You will see this output:

Hello world!

You can copy this code to the REPL:

def fib(x)
    if x <= 1
        return x
    end
    return fib(x - 1) + fib(x - 2)
end
fib(10)

This example code will output the result 55 and you can save the above code to a plain text file (eg test.be) and run this command:

./berry test.be

This will also get the correct output.

License

Berry is free software distributed under the MIT license.

The Berry interpreter partly referred to Lua's design. View Lua's license here: http://www.lua.org/license.html.