Skip to content

A dynamic, interpreted, scripting language written in Java.

License

Notifications You must be signed in to change notification settings

JoaaoVerona/venusscript

Repository files navigation

This was a project made by the author while in university, in 2016, and is no longer maintained. Still, feel free to explore and fork it. :)


venusscript

Welcome to the official GitHub repository of the dynamic, injectable, scripting language VenusScript. See the examples directory to get a closer look in how the language works.

using std

ver = "2.0.0"
println("Hi from VenusScript! Version = " + ver)

def sum(int a, int b) {
    return a + b
}

newestSum = 0

async {
    for i in (1, 10) {
        newestSum = sum(i, i)
        println(newestSum)
    }
}

wait(newestSum == 20)
println("Ok!")

Version Planning

Version State Description
0.x done
  • Definitions
  • Functions
  • Function references
  • Standard library
  • Loop containers
  • Branching components
  • Variable references
  • Initial dynamic injection
  • Runtime interpretation
  • Asynchronous features
  • Synchronous features
  • Homogeneous arrays
1.x current
  • Object-oriented features (classes, attributes, methods, maybe polymorphism, etc)
  • Java interoperability
  • Lists
  • Dictionaries/Maps
  • Heterogeneous arrays
2.x planned
  • Functional features
  • Enumerations
  • Debugging utilities and breakpoints
? planned
  • Improved performance
  • Own bytecode compiler and interpreter

How to use

With Gradle:
dependencies {
	compile 'com.github.bloodshura:venusscript:2.0.0'
}
With Maven:
<dependency>
	<groupId>com.github.bloodshura</groupId>
	<artifactId>venusscript</artifactId>
	<version>2.0.0</version>
</dependency>
With other build systems:

If your build system supports fetching dependencies from the Maven central repository, then just include a dependency with group com.github.bloodshura, artifact venusscript and version 2.0.0.

Tech

VenusScript is meant to be used within any Java or JVM-built (Kotlin, Scala, Groovy, etc) application. It is required Java 8+.

Definition

  • Highly extensible
  • Dynamic typing
  • Context/scope manipulation
  • No 'null' type/value
  • Simple syntax
  • Runtime injections (of libraries, function overriding, function definition, etc)
  • Multithreaded
  • Extremely easy syntax

Already implemented

  • Asynchronous features: async scopes
  • Synchronous features: monitor locks (produce, consume), value waiting (e.g. wait(i == 5))
  • Value types
  • Function references
  • Variable references
  • Top-level functions
  • Higher-order functions
  • Dynamic include statements
  • Dynamic using statements
  • Exporting variables to global context (so multiple scripts within the same application can access them)
  • While, do-while containers
  • Break, continue statements
  • Ranged foreach container (e.g. for i in (0, n))
  • Strongly typed function definitions (e.g. def print(string name) {...)
  • Basic standard libraries (random, input, output, cryptography, dialogs, math, runtime injection)
  • Interpret source code at runtime (e.g. interpret("println(3 + 5 + 2 - 1)"))
  • Binary, decimal and hexadecimal literals
  • Execute other scripts, asynchronously or synchronously (e.g. async run("../basic.vs"))
  • Homogeneous arrays

To be implemented

  • Object-oriented programming (classes, attributes, methods, maybe polymorphism, etc)
  • Functional programming (lambdas, data immutability, etc)
  • Collections (heterogeneous arrays, lists, maps, sets)
  • Easier interoperability with Java
  • User-defined value types
  • Debugging features (including, but not limited to, breakpoints)
  • Expand standard libraries
  • Enumerations
  • Simple exception handling?
  • ... and many more...

Documentation

Work in progress.