library using library?

[David Soukal]

Hello,

I have an interesting problem that I'm tackling with. I'm sure there
must be some obvious solution...

I have this big project. It's composed of several *.lib modules. Now,
one of the modules uses IJG JPEG library. But, another module needs to
use *modified* verzion of the library: the application displays images -
for that it uses "normal" jpeg-6b library. However, some functionality
is required that modifies the jpeg files as we need - this is the job of
the other, modified, library.

Now, when I link the application it crashes. After a few hours, we've
found out that it's because the code that should be calling functions
from B.jpeg6b in fact calls A.jpeg6b. The linker didn't even complain.

Now, since the IJG Jpeg-6b is in C not in C++, we cannot use
"namespace"s to seperate these two.

Has anybody met this problem before?

Formally, it could be stated as,

an application must be linked with libraries A, B, both define a
function f(), how do I make sure that the proper function, i.e. A::f or
B::f gets called?

THANKS!

David

[David Soukal]

Hello guys,

the problem can be also viewed as the following (more precisly):

an application must be linked with libraries A.lib and B.lib, both of
the libraries use their version of the JPEG library. I don't need to
expose the jpeg library to the application, so there does not have to be
collision A::f and B::f.

The problem is that when I compile library A and it calls functions from
the JPEG library, the final application that uses A must be linked with
the JPEG library. But the application itself does not care about
functions from the jpeg library, it only cares about functions from A.

Now, here's the problem. A and B use different JPEG libraries so we must
link the application with

A.lib A-jpeg.lib, B.lib, B-jpeg.lib

and that's it. A-jpeg.lib and B-jpeg.lib have the same interface but do
differ.

I would like to have only

A.lib, B.lib

and the internal - no needed - functionality of A-jpeg.lib and
B-jpeg.lib have inside them.

THANKS for comments!

David

[Case]

David Soukal wrote:

Hello,

I have an interesting problem that I'm tackling with. I'm sure there
must be some obvious solution...

I have this big project. It's composed of several *.lib modules. Now,
one of the modules uses IJG JPEG library. But, another module needs to
use *modified* verzion of the library: the application displays images -
for that it uses "normal" jpeg-6b library. However, some functionality
is required that modifies the jpeg files as we need - this is the job of
the other, modified, library.

Now, when I link the application it crashes. After a few hours, we've
found out that it's because the code that should be calling functions
from B.jpeg6b in fact calls A.jpeg6b. The linker didn't even complain.

Now, since the IJG Jpeg-6b is in C not in C++, we cannot use
"namespace"s to seperate these two.

Has anybody met this problem before?

Formally, it could be stated as,

an application must be linked with libraries A, B, both define a
function f(), how do I make sure that the proper function, i.e. A::f or
B::f gets called?

You should look for (binary) tools/utilities to rename the library
routines to Af and Bf. Ask in a programming newsgroup for your specific
platform.

Kees

[David Soukal]

Hi,

but that's not very clean is it? I mean the source code for the A, B
libraries have hundreds of functions... To rename all of them to have
prexif "a" or "b" would be tedious, not mentioning the fact, that you
cannot UPGRADE A and B when a patch comes around...

Thanks,

D.
Case wrote:

David Soukal wrote:

Hello,

I have an interesting problem that I'm tackling with. I'm sure there
must be some obvious solution...

I have this big project. It's composed of several *.lib modules. Now,
one of the modules uses IJG JPEG library. But, another module needs to
use *modified* verzion of the library: the application displays images
- for that it uses "normal" jpeg-6b library. However, some
functionality is required that modifies the jpeg files as we need -
this is the job of the other, modified, library.

Now, when I link the application it crashes. After a few hours, we've
found out that it's because the code that should be calling functions
from B.jpeg6b in fact calls A.jpeg6b. The linker didn't even complain.

Now, since the IJG Jpeg-6b is in C not in C++, we cannot use
"namespace"s to seperate these two.

Has anybody met this problem before?

Formally, it could be stated as,

an application must be linked with libraries A, B, both define a
function f(), how do I make sure that the proper function, i.e. A::f
or B::f gets called?

You should look for (binary) tools/utilities to rename the library
routines to Af and Bf. Ask in a programming newsgroup for your specific
platform.

Kees

[Dan Pop]

In <40**********@bingnews.binghamton.edu> David Soukal <ds******@binghamton.edu> writes:

I have an interesting problem that I'm tackling with. I'm sure there
must be some obvious solution...

I have this big project. It's composed of several *.lib modules. Now,
one of the modules uses IJG JPEG library. But, another module needs to
use *modified* verzion of the library: the application displays images -
for that it uses "normal" jpeg-6b library. However, some functionality
is required that modifies the jpeg files as we need - this is the job of
the other, modified, library.

Now, when I link the application it crashes. After a few hours, we've
found out that it's because the code that should be calling functions
from B.jpeg6b in fact calls A.jpeg6b. The linker didn't even complain.

Now, since the IJG Jpeg-6b is in C not in C++, we cannot use
"namespace"s to seperate these two.

Has anybody met this problem before?

Formally, it could be stated as,

an application must be linked with libraries A, B, both define a
function f(), how do I make sure that the proper function, i.e. A::f or
B::f gets called?

There is no general solution to your problem. On Unix systems, the first
library specified on the linking command always wins. On other systems,
the linker complains about multiply defined symbols.

And the C standard says that you're invoking undefined behaviour...

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Alan Balmer]

On Fri, 14 May 2004 08:34:09 -0400, David Soukal
<ds******@binghamton.edu> wrote:

Hello,

I have an interesting problem that I'm tackling with. I'm sure there
must be some obvious solution...

I have this big project. It's composed of several *.lib modules. Now,
one of the modules uses IJG JPEG library. But, another module needs to
use *modified* verzion of the library: the application displays images -
for that it uses "normal" jpeg-6b library. However, some functionality
is required that modifies the jpeg files as we need - this is the job of
the other, modified, library.

Now, when I link the application it crashes. After a few hours, we've
found out that it's because the code that should be calling functions
from B.jpeg6b in fact calls A.jpeg6b. The linker didn't even complain.

Now, since the IJG Jpeg-6b is in C not in C++, we cannot use
"namespace"s to seperate these two.

Has anybody met this problem before?

Formally, it could be stated as,

an application must be linked with libraries A, B, both define a
function f(), how do I make sure that the proper function, i.e. A::f or
B::f gets called?

THANKS!

David

There's no answer in standard C. You should ask in a forum dedicated
to the platform and tools you're using. You might be able to play some
(risky) games regarding linking order or something.. It doesn't help
after the fact, but namespaces in C are done by using a different
prefix for the external names of different libraries.

--
Al Balmer
Balmer Consulting
re************************@att.net

[David Soukal]

Thank you guys,

this is what I though. Unfortunatelly, I *do* have to use the two
versions of the same library...

It's the IJG's JPEG library, it has dozens of functions, I don't want to
rename them mainly because of that I don't want to tie my hands for next
patches... I though about doing something like

jcmaster.c --> rename to jcmaster.c.old and creat

jcmaster.c as

namespace something {
#include "jcmaster.c.old"
}

and do that for all *.c files. But that's not really C solution and who
knows whether it would even compile on a C++ compiler...

Thanks again!

David

ps. I have no other choice, the first JPEG library is defined in
ImageMagick - I don't want to mess up that, and the other does what I
really need to do, modify some DCTs... something that does not belong to
ImageMagick :-(

pps. This only convinced me that C is really badly designed... :-) No
offense, to C lovers, please! God bless C++ namespaces or better yet
Java's packages... (only teasing)

Alan Balmer wrote:

On Fri, 14 May 2004 08:34:09 -0400, David Soukal
<ds******@binghamton.edu> wrote:

Hello,

I have an interesting problem that I'm tackling with. I'm sure there
must be some obvious solution...

I have this big project. It's composed of several *.lib modules. Now,
one of the modules uses IJG JPEG library. But, another module needs to
use *modified* verzion of the library: the application displays images -
for that it uses "normal" jpeg-6b library. However, some functionality
is required that modifies the jpeg files as we need - this is the job of
the other, modified, library.

Now, when I link the application it crashes. After a few hours, we've
found out that it's because the code that should be calling functions

from B.jpeg6b in fact calls A.jpeg6b. The linker didn't even complain.

Now, since the IJG Jpeg-6b is in C not in C++, we cannot use
"namespace"s to seperate these two.

Has anybody met this problem before?

Formally, it could be stated as,

an application must be linked with libraries A, B, both define a
function f(), how do I make sure that the proper function, i.e. A::f or
B::f gets called?

THANKS!

David

There's no answer in standard C. You should ask in a forum dedicated
to the platform and tools you're using. You might be able to play some
(risky) games regarding linking order or something.. It doesn't help
after the fact, but namespaces in C are done by using a different
prefix for the external names of different libraries.

[David Soukal]

ppps. :-)

On a more general note:

How do I write a (static) library A that uses a version of library C
(call it C1) and then write a library B that uses different version of
the library C (call it C2) *and* link library A, B to my application?

Since A, B use some functions from C1 and C2, I have to link the
application with C1 and C2 also, but there we go again...

At least with Microsoft C++, I cannot "include" C1 into A and C2 into
B... it's simply not possible for static libraries (am I wrong?).

I found this very odd since the application may not even care about
functions in C (C1, C2) so why do I have to link it with them...

Thanks for your thoughts!

David

[Neil Cerutti]

In article <40**********@bingnews.binghamton.edu>, David Soukal
wrote:

Thank you guys,

this is what I though. Unfortunatelly, I *do* have to use the
two versions of the same library...
That sucks.
It's the IJG's JPEG library, it has dozens of functions, I
don't want to rename them mainly because of that I don't want
to tie my hands for next patches... I though about doing
something like

jcmaster.c --> rename to jcmaster.c.old and creat

jcmaster.c as

namespace something {
#include "jcmaster.c.old"
}

and do that for all *.c files. But that's not really C solution
and who knows whether it would even compile on a C++
compiler...

Thanks again!

David

ps. I have no other choice, the first JPEG library is defined
in ImageMagick - I don't want to mess up that, and the other
does what I really need to do, modify some DCTs... something
that does not belong to ImageMagick :-(

pps. This only convinced me that C is really badly designed...
:-) No offense, to C lovers, please! God bless C++ namespaces
or better yet Java's packages... (only teasing)

You need the help of IJG. There might be a solution built
into their headers that they can tell you about, or maybe they
can give you a back-port of the functionality you are missing.

--
Neil Cerutti
"The barbarian seated himself upon a stool at the wenches side, exposing
his body, naked save for a loin cloth brandishing a long steel broad
sword..." --The Eye of Argon

[Dan Pop]

In <40**********@bingnews.binghamton.edu> David Soukal <ds******@binghamton.edu> writes:

On a more general note:

How do I write a (static) library A that uses a version of library C
(call it C1) and then write a library B that uses different version of
the library C (call it C2) *and* link library A, B to my application?

Which part of "undefined behaviour" in my previous post was too
difficult for you to understand?

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Brian Gough]

David Soukal <ds******@binghamton.edu> writes:

Now, when I link the application it crashes. After a few hours, we've
found out that it's because the code that should be calling functions
from B.jpeg6b in fact calls A.jpeg6b. The linker didn't even complain.

Now, since the IJG Jpeg-6b is in C not in C++, we cannot use
"namespace"s to seperate these two.

Has anybody met this problem before?

The jpeg library header files contain a set of macro definitions for
all the external function names, so you can change them in one place
(e.g. to add a version number suffix) and recompile the library.

--
Brian Gough

Network Theory Ltd,
Publishing Free Software Manuals --- http://www.network-theory.co.uk/