Re: Test Modules

[John Emmas <johne53 tiscali co uk>]

On 06/03/2013 13:03, Tristan Van Berkom wrote:
> On Wed, 2013-03-06 at 12:41 +0000, John Emmas wrote:
> > Undoubtedly, yes. If you build the binaries with MinGW, then later 
> > change something and rebuild, MinGW does not seem to guarantee that 
> > the second build will use the same ordinal values as your first build 
> > (in each DLL). It's a great recipe for DLL Hell. 
> This is seriously unfortunate, if glib maintainers need to maintain an
> alternate build system to compile glib on win32, that is a serious
> problem (considering we are having a hard time already just to get
> win32 related patches upstreamed in glib/gtk+).
>
> [...]
> As for 1, I think the bigger problem here is really about MinGW, if we
> don't trust the compatibility of the dlls it generates, that's really
> a bug that should be fixed in MinGW.

Yes, I agree entirely Tristan.  MinGW libraries are fine if the 
programmer adopts your recommendation (i.e. to bundle his libraries in 
the same folder as his application) but for building DLLs that are 
supposed to be 'shared' components, MinGW is effectively useless.


> Is '2' really a problem ? I would think that using the earliest ABI
> possible is intentionally done by mingw maintainers, in order to support
> as many variants of win32 as possible, right ?

It's a problem if you want your app to behave the same on everybody's 
system - because the only way to achieve that is to distribute a 
specific runtime version, along with your app.  For the GTK app that I 
work on (Harrison Mixbus) we specifically distribute runtime version 
8.0.50727.6195 (the same version that we test against).  Our application 
will only run against that specific runtime.  As close as is possible, 
this guarantees that if a customer finds a bug, we should be able to 
reproduce it.  The problem is that we can only distribute one runtime 
version, so we need to be sure that all our modules link to that one.  
Our installer (InstallShield) doesn't have the ability to distribute 
multiple runtimes.

John