Re: bug in gnustep-make / my last mail (pantomime)

[Nicola Pero]

> hmm, I found the "bug". I build pantomime twice (for a static and a
> dynamic library). However when building with shared=no, the
> dynamically loadable bundle is built with -fPIC, which is definitely
> wrong.

The 'dynamically loadable bundle' is the SSL bundle in the Pantomime
library I suppose ?

I'm not sure what the meaning of 'shared' vs 'static' is for a dynamically
loadable bundle ... I don't think gnustep-make makes any difference
between them.

Thinking about it, it looks correct - I don't think it's useful to make a
difference between them :-)

Maybe the difference would be that a 'shared' loadable bundle is like a
shared library object, but loaded into an already running executable,
while a 'static' loadable bundle would be like a static (non-shared)
library object, but loaded into an already running executable ?

In other words, that a 'shared' loadable bundle object, when loaded
multiple times from different applications, is shared between them, while
a 'static' loadable bundle object, when loaded multiple times from
multiple applications, is not shared ?

Well I don't see the point of making this complicated distinction, since
the 'static' loadable bundle object is always more inefficient and gives
no benefits :-) I assume it would be used automatically on platforms which
don't support the shared one.

I'm not even sure platforms allow you to make such a distinction.

While for libraries there might be a reason to use static libraries (have
an executable which is self-contained without having to depend on anything
from the outside; more efficient executable code) - static libraries are
`merged' into the executable, I'm not quite sure what the point would be
in a 'static loadable object'.  Even if 'static', the object must be
loaded from outside.  So what's the point of having it 'static' ?  I think
if you are using a 'loadable object', you always want the more efficient
implementation the environment supports of that concept :-)

So, I think you should always build dynamically loadable bundles only once
- and no matter if you specify shared=yes or shared=no, they should be
built with the same flags (the more efficient and better way of building
dynamically loadable objects on that platform).

I beg you pardon in advance if I missed your point - the mail was quite
short and it wasn't easy to guess what you were meaning. :-)