Hello,
I just finished working through Essentials Programming Languages
(first edition) and now know enough to write recursive descent
interpreters for simple languages. The book also explains how to create
bytecode virtual machines. So far so good.
I now wish to learn how to interface c code to the languages I create.
In other words, I would like to call existing C libraries from the
languages I create.
I am utterly at a loss how to do this. Can someone please point me at
any book or website that explains how to interface existing C code to
an interpreter/bytecode based vm?
From what I understand from a survey of various languages with ffi,
the first step would seem to be to write a vm/interpreter *in C* and
then have some kind of "mylanguage.h" header file that exposes various
data structures of the VM/AST. This is the key step that seems to
enable the creation of an FFI mechanism (the details of which are a
mystery to me :-( )
I am sorry if that is totally wrong. (please correct me). Am i
totally on the wrong track? Should i now learn how linkers work?
I am totally confused as to what to study and where to look to
understand how to write a language with an ffi. Any pointers will be
very much appreciated.
Thanks in advance,
Ravi
[If you want to make a fully general mechanism, you're on the right
track and it's a lot of work. the other hand, if you merely have a
few existing libraries that you want to call, just write some operators
for the VM that call them. -John]

When you're running in a VM and you want to call compiled C code, this
is called a native interface. In the Java world it's called JNI, and in
the .NET world it's called Platform Invoke (p-invoke).

As John said, you basically need to create a virtual instruction that
can call a routine at a specified address. The need to know the address
is a fundamental requirement, of course.

Windows we typically call into native DLLs. The virtual machine
could be given the job of loading the DLL, and then it can query the
addresses of the public functions.

In the embedded world, we typically compile code to run in a fixed
memory range, and we use a vector table to create standard entry points
the VM can call into.

of the key requirements is to pass parameters both ways. This
requires the VM to know the particular calling convention used by the C
code.

All this is a little harder if you have a managed memory environment in
your VM (like the JVM or .NET CLR). It requires a lot of thought on how
to handle pointers in this kind of situation since it's considered
"unsafe" to access managed memory areas with a pointer. It's not
impossible to implement, but you need to be aware of the security
issues.