This is a cryptographically signed message in MIME format.

--------------ms010602040907000707070602
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit

Hi Roger,

> I suppose you can link against a newer version if desired [1], though
> it's true that the project goes stagnant quite a bit.

If you want to use an unofficial version of gcc 4.x for mingw, then I'd 
go here:

http://tdragon.net/recentgcc/

> I suppose my only concerns with the change are
> 1) are there subtle errors, like you do an ALLOC_N and then the
> library frees it, so you can't control it, resulting in a binary
> incompatibility?

If there are a segmentation fault will occur - so its not subtle.

> 2) Apparently you cannot use structures across different runtimes is
> that right [2]?  I suppose that's not a problem?

No, that is generally not true. VC and Mingw create compatible C binary 
interfaces with one exception that I know of explained here (and there 
is a patch to fix gcc):

http://gcc.gnu.org/bugzilla/show_bug.cgi?id6834
http://www.angelcode.com/dev/callconv/callconv.html

The only time I have run into this is when creating a Ruby extension 
using VC2008 that called into the proj4 library built with MingW (so it 
really didn't have anything to do with Ruby).  I don't know of any 
examples where this is an issue with the Ruby's C api.

  > Binaries would need to be built [re-built] using VC2008 or mingw cross
> compile linked to that dll, is that right?  I think that would bring
> some sanity to the windows environment as currently it's pretty
> fragmented.

Yes, it is possible to go try and go down the path that there is one 
"blessed" compiler on Windows.  But the point of my proposal was to 
avoid that, giving developers the choice to use whatever compiler they want.

> 2) It allows mingw built binaries to interop with VC ones--binaries
> are much faster if built by gcc [1 #5].

That's an invalid comparison for a couple of reasons.  First you would 
compare VC2008 versus gcc 4.3.  Except you can't, because gcc 4.x is not 
officially released for windows so you're stuck with gcc 3.4.5.

> Do the core folks favor VC2008 or any compiler at all?  It appears
> that as long as you link to the same DLL the two are compatible.

I favor not favoring a compiler.

Now, you do bring up an interesting point, which is instead of favoring 
a compiler favor a runtime library (msvcr90 being the obvious choice). 
  In other words, VC2008 will always link against that one and you can 
mingw to link against it also.  The downside is that you exclude VC2003 
or the upcoming VC2010.

My vote is still to try not choosing a compiler.  I certainly think its 
worth a try.  If it doesn't work, we change tactics.

> Another option would be to release a mingw only OCI linked against
> msvcr90.dll, then instruct extension developers on how to release
> binaries that "pretend" to be mingw though they're only "mingw
> compatible."

There is no pretending here.  Those would be mingw binaries linked 
against msvcr90.dll.  That is supported.  I have no idea if it works 
cross-compiling though.

> Or perhaps rubygems could be patched to recognize compatible binaries.

Not sure what you mean.  My goal is that an extension developer only has 
  to release 1 binary for windows per ruby version.

Charlie

--------------ms010602040907000707070602
Content-Type: application/x-pkcs7-signature; name="smime.p7s"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="smime.p7s"
Content-Description: S/MIME Cryptographic Signature
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--------------ms010602040907000707070602--