Foreign Function Interface Article Index for
Foreign 		Website Links For
Foreign 		 

Information About

Foreign Function Interface
  CATEGORIES ABOUT FOREIGN FUNCTION INTERFACE
   
application programming interfaces
   
programming language topics
   
APPAREL
BABY
BEAUTY
BOOKS
CAR TOYS
CELL PHONES
DVD'S
ELECTRONICS
GOURMET FOOD
GROCERIES
HEALTH & PERSONAL
HOME & GARDEN
JEWELRY
MUSIC
MUSIC INSTRUMENTS
OFFICE PRODUCTS
SOFTWARE
SPORTING GOODS
TOOLS & HARDWARE
TOYS
VIDEO GAMES
SHOPPING HOME
MORE SHOPPING...



It should be noted that despite the name, FFIs are not necessarily restricted to Function Call s; many FFIs permit Method Call s on objects; and some even permit migration of non-trivial datatypes and/or objects across the language boundary.

The term foreign function interface is generally not used to describe multi-lingual runtimes such as the Microsoft Common Language Runtime , where a common "substrate" is provided which enables any CLR-compliant language to use services defined in any other. In addition, many distributed computing architectures such as the Java Remote Method Invokation (RMI), RPC , CORBA , and SOAP permit different services to be written in different languages; such architectures are generally not considered FFIs.

In most cases, a FFI is defined by a "higher-level" language, so that it may employ services defined and implemented in a lower level language, typically a systems language like C or C++. This is typically done to either access OS services in the language in which the OS' API is defined, or for performance considerations.

Many FFIs also provide the means for the called language to invoke services in the host language as well.


OPERATION OF A FFI


The primary function of a FFI is to mate the semantics and calling conventions of one programming language (the ''host'' language, or the language which defines the FFI), with the semantics and conventions of another (the ''guest'' language). This process must also take into consideration the Runtime Environment s and/or Application Binary Interface s of both. This can be done in several ways:

  • Requiring that guest-language functions which are to be host-language callable be specified or implemented in a particular way; often using a compatibility library of some sort.

  • Use of a tool to automatically "wrap" guest-language functions with appropriate glue code, which performs any necessary translation.

  • Restricting the set of host language capabilities which can be used cross-language. For example, C functions called from C++ may not (in general) include reference parameters or throw exceptions.


FFIs may be complicated by the following considerations:

  • If one language supports Garbage Collection and the other does not; care must be taken that the non-GC language code doesn't do something to cause the GC to fail. In JNI, for example, C code which "holds on to" object references passed from Java must "register" this fact with the Java runtime; otherwise the referred-to objects may be garbage-collected if no more valid references to the object(s) exist within the Java environment. (The C code must likewise release such references manually when the corresponding object is no longer needed).

  • Complicated or non-trivial objects or datatype may be difficult to map from one environment to another.

  • It may not be possible for both languages to maintain references to the same instance of a mutable object, due to the mapping issue above.

  • One or both languages may be running on a Virtual Machine (including different VMs).

  • Cross language Inheritance or other forms of type or object composition may be especially difficult.



EXAMPLES


Examples of FFIs include:

  • C++ has a trivial FFI with C, as the languages share a significant common subset. The primary effect of the extern "C" declaration in C++ is to disable Name Mangling .

  • JNI, which provides an interface between Java and C / C++ , the preferred systems language on most systems where Java is deployed

  • The FFIs of Common Lisp and Haskell

  • The major "scripting" languages, such as Python , Perl , Tcl , and Ruby , all provide easy access to native code written in C/C++ (or any other language obeying C/C++ calling conventions).


In addition, many FFIs can be generated automatically: for example, SWIG .


EXTERNAL LINKS