Re: Embeddable and Extensible Languages

PlayDough wrote:
> packages/add-ons). Perferably it has a reasonable footprint, it
> portable across platforms (Linux and Win32), and support for
> multiple contexts.


I wasn't abundantly clear on the above point (others have asked "what
do I mean exactly"), so I want to clarify the above point.


I would like to find a language with a reentrant interpreter. But
even this isn't totally accurate. Perhaps a C++ example might clear
up what I'm trying to do.


For example, I create a class:


class X
{
public:
X(const std::string& script_file);
void Run(void);


private:
Interpreter_context ctx;
};


And in the constructor, I do something like:


X::X(const std::string& script_file)
{
interp_init();
interp_create_context(&ctx);


load_script(&ctx, script_file);
}


void X::Run(void)
{
run_script(&ctx);
}


Now in the application, I would instantiate class X several times,
however, in separate threads. I don't have control over the thread
creation mechanism, nor the instantiation of the classes. I only have
control over the class I create.


However, as an example, I can do the following:


void* thread1(void* arg)
{
X x1("script1");


x1.Run();
}


void* thread2(void* arg)
{
X x2("script1");


x2.Run():
}


int main(void)
{
pthread_t thr1, thr2;


pthread_create(&thr1, 0, thread1, 0);
pthread_create(&thr2, 0, thread2, 0);


pthread_join(thr1, 0);
pthread_join(thr2, 0);
}


Nearly all the languages I've looked at have some soft of global,
static storage that prevents this type of mechanism from working. For
example, Ruby has ruby_init(). Ignoring issues of callback (language
extensions that call class methods), is there a language that
guarantees that x1's interpreter and x2's interpreter will not collide
in threads?


This is why I'm leaning towards Lua. It seems well behaved in this
respect.


Thanks,
Pete

Return to the comp.compilers page.
Search the comp.compilers archives again.