Muesli: Multiple Utility, Evaluation and Scripting Language Interface

Muesli is a library to interface an application to multiple programming language evaluators (normally, interpreters).

Muesli allows your program to call any one (or more) of a number of programming language interpreters through a consistent interface, such that you can choose the language(s) to use at run-time.

It can be used anywhere where you want to use a scripting language but don't want to be restricted to any particular scripting language.

It makes some of the same facilities available in the supported languages, and so can also be used to call one language from another.

Features

Muesli provides the means to find a language interpreter interface by name or by filename extension, and to get a string or a file evaluated in that language, using the same API for all the languages.

It extends each language to allow it to call the other languages, likewise.

It also provides some assistance for handling application parameters (with getopt) from the scripting languages.

Entry points

Since this is a package for programmers to incorporate in projects, a few lines of code will probably explain the main entry points better than a considerably larger amount of text:

muesli_load_file(filename);

muesli_value_t result =
  muesli_eval_in_language(language_name,
		          program_fragment,
                          strlen(program_fragment),
                          flags);

Alternatively, if you want to get an evaluator and use it repeatedly, you can do:

evaluator_interface *my_evaluator =
   muesli_get_named_evaluator(language_name, exit_if_not_found);
	

(my_evaluator->load_file)(my_evaluator, filename);

muesli_value_t result =
  (my_evaluator->eval_string)(my_evaluator,
	                      program_fragment,
                              strlen(program_fragment),
	                      flags);

Languages supported

The level of support for languages varies, currently mostly according to how much the parent project has used them. The following languages are currently supported, mostly quite fully:

• exec -- run an external program for each evaluation
• Guile
• Haskell -- uses a Haskell system running in a separate process
• JavaScript
• Common Lisp -- uses a Lisp system running in a separate process
• Lua
• Perl
• pipe -- start up a process, and talk to it for each evaluation
• Python
• Octave -- a MATLAB clone
• SIOD (UL version) -- a small Scheme implementation
• stack-code -- a small bytecode interpreter for testing bytecode language interfaces
• Tcl

Note that the languages running in a separate process (Common Lisp, Haskell) can't be used to script actions of your application, as they can't call the functions of your application; they can only be used to evaluate strings.

The following language interfaces are currently at at least early stages of being interfaced:

• emacs-lisp (embedded in GNUEmacs)
• GhostScript
• machine code
• R
• Ruby
• Smalltalk
• SWI Prolog
• s-lang
• tcc -- Tiny C Compiler

At least the following further language interfaces are planned:

• jvm (bytecode)
• Parrot (bytecode)

Further suggested languages include:

• scsh

Please feel welcome to request, or add, interfaces to further interpretive languages with Free Software implementations.

Documentation

You can get the manual as HTML, DVI, info, or PDF.

Muesli includes a demo mini-application.

Licensing

Muesli is licensed under the GPL, version 3 or later.

Getting the files

CVS access

Here are the instructions for CVS access to the project. You can browse the sources online here.

I would like to apologize for using CVS; I tried the others that this site provides, but I had what I suspect may be firewall / gateway trouble (even though I went via our DMZ hosts). I'll try to fix this sometime.

Downloads

The download area for Muesli is https://savannah.nongnu.org/files/?group=muesli.

Communication

• News
• Mailing lists
• Bugs
• Tasks

The project details page is at http://savannah.nongnu.org/p/muesli.

Helping with the project

Please feel welcome to join in with the project. My contact address is at the bottom of this page. I'll do my best to answer any questions about the project (and not just say RTFM).

Muesli is, by its nature, inherently a very modular project, and it's possible to work on a language interface without needing to know more than that interpreter's API, quite a bit of muesli.h, and probably a few bits of muesli.c, so it should be possible to dip into the project to do what you want to do, without having to commit much time to it.

Generally speaking, I can see three main areas for work on the code:

• Integrate with more scripted applications
• Support more languages
• Add more forms of language access (e.g. function slots to set and get variables in the languages)

I'm sure that more work on the documentation would be useful too, perhaps creating a Guide to accompany the manual.

For a more detailed view of what needs to be done, you can look in the ``Status'' section of the manual to see the status of each language interface and in the project tasks list for specific things to contribute; or of course you can think up whatever you'd find useful, and either write it yourself, or add it to the tasks list. Feel welcome to take any of these tasks from me, or to contribute anything else (including improving the documentation and the web site, designing a logo, or anything else).

Acknowledgements

Muesli was initially written within the Biocomputing-Developmental Systems Centre, University of Limerick, Ireland, by John Sturdy.

The parent project for which Muesli was developed is funded by Science Foundation Ireland (SFI).

Muesli would be nothing without the implementors of the languages to which it provides interfaces.