On Tuesday, 6 October 2015 at 19:42:08 UTC, Jacob wrote:
There are many programs out there that use some sort of
scripting capabilities.
I've been wanting to write an app that exposes a scripting like
environment D, lua, or some other fast language to the user.
But there are two requirements:
1. The user has access to all objects created in app. e.g., if
I create a class X in the app then the user can instantiate X
in the script without having to recreate it. (the script then,
is sort of an extension of the app)
I don't mind actually having to expose X to the script, but it
should be easy.
2. It should be fast. When it is "recompiled" it shouldn't take
more than a few seconds. It also shouldn't require a
re-initialization of everything.
Can D do this easily?
I can see two ways about this:
1. Use D
Can you include your application's source code with the
application?
If so, what I think could work is simply import modules belonging
to your app from your plugin's source code, but don't link with
the app object files.
The main complication with this approach is that you would need
to either include a D compiler with your app, or expect the user
to have one installed on their system. Note that DMD is not
redistributable (you can't include DMD with your program), but
this doesn't apply to LDC/GDC.
This might also get tricky on Windows, as you'll probably need to
create or generate a .DEF file (and accompanying import library)
which lists all exports/imports shared between your program and
plugins. This will include all class methods as mangled names.
D compile times are quite low already, so I don't think this
would be an issue.
2. Use a scripting language, e.g. Lua
D's compile-time reflection and code-generation abilities
certainly make it possible to expose functions and classes to
scripts. You could add a mixin to an exposed class, which would
generate all the necessary run-time type information to expose
the class to the scripting language. I don't know if any existing
library already provides this in an easy-to-use manner, though.
Perhaps a good starting point would be LuaD:
https://github.com/JakobOvrum/LuaD
