Re: thick? thin? binding

[David Emery <demery@cox.rr.com>]

We had a tremendous discussion on this during the POSIX/Ada
(IEEE P1003.5) days.  It turns out that there are really two
dimensions to the problem.  We used "thick" vs "thin" to
describe the documentation.  If the binding has a fully rewritten
set of documents, it's a "thick binding".  If the binding comes
with a document that refers to the underlying binding, it's a "think
binding".  For example of the latter:
   The operation Open implements the C operation Open(), with the
   parameters mapped to Ada types as follows: ....
For the actual presentation of API itself, we used the terms "direct"
and "abstract".  A "direct binding" would make the interface pragmas,
etc directly visible.  (Hence the name.)  An "abstract binding" would
hide the underlying C (or whatever) API.  As an example of the latter,
most POSIX/C operations return -1 to indicate failure, and sett the
errno value.  We replaced this by the POSIX.POSIX_Error exception,
and provided an analog to errno.  Additionally, our errno (a function
in the package POSIX) was required to be tasking-safe.  Depending on
how both the Ada binding and the C library was implemented, a direct
binding, providing 
   errno : interfaces.c.int;
   pragma inport (convention => c, entity => errno);
might well not be tasking-safe.  

Although I'm certainly biased, I still think that the best discussion 
on the issues associated with Ada bindings is the rationale in 
IEEE Std 1003.5....  

         dave
         (editor for the first IEEE 1003.5 standard...)