Embeddable Scripting Languages

Garthy

Level 9

Quack, verily

Embeddable Scripting Languages

« on: December 07, 2009, 07:54:54 PM »

I seem to have been fighting this problem for years. I'm wondering if anyone can help. I'm trying to find a embeddable scripting language that will allow me to do this:

In a C/C++ program, set up a scripting environment, load a script (from a file), push some local C/C++ functions into the environment, and then call the script, which may contain calls to the functions I pushed into the environment. Basically:

A (C++) calls B (scripting language) which calls a function in A (C++).

An opaque type needs to be passed in through the chain, and it needs to be able to handle simple things, such as passing around integers, floats, and strings.

Note that being able to include C/C++ code in a scripting language as an extension is *not* enough. I know that a lot of things can do this- it's not what I'm trying to do, and not what I want.

Now, there's a bunch of languages that *might* do it, and tools that *might* help. I'm after something sufficiently advanced that it *specifically* presents a clear and easy-to-use example of this sort of thing in their documentation.

So far, I've got this sort of thing working with LUA, but I'm after other options. Unfortunately, for most things that claim that they can do this, there's minimal documentation and rarely an example of how to do it. Most of the examples end up focusing on extending the scripting language, rather than embedding it in an existing program. I end up sinking a whole bunch of time into trying to figure it out, then find out that I can't *really* do it, the minimal doco that hinted it was possible was actually wrong, or there's some nasty catch that is being glossed over.

Here is a concrete example of what I'd like to do:

*** foo.cpp:

Code:

class Bar
{
  public:

    Bar();
    int foo(int b, int c);
    
    int run0(int e);
    int run1(int e, int f);

    ScriptingEnvironment env;
    int d;

  (other, really complex definitions)
};

// Just an adapter to turn the opaque type back into a class, then
// call a method. I'm assuming the environment handles opaque types with
// (void *).
static int call_foo(void *a, int b, int c)
{
  return ((Bar *)a)->foo(b, c);
}

// The function that may be called from the script after passing through the
// adapter.
int Bar::foo(int b, int c)
{
  return somecomplexfunction(b, c, d);
}

void Bar::Bar()
{
  // Create the environment.
  env = ScriptingEnvironment::create();
  // Add our local adapter function "call_foo", accessible as "foo" from
  // the script.
  env.add("foo", call_foo, "pii") // Pointer, int, int.
  // Load the script from an external file. I don't mind if I have to load
  // first then add funcs, or add funcs then load- works for me.
  env.load("somescript.ext");
  // Any explicit exporting would be done here, if needed.
  env.export("somefunc", "pi");
  env.export("otherfunc", "pii");
}

int Bar::run0(int e)
{
  // Setting "d", which we end up using in "foo" if it is called, but not
  // otherwise.
  d = somemagicfunc(e);
  // We pass in "this" as an opaque type, so that if it calls "call_foo",
  // we can convert it back to the class via the adapter.
  return env.call("somefunc", "pi", this, e); // Pointer, int.
}

int Bar::run1(int e, int f)
{
  d = somemagicfunc(e+f);
  return env.call("otherfunc", "pii", this, e, f); // Pointer, int, int.
}

int main()
{
  // Construct a "Bar" named "bar", which will load the script and do the
  // needed setup.
  Bar bar;
  // Make multiple calls to the loaded script and environment.
  cerr << bar.run0(4) << "\n";
  cerr << bar.run0(5) << "\n";
  cerr << bar.run0(6) << "\n";
  cerr << bar.run1(4) << "\n";
  cerr << bar.run1(5) << "\n";
  cerr << bar.run1(6) << "\n";
}

*** somescript.ext:

Code:

#NB: "foo" is impemented back in the original C++.

# This is called from the C/C++ side.
def somefunc(a, e)
  return foo(a, e) + foo(a, 5)
end

# This is called from the C/C++ side.
def otherfunc(a, e, d)
  return foo(a, e) + foo(a, 6) + foo(a, d)
end

..............

So the question is: Is anyone aware of an embeddable scripting language (apart from LUA) that *can* do this, has personally done it themselves, knows the official documentation has *actual* easy-to-use examples that show the officially-supported way of doing it, and can also recommend it?


« Last Edit: December 08, 2009, 03:00:43 PM by Garthy »	Logged

David Pittman

Level 2

MAEK GAEM