Re: GPL and statically linking with non-GPL standard C library

[Alexander R. Pruss]

byron@cc.gatech.edu (Byron A Jeff) wrote in message 
news:<c92gvo$loi@cleon.cc.gatech.edu>...
> In article <f601968d.0405260448.5c463ca5@posting.google.com>,
> Alexander R. Pruss <ap85@georgetown.edu> wrote:
> -Would it make a difference if I used the newly released free Microsoft
> -C compiler and its libs?  
> 
> Nope. Not a part of the standard distribution of Windows and certainly isn't
> a GPL compatible license.

[Can't one argue that it's part of their .NET system which is in
effect an OS?]

Note first that this is a VERY serious problem for Palm development. 
To do a number of things portably, you typically link statically
against a PalmSource-provided glue library which, AFAIK, is not
available under a GPL-compatible license.  Moreover, you typically use
header files from various hardware manufacturers, some of which not
only contain prototypes but also various essential macros.  It seems
that if the clause in the GPL is read in such a way that the stuff
must come with the STANDARD distribution of the OS, then the binaries
of every well-written Palm program licensed under the GPL are
technically in violation of the GPL, including both of the major
projects that I am on the core teams of.

But it seems to me--though I am professionally a philosopher not a
lawyer--that this is isn't the right way to read the OS exception
clause.

Let's look at it carefully: "anything that is normally distributed (in
either source or binary form) with the major components (compiler,
kernel, and so on) of the operating system on which the executable
runs, unless that component itself accompanies the executable."

The exception does NOT merely exempt the stuff that comes with a
standard distribution of the OS.  If it did that, it would be phrased:
"anything that is normally distributed (in either source or binary
form) with the operating system on which the executable runs." 
Rather, it exempts the stuff that comes with THE MAJOR COMPONENTS of
the OS, and it explains what counts as a "major component" by giving
the examples of "compiler" and "kernel".  Thus, rather than seeing the
OS as a monolithic whole, the clause sees the OS as a collection of
components.  Moreover it tacitly acknowledges that the components are
such that they might be distributed separately (otherwise how could
just "that component" accompany the executable?) and presumably also
sold separately.

Thus it seems that in the sense of the GPL, an OS is a collection of
"major" components, each of which can in principle be distributed
separately.  A kernel is one such component and a compiler is another.
 Thus, what Microsoft distributes as "the Windows Operating System"
(or whatever they call it) is actually only a major component of the
OS, or more precisely a collection of major components, but does not
constitute all of the Windows OS because it lacks a compiler.  (Note
that seeing a compiler as a part of the OS is an important insight. 
An "OS" without a compiler is only a part of an OS.)

If this is correct, then at least Microsoft's compiler, and perhaps
Borland's (for why should all the components of an OS come from a
single company---one could run something like Win9X on top of
something like DR-DOS) counts as a "major component of the OS", even
if it is not distributed with the Windows kernel or with the utility
programs that come along with a shrinkwrapped package of "Windows".

The libraries one statically links against are distributed with the
compiler.  The compiler is a major component of the OS (even if sold
or given away separately).  Hence, all is well, it seems.

(Likewise, a glue library which is distributed with the PalmOS SDK is
just fine, as one can argue that the SDK is as much a major component
of the OS as a compiler would be.)

Or so it all seems to me now.

I understand, of course, why this exception is dangerous.  It is, for
one, vague.  Are all compilers exempt?  If so, then the GPL is
useless, because (as someone basically once pointed out on ./) one can
make a custom compiler for a new language, call it MyC, that generates
many megabytes of binaries from a single new primitive called
"LinkMyEvilProprietaryStuff".  Probably one could argue that such a
compiler, unlike a compiler for a standardized language, is not a part
of the OS.


Actually, in case anybody is wondering, I am actually the author of
the GPL code (except for some unproblematic BSD-style licensed parts)
that I am compiling with cl and bcc32 (see palmfontconv.sf.net), so
it's not a problem for me (except maybe in regard to the PalmOS stuff,
but there one can probably argue that at least implicit permission is
given since all the Palm developers do it and I think we're only
borrowing GPL code developed for PalmOS devices).  But the immediate
question is whether I need to grant an explicit exemption to the GPL
to anybody else who might wish to distribute my binaries, or whether
the standard GPL suffices.  Though it would be nice to know in the
future if I had to stop linking with cl and link with a compiler that
optimizes less well (cl is really very good) if I wanted to
incorporate some GPL code by another author.

Alex Pruss