🚀 go-pugleaf

On many platforms, there is a de-facto calling standard that many 
language processors can generate calls to, allowing libraries to be
be implemented in one language, and called from others.  Often
(although 
not always) this standard is the native "C" calling mechanism on the
platform, but almost always it is possible to use C to create libraries

that obey the standard, such that they can be invoked by languages 
other than C.  It would be really nice if C++ could be used in the 
same way, to produce language-neutral libraries.

Since C++ defines the 'extern "C"' construct, with the goal of being
able to call routines from the C RTL, this seems to imply that the 
C++ language constrains data objects (objects without member-functions)
to be built in memory in the same way that C would build those objects.

Given this data compatibility with C, the only reason I can see that
call-in (e.g. calling a C++ routine from a C main program) may not work

is that a program with a C main() function may not properly initialize 
any C++ modules it's linked with, so that non-local static objects 
declared in those modules may not get constructed.

I was wondering if there's any likelihood of a fix for this situation
getting into the standard?  It doesn't seem too hard - one solution
would be to define a #pragma directive, whose purpose would be to
create a public initialization routine for the module in which it
appears (with a name supplied as an argument to the pragma), which a
non-C++ user of the module would have to invoke prior to any other
routines or objects exported by the module.  Implementations that 
use some linker or loader magic to auto-initialize would probably
generate an empty routine from this pragma; implementations that
generate explicit calls for initialization would generate a routine
containing the same initialization code as would be generated if 
the module contained a C++ main function.  The freedom as to when 
(in a C++ program) initialization of a module occurs doesn't seem to
have any bearing on this, as regardless of when the C++ environment 
would call a module's initialization function, such a function must be
generated by the compiler; all I'm proposing is that a pragma be
defined to allow a similar initialization function to be generated 
for explicit calling by non-C++ programs.

The generated initialization function must not mind being called
multiple times, nor must it mind if both it and the "internal" C++
initialization process are invoked.  Other than this, I don't see 
any particular problems.

Any comments?


John


---
[ comp.std.c++ is moderated.  Submission address: std-c++@ncar.ucar.edu.
  Contact address: std-c++-request@ncar.ucar.edu.  The moderation policy
  is summarized in http://dogbert.lbl.gov/~matt/std-c++/policy.html. ]