Embedded Scripting Language Designed for C++

Related tags

Scripting language c-plus-plus cpp embedded-scripting-language
Overview

Master Status: Linux Build Status Windows Build status codecov.io

Develop Status: Linux Build Status Windows Build status codecov.io

Coverity Scan Build Status

ChaiScript

http://www.chaiscript.com

(c) 2009-2012 Jonathan Turner (c) 2009-2017 Jason Turner

Release under the BSD license, see "license.txt" for details.

Introduction

Gitter

ChaiScript is one of the only embedded scripting language designed from the ground up to directly target C++ and take advantage of modern C++ development techniques, working with the developer how they would expect it to work. Being a native C++ application, it has some advantages over existing embedded scripting languages:

  1. It uses a header-only approach, which makes it easy to integrate with existing projects.
  2. It maintains type safety between your C++ application and the user scripts.
  3. It supports a variety of C++ techniques including callbacks, overloaded functions, class methods, and stl containers.

Requirements

ChaiScript requires a C++14 compiler to build with support for variadic templates. It has been tested with gcc 4.9 and clang 3.6 (with libcxx). For more information see the build dashboard.

Installation using vcpkg

You can download and install ChaiScript using the vcpkg dependency manager:

git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh
./vcpkg integrate install
vcpkg install chaiscript

The ChaiScript port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please create an issue or pull request on the vcpkg repository.

Usage

  • Add the ChaiScript include directory to your project's header search path
  • Add #include <chaiscript/chaiscript.hpp> to your source file
  • Instantiate the ChaiScript engine in your application. For example, create a new engine with the name chai like so: chaiscript::ChaiScript chai
  • The default behavior is to load the ChaiScript standard library from a loadable module. A second option is to compile the library into your code, see below for an example.

Once instantiated, the engine is ready to start running ChaiScript source. You have two main options for processing ChaiScript source: a line at a time using chai.eval(string) and a file at a time using chai.eval_file(fname)

To make functions in your C++ code visible to scripts, they must be registered with the scripting engine. To do so, call add:

chai.add(chaiscript::fun(&my_function), "my_function_name");

Once registered the function will be visible to scripts as "my_function_name"

Examples

ChaiScript is similar to ECMAScript (aka JavaScript(tm)), but with some modifications to make it easier to use. For usage examples see the "samples" directory, and for more in-depth look at the language, the unit tests in the "unittests" directory cover the most ground.

For examples of how to register parts of your C++ application, see "example.cpp" in the "samples" directory. Example.cpp is verbose and shows every possible way of working with the library. For further documentation generate the doxygen documentation in the build folder or see the website http://www.chaiscript.com.

The shortest complete example possible follows:

/// main.cpp

#include <chaiscript/chaiscript.hpp>

double function(int i, double j)
{
  return i * j;
}

int main()
{
  chaiscript::ChaiScript chai;
  chai.add(chaiscript::fun(&function), "function");

  double d = chai.eval<double>("function(3, 4.75);");
}
Comments
  • Script files with UTF-8 BOM aren't executed

    Script files with UTF-8 BOM aren't executed

    While ChaiScript supports UTF-8 sequences in strings it seems that files encoded in UTF-8 with a BOM at the start will fail silently – this actually drove me nuts until I actively stepped through.

    • If the user provided input is a file (i.e. as parameter to use() or eval_file()), the BOM should be skipped.
    • If the user provided input as a string, the BOM should probably trigger "Unparsed Input".

    As of right now (current master branch), Statements() will not match the first character of the BOM at the start to any known statement (which is correct and for obvious reasons) and as such just return false (which is then interpreted as a no-op).

    Minimal example:

    #include <iostream>
#include "chaiscript/chaiscript.hpp"

int main() {
  chaiscript::ChaiScript chai;

  chai.add(chaiscript::fun([](const std::string &text) { std::cout << text; }), "print");

  // The following expression is skipped rather than
  // causing an "Unparsed Input" exception or skipping
  // the BOM (in case of a file).
  chai.eval("\xef\xbb\xbfprint(\"Hello World!\");");

  return 0;
}
    opened by MarioLiebisch 21
  • Adding basic namespace handling

    Adding basic namespace handling

    Issue this pull request references: #113

    • I posted a more detailed explanation about this pull request in the discussion: #113.

    The new code is wrapped in NAMESPACE HANDLING comments.

    C++: register_namespace(): registers a namespace with an instance of ChaiScript (supports delayed namespace generation) import(): imports a namespace as a global Dynamic_Object

    ChaiScript: import(): imports a namespace namespace(): generates and registers a new namespace

    opened by stephenberry 21
  • Example segfaulting after execution

    Example segfaulting after execution

    With the newest version of chaiscript(5.7.1 as of writing) my application crashes right after closing. This also happens with the basic example(regardles of using stdlib dll or not).

    My OS: Windows 10 Compiler: MinGW 4.9.2 (DW2)

    Additional info on the compiler: gcc --version gcc (i686-posix-dwarf-rev1, Built by MinGW-W64 project) 4.9.2

    opened by SpeCter 14
  • Tutorial

    Tutorial

    Hi would it be possible for someone from the contributors help me write a tutorial for chaiscipt? I've tried this morning and I've not really gotten far with it.

    I was able to make a module but I don't know how to "import" it and use it.

    I would gladly work with someone to do a sort of copy of the python tutorial to chaiscript if anyone is interested.

    opened by lucidguppy 13
  • Update cheatsheet.md

    Update cheatsheet.md

    Issue this pull request references: #

    Changes proposed in this pull request

    Added missing parameters to the examples of "Adding Method / Member"

    opened by profiler-bg 12
  • \r not recognized in eval. Seemingly quits eval.

    \r not recognized in eval. Seemingly quits eval.

    I noticed that the \r character seems to cause a problem when you call chai.eval on a string with \r characters in it. (haven't tested with \r\n. Just \r) I didn't get an error, however. It just abandoned the eval and didn't add any symbols from it. Problem "temporarily" solved by replacing all \r characters with \n, but that's a quick, not optimal, fix.

    opened by lufinkey 12
  • Can't compile example or link to chaiscript.

    Can't compile example or link to chaiscript.

    Hi,

    This might be more down to my ineptitude with the command line but I can't get the example given here working.

    This was the exact command I used.

    clang++ Main.cpp -I./ -ldl -std=c++11 -stdlib=libc++

    Which produces the error.

    chaiscript_engine.hpp:656:16: error: no matching member function for call to 'add'

    Also if I try to link to the lib with just an empty main().

    clang++ Main.cpp -o foo -ldl -I./ -L./ -lchaiscript_stdlib-5.3.1 -std=c++11 -stdlib=libc++

    I get the linker error

    ld: can't link with bundle (MH_BUNDLE) only dylibs (MH_DYLIB) file './/libchaiscript_stdlib-5.3.1.so' for architecture x86_64

    Any ideas?

    opened by PhilCK 11
  • Cannot use chaiscript 5.7 in VS 2012

    Cannot use chaiscript 5.7 in VS 2012

    Hi,

    I came across chaiscript a few days ago and i was very impressed by it.. I wanted to try it desperately.. So I downloaded the package and included the header files chaiscript.hpp .. And didnot add any function to make sure that my linking was correct But when i try to build there are about 149 errors .. Related to cahi script

    Error 1 error C2143: syntax error : missing ',' before '...' c:\chaiscript 5.7.0\include\chaiscript\chaiscript_defines.hpp 66 Error 2 error C2065: 'Arg' : undeclared identifier c:\chaiscript 5.7.0\include\chaiscript\chaiscript_defines.hpp 67 Error 3 error C2988: unrecognizable template declaration/definition c:\chaiscript 5.7.0\include\chaiscript\chaiscript_defines.hpp 67 Error 4 error C2059: syntax error : '...' c:\chaiscript 5.7.0\include\chaiscript\chaiscript_defines.hpp 67 Error 5 error C2143: syntax error : missing ';' before '}' c:\chaiscript 5.7.0\include\chaiscript\chaiscript_defines.hpp 76 Error 6 error C2065: 'default' : undeclared identifier c:\chaiscript 5.7.0\include\chaiscript\dispatchkit\type_info.hpp 50 Error 7 error C2253: 'Type_Info' : pure specifier or abstract override specifier only allowed on virtual function c:\chaiscript 5.7.0\include\chaiscript\dispatchkit\type_info.hpp 50 ............... and list goes on..

    Source.cpp

    include

    include

    include<chaiscript/chaiscript.hpp>

    int main(char* argc,int atgv) {

    return 0;

    }

    errors_chai

    opened by deltamish 10
  • Add

    Add "method_missing" feature

    The "method_missing" method is called for all functions that could not be dispatched. It get's the name of the function and all the original arguments as arguments.

    It's very useful to implement property systems and allow object.prop to access the value.

    The implementation is very hacky but get's the job done. Very much like the entire dispatch system.

    opened by arBmind 10
  • Templates?

    Templates?

    I couldn't find much info on ChaiScript and templates.

    I have an entity class that has this functionality.

    class Entity
{
public:
     template<typename T>
     T* getComponent() { // ... // }
};

    Is it possible to bind getComponent() to Chai?

    opened by PhilCK 10
  • Handle BOM in the beginning of the script

    Handle BOM in the beginning of the script

    Issue this pull request references: #436

    Changes proposed in this pull request

    • detect BOM in the same way a symbolic link is detected before the parsing begins and skip it
    opened by AlekMosingiewicz 9
  • Can we get some examples of regular expression matching, substitution, and extraction?

    Can we get some examples of regular expression matching, substitution, and extraction?

    I need to write a Chai script to use with https://github.com/sabrogden/Ditto/wiki/Scripting and am trying to figure out how to do regular expression matching with Chai script.

    Is it possible to get some example somewhere?

    Ideally, I want to extract email addresses from a string like so:

    Joe Schmow <[email protected]>, one two <[email protected]>, three "four" five <[email protected]>
    opened by imthenachoman 0
  • Way to call method on Chaiscript object from C++

    Way to call method on Chaiscript object from C++

    Hi, I'm looking for some way to call a method on a Chaiscript object from C++, but I can't see anything obvious.

    For example: (Chaiscript)

    class Foo{
   def Foo() {}
   def Bar(x) { return x + 5; }
};

    (C++)

    auto foo = chai.eval("Foo()");
//somehow retrieve 'Foo::Bar' as std::function<int(int)> or similar
std::cout << bar(3) << std::endl; // prints "8"

    I can get the object as a chaiscript::dispatch::Dynamic_Object, but there seems to be no way to see methods on the object. get_attrs just gives me member variables, not the methods.

    opened by mallardtheduck 1
  • The project still alive?

    The project still alive?

    I know that isn't really a issue. But I would like to know if the project still alive, because I don't want to use an abandoned library in my project. The reason I'm asking that is due to the last commit was one year ago.

    opened by EzeAGB 2
  • Passing chaiscript::ChaiScript reference to add_class for enumerations

    Passing chaiscript::ChaiScript reference to add_class for enumerations

    • Compiler Used: MSVC 2019
    • Operating System: Windows 10
    • Architecture (ARM/x86/32bit/64bit/etc): x86 32-bit

    I want to add an enum class to ChaiScript, for this I use chaiscript::utility::add_class.

    My first attempt is to simply pass a reference to the chaiscript::ChaiScript class instance as the first argument, like this:

    chaiscript::ChaiScript chai;
chaiscript::utility::add_class<MyEnumClass>(chai, "MyEnumClass", {
	{MyEnumClass::Apple, "MyEnumClass_Apple"},
	{MyEnumClass::Banana, "MyEnumClass_Banana"},
	{MyEnumClass::Pear, "MyEnumClass_Pear"}});

    However, in the latest version 6.1, this results to a compile error: image_2022-09-12_001505024 Indeed, if we take a look inside add_class: https://github.com/ChaiScript/ChaiScript/blob/2898ae679f733db37f2e9db6256c3d36e87b40eb/include/chaiscript/utility/utility.hpp#L85-L101 This is because when calling equal, not_equal and assign methods from the namespace chaiscript::bootstrap::operators, the first argument t_module is required to be of type Module, since the first argument of equal etc. is of type Module&: https://github.com/ChaiScript/ChaiScript/blob/2898ae679f733db37f2e9db6256c3d36e87b40eb/include/chaiscript/dispatchkit/operators.hpp#L83-L86

    I know that one solution is to create a Module instance, use add_class on the Module instance, and then add the Module instance to the ChaiScript instance. However this feels like additional steps that don't seem to be necessary, especially when the add_class variant for non enum types works with the first argument being a ChaiScript reference fine. Since there is a template argument for the first argument, I do feel that there was intention to make it work with a ChaiScript reference, and maybe other types, though as for enum classes it only works with Module. I think a good fix would be to give to all functions in chaiscript::bootstrap::operators a second template argument for the first parameter, so they can accept any other type than Module, like this:

      template<typename T, typename M>
  void equal(M &m) {
    m.add(chaiscript::fun([](const T &lhs, const T &rhs) { return lhs == rhs; }), "==");
  }

    So when giving M=chaiscript::ChaiScript it should still work as it has the add method, and it will also make add_class work with ChaiScript as first parameter type at the same time. There might be other solutions I don't know, but I think it would be nice if I could just add enums directly to the ChaiScript without having to pass through a Module.

    PS: Btw great project! Integrating it to my program was surprisingly very fast, but it does lack a lot of documentation and hasn't been updated very much...

    opened by AdrienTD 0
  • Is there a good practice to serialize/de-serialize boxed_value?

    Is there a good practice to serialize/de-serialize boxed_value?

    Hi,

    Just like the title. I was wondering if there is a good practice to serialize/de-serialize boxed_value?

    In my usage scenario, two chaiscript execution ends are connected by bytearray stream, so it would probably be convenient and efficient if boxed_value could be serialized directly. But after thinking about it for a while, there doesn't seem to be a good way to do it?

    Thanks.

    opened by desert0616 0
Releases(v6.1.0)

  • v6.1.0(May 29, 2018)

    Changes since 6.0.0

    • Add namespacing support #290 @stephenberry
    • Add utf parsing support
    • cheatsheet.md updates
    • add_class utility support for scoped enums #306 @StanEpp
    • Parser optimizations #300 @niXman
    • Various JSON fixes #377 #400 #409 #371 @totalgee @dinghram @arcoRocks
    • Various cleanups, bugfixes and warning fixes and minor performance improvements
    • Support for C++17 compilers!
    • Support for UTF8 BOM #439 @AlekMosingiewicz @MarioLiebisch
    Source code(tar.gz)
    Source code(zip)

  • v6.0.0(Feb 22, 2017)

    Changes since 5.8.6

    6.0.0 is a massive rework compared to 5.x. It now requires a C++14 enabled compiler

    Compiler Requirements

    • MSVC 2015 or greater
    • g++ 4.9 or greater
    • clang 3.6 or greater

    Breaking Changes

    • Instantiating a ChaiScript object now, by default, builds the stdlib in
      • This was done to address the most common support issues of loading stdlib dynamically at runtime
      • If you want the old behavior, use include/chaiscript/chaiscript_basic.hpp
    • Headers have been reorganized to fully separate stdlib/parser/engine from each other (some faster builds)
    • Bootstrap functions no longer return a reference to the module added to (compile time savings)
    • It's now no longer possible modify AST_Nodes (compile time, runtime efficiency)
    • Function annotations no longer exist (simplifies code, reduces compile time, compile size)

    New Features Added

    • Modular optimization system; this can be accessed via the ChaiScript_Basic interface
    • Execution tracing capability; also accessed via ChaiScript_Basic interface
    • range-based for loops for( id : container ) { } (much better performance than other loop types)
    • If-init expressions (ala C++17)
    • Support for passing r-value references to functions
    • Support for containing unique_ptr
    • Add helpers for exposing enum classes to ChaiScript
    • Allow typed ChaiScript defined functions to perform conversions on call #303

    Improvements

    • Compile time improvements
    • Compile size improvements
    • Significant runtime improvements (see "Modular optimization system")
    • Significant parser improvements, both with parse-time and parser initialization time (Thanks @niXman)
    • Fix type conversion to bool in conditionals

    Improvements Still Need To Be Made

    • File location tracking has been rewritten; this currently means error location reporting is not as good as it was
    • Tracing capability needs to be tested and vetted
    Source code(tar.gz)
    Source code(zip)

  • v5.8.6(Feb 22, 2017)

    Changes since 5.8.5

    • Optimize away return statements in lambdas also
    • Allow conversions to bool in conditionals
    • Don't allow class statements inside of scopes
    • Properly error when a dynamic object non-function member is called
    Source code(tar.gz)
    Source code(zip)

  • v5.8.5(Oct 10, 2016)

    Changes since 5.8.4

    • Fix order of operations for prefix operators
    • Make sure atomics are initialized properly
    • Remove parsing of unused prefix & operator
    Source code(tar.gz)
    Source code(zip)

  • v5.8.4(Oct 10, 2016)

  • v5.8.3(Sep 16, 2016)

  • v5.8.2(Sep 16, 2016)

  • v5.8.1(Mar 5, 2016)

  • v5.8.0(Feb 17, 2016)

    Changes since 5.7.1

    • Make all parser iterator operations range checked
    • Parse in-string eval statements once, not once for each execution
    • Fix parsing of operators (ie 1<-1 now parses)
    • Fix variable scoping for functors
    • Exception reduction
    • Various object lifetime fixes
    • Add JSON support for load / save #207
    • Numeric overload resolution fixes #209
    • Fix long long #208
    • Add octal escapes in strings #211
    • Fixed sizing of binary literals #213
    • Added support for != with bool values #217
    • Various value assignment vector fixes
    • Fixed broken hex escape sequences from @ChristianKaeser
    • Multiply defined symbols fixes #232 @RaptorFactor
    • Add add_class helper #233 @vrennert
    • Cheatsheet fixes #235 @mlamby
    • Fix parsing of strings inside of in-string eval statements
    • Allow lower-case global keyword
    • Enable thread-local on MSVC (should be significant performance boost)
    Source code(tar.gz)
    Source code(zip)
    chaiscript-5.8.0-Darwin.tar.bz2(1.15 MB)
    chaiscript-5.8.0-Linux.deb(1.51 MB)
    chaiscript-5.8.0-win32.exe(929.82 KB)
    chaiscript-5.8.0-win64.exe(1.05 MB)

  • Test_Release(Oct 17, 2015)

  • v5.7.1(Jul 17, 2015)

    Changes since 5.7.0

    • Build time reduction
    • Build size reduction
    • Performance increases
    • Fixed ~20 crash-bugs found with fuzzy testing #194
      • Let unhandled exceptions propogate to user
      • Report eval_error when break statement is not in loop
      • Fix handling of 0 length scripts closes #193
      • Don't crash on arity mismatch - Specifically affects the case where no overloads exist for a given function
      • Fix error printing for bind calls
      • Handle unexpected continue statement
      • Check arity during bind
      • Don't allow arith conversion on variadic function
      • Correct bind parameter match count
      • Add in expected Boxed_Value exception cases
      • Check access to AST, don't allow ; in func def
      • Don't attempt arithmetic unary & call
      • Don't crash on 0 param call to bind
      • Catch errors during member function dispatch
      • Properly handle type of const bool &
    • Automatic deduction of lambda type signatures
    • Work with non-polymorphic parent/child conversions
    • Move to codecov for coverage reporting
    • Add .at method for Map objects
    • Various corrections for support of move-only objects
    Source code(tar.gz)
    Source code(zip)
    chaiscript-5.7.1-Darwin.tar.bz2(1.13 MB)
    chaiscript-5.7.1-Linux.deb(1.45 MB)
    chaiscript-5.7.1-win32.exe(898.64 KB)
    chaiscript-5.7.1-win64.exe(1.02 MB)

  • v5.7.0(May 6, 2015)

    Changes since 5.6.0

    • Significant code cleanups and reduction
    • Smaller builds
    • Faster compiles
    • Less runtime memory usage
    • ~2x faster runtimes
    • biicode support
    • method_missing feature added #164 @arBmind
    • Generic objects with dynamic properties support
    • Add ability to call functions contained in properties
    • Add lambda captures
    • Create cheatsheet.md for all-in-one reference of features
    • Fix support for libc++
    • Eliminate clone of return value stored locally
    • Eliminate 'return' statements when last line of function
    • Reduce number of runtime exceptions occuring
    • Reduce copies / moves of return values.
    • make use statement return value of last statement in file
    • Add ability to access fixed array sizes
    • Add support for scientific notation floating point literals #174 @totalgee
    Source code(tar.gz)
    Source code(zip)
    chaiscript-5.7.0-Darwin.tar.bz2(1.32 MB)
    chaiscript-5.7.0-Linux.deb(1.46 MB)
    chaiscript-5.7.0-win32.exe(878.94 KB)
    chaiscript-5.7.0-win64.exe(1.03 MB)

  • v5.6.0(Jan 17, 2015)

    Changes since 5.5.1

    • Throw exception on integer divide by 0

    • Add optional type specification to function declarations

      def func(int i, j, double k) {
  // i must be an int.
  // j can be anything
  // k must be a double
  // normal conversion rules still apply
}

    • Many minor fixes for compiler warnings

    • Add support for std::future and std::async

      var f := async(someFunction);
var f2 := async(someFunction2);

// someFunction and someFunction2 are running in parallel now
f.get();
f2.get();

    • Fully support r-value returns, supporting move-only objects and reducing object copies

    Source code(tar.gz)
    Source code(zip)
    chaiscript-5.6.0-Darwin.tar.bz2(1.24 MB)
    chaiscript-5.6.0-Linux.deb(1.46 MB)
    chaiscript-5.6.0-win32.exe(819.80 KB)
    chaiscript-5.6.0-win64.exe(998.87 KB)

  • v5.5.1(Dec 21, 2014)

  • v5.5.0(Nov 10, 2014)

  • v5.4.0(Sep 1, 2014)

    Changes since 5.3.1

    • Decreased compile time and build size
    • Make "reflection" module built in (losing some of the time / build size gains)
    • Add new "class" syntax for ChaiScript defined methods and attributes see: unittests/class.chai for examples
    • Minor performance enhancements
    • major to_string performance enhancements
    • Provide API for retrieving registered type name #124
    • Added strong reference to container to range object #132
    Source code(tar.gz)
    Source code(zip)

  • v5.3.1(Jun 11, 2014)

    Changes since 5.3.0

    • Add automatic conversion of arithmetic return types, following the same rules as conversion of arithmetic types when passing parameters
    • Add automatic casting up the inheritence hierarchy when possible.
    • Enable travis.ci testing
    • Allow users to add globals from within script
    • Various static analysis fixes
    • Code modernization to C++11
    • Unofficial support for Haiku added
    • Fix #121 - Inability to compile on cygwin
    • Formatting fixes and spelling corrections
    • Apply "include what you use" https://code.google.com/p/include-what-you-use/
    • Apply clang-modernize
    • Various threading fixes
    • Performance improvements
    Source code(tar.gz)
    Source code(zip)

  • v4.3.1(May 4, 2014)

  • Release-5.3.0(Mar 24, 2014)

    Current Version: 5.3.0

    Note, with this version the C++11 version of ChaiScript has become the official version, and the boost version of ChaiScript will see very little if any future development.

    Changes since 5.2.0

    • Official support for MSVC with C++11. All major platforms and compilers are now support for C++11 release
    • Enhanced unit tests
    • Add continue statement, fix various use cases for for loops
    • Fix use of suffixed numbers in vector initialization
    • Code cleanups
    • Eliminate global data, which makes code more portable and thread safe
    • Fix issue #79
    • Merge pretty_print fixes from @mgee #82
    • Compiler warning fixes for latest compiler releases
    • Fix threading problems
    • Fix linking error on MacOS Mavericks #88
    • Allow non-const globals
    • Make sure user cannot name a variable with :: in it #91
    • Fix various string / map / vector size and count calls for compilers which have weird overloads for them. #90 #93 #95
    • Make module search path relative to the currently running executable
    • Build and work with wstring windows builds
    • fix for some new line cases in the middle of a vector initialization from jespada
    Source code(tar.gz)
    Source code(zip)

  • Release-4.3.0(Feb 23, 2014)

    Current Version: 4.3.0

    Note: this is scheduled to be the last release that requires boost, new releases after this will require a C++11 compiler.

    Changes since 4.2.0

    • Enhanced unit tests
    • Add continue statement, fix various use cases for for loops
    • Fix use of suffixed numbers in vector initialization
    • Code cleanups
    • Eliminate global data, which makes code more portable and thread safe
    • Fix issue #79
    • Merge pretty_print fixes from @mgee #82
    • Compiler warning fixes for latest compiler releases
    • Fix threading problems
    • Fix linking error on MacOS Mavericks #88
    • Allow non-const globals
    • Make sure user cannot name a variable with :: in it #91
    • Fix various string / map / vector size and count calls for compilers which have weird overloads for them. #90 #93 #95
    • Make module search path relative to the currently running executable
    • Build and work with wstring windows builds
    Source code(tar.gz)
    Source code(zip)
Owner
ChaiScript
ChaiScript
GitHub http://chaiscript.com
A minimalist and mundane scripting language.

Drift Script A minimalist and mundane scripting language. I like all simple things, simple and beautiful, simple and strong. I know that all developme

Drift 12 Nov 14, 2022
Embedded JavaScript engine for C/C++

V7: Embedded JavaScript engine NOTE: this project is deprecated in favor of https://github.com/cesanta/mjs V7 is the smallest JavaScript engine writte

Cesanta Software 1.4k Dec 29, 2022
A tool for generating cross-language type declarations and interface bindings.

Djinni Djinni is a tool for generating cross-language type declarations and interface bindings. It's designed to connect C++ with either Java or Objec

Dropbox 2.8k Jan 3, 2023
A multi-language script plugin loader for BDS LiteLoader, based on ScriptX

LiteXLoader - 划时代 x 跨语言脚本插件加载器 ?? 简介 LiteXLoader是一个基岩版官方服务端Bedrock Delicated Server（以下简称BDS）插件框架，提供强大的跨语言脚本插件支持能力和稳定的开发API支持。

LiteLoaderBDS Developers 85 Dec 20, 2022
UserLand Frontier is a web application development platform that includes a scripting language, integrated object database, code editor, debugger, outliner, multi-threaded runtime and integrated HTTP server. It has been used as a weblog and website hosting service, local scripting environment and web services client and server.

UserLand Frontier Open Source Release Version 10.1a12 Last updated March 14, 2021 by Rogers Cadenhead. Installation Instructions This project is curre

Rogers Cadenhead 25 May 19, 2022
The Wren Programming Language. Wren is a small, fast, class-based concurrent scripting language.

Wren is a small, fast, class-based concurrent scripting language Think Smalltalk in a Lua-sized package with a dash of Erlang and wrapped up in a fami

Wren 6.1k Dec 30, 2022
Kuroko - A bytecode-compiled scripting language

Kuroko - A bytecode-compiled scripting language Kuroko is a bytecode-compiled, dynamic, interpreted programming language with familiar Python-like syn

Kuroko 325 Dec 29, 2022
simple and fast scripting language

The Aument Language The Aument language is a work-in-progress dynamically-typed scripting language with performance first: this scripting language is

The Aument Project 35 Dec 27, 2022
Dialogue scripting language for Unreal Engine

Supertalk Welcome to Supertalk! This is a simple dialogue scripting language for Unreal Engine created due to frustration with visual dialogue tree wo

Sam Bloomberg 41 Nov 18, 2022
A minimalist and mundane scripting language.

Drift Script A minimalist and mundane scripting language. I like all simple things, simple and beautiful, simple and strong. I know that all developme

Drift 12 Nov 14, 2022
🎩 An interpreted general-purpose scripting language 🔨

Dunamis Version 0.0.0.2 - Alpha Version 1.1 An interpreted general-purpose programming language Contents Syntax Functions Variables Objects Enums Incl

Tech Penguin 4 Dec 21, 2021
a C++ scripting language

/>mpl setup />mpl requires CMake and a C++ compiler to build, rlwrap is highly recommended for running the REPL. $ cd ampl $ mkdir build $ cd build $

Andreas Nilsson 2 Nov 6, 2021
A basic build system for the Skript scripting language.

skib A basic build system for the Skript scripting language. Features #include other files recursively #define preprocessor symbols and macros Usage #

Daniel 1 Jun 27, 2022
A scripting language written in C

News KGScript will be rewritten from scratch in C or C++ (a big update) Usage Usage: ./KGScript file.kgs [options] Examples prints("Example") printi(1

null 16 Nov 12, 2021
Simple, fast, JIT-compiled scripting language for game engines.

Aftel Aftel (acronym for «A Far Too Easy Language») is a programming language, primarily intended to serve as an embeddable scripting language for gam

Rosie 17 May 20, 2022
ACL - A simple scripting language made in c++

ACL ACL is a simple and easy to learn language. ACL is a compiled language, made with C++. For code examples look at the examples/ folder. We would ap

Niclas 10 Nov 1, 2022
A scripting language created mainly for game engines

HCode Hammurabi's Code A scripting language created for the use in games and game engines. Currently supported features and roadmap Structs Functions

null 4 Oct 11, 2020
ArkScript is a small, fast, functional and scripting language for C++ projects

ArkScript Documentation Discord server: invite link, to discuss the specification of the language and receive help Modules Nota bene: the project is r

ArkScript 484 Jan 1, 2023
The UwU's Scripting language. Made with love for UwU Nyanny Commuwiwwy!

UwUscript UwUscript is a scripting language. Installation Prerequisite LLVM 10.0 flex and bison. CMake 3.10 Build Clone this repository. git clone htt

UwUssimo Robinson 8 Nov 28, 2022
Unix pager (with very rich functionality) designed for work with tables. Designed for PostgreSQL, but MySQL is supported too. Works well with pgcli too. Can be used as CSV or TSV viewer too. It supports searching, selecting rows, columns, or block and export selected area to clipboard.

Unix pager (with very rich functionality) designed for work with tables. Designed for PostgreSQL, but MySQL is supported too. Works well with pgcli too. Can be used as CSV or TSV viewer too. It supports searching, selecting rows, columns, or block and export selected area to clipboard.

Pavel Stehule 1.9k Jan 4, 2023