There are two separate kinds of derived works you can create from an LGPL-licensed work:
- a combined work that includes/uses the LGPL library (per section 4, "Combined Works")
- a modification of the LGPL library itself (per section 2, "Conveying Modified Versions")
To qualify as a "Combined Work", your changes cannot be "based on" the library, but rather must be a separable component that uses the library as an interface. Consider the definitions from the license (emphasis mine):
An “Application” is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library.
A “Combined Work” is a work produced by combining or linking an Application with the Library.
So, a combined work consists of
- the LGPL-licensed library, and
- another work ("Application") that is not "based on" the library
Visually, we could represent the whole Combined Work as:
[Application] === (uses) ===> [Library]
| |
|-------------Combined Work-------------|
It seems to me (note: not a lawyer) that if a derived work is only a modification of the library itself, it would qualify as being "based on" the library. Therefore, such a work could not be part of a union that satisfies the license's definition of a Combined Work, because its non-Library component is based on the text Library, rather then using an interface provided by the Library. Instead, it would be a modification of the library, and governed by section 2, rather than section 4.
On the other hand, if you modified the library's file to add completely separate code that merely uses the library's interface, that wouldn't seem to be "based on" the library, because the two components (library and your addition) are completely separate (but merely happen to be contained inside the same file). For example:
class OriginalLibrary() {
void someInterface(int foobar) {
return new Sys().doStuff(foobar, 18);
}
}
int main(char** argv, int argc) {
OriginalLibrary mylib = new OriginalLibrary();
printf("I use the library, but I'm not pat of it");
printf(mylib.someInterface(argv[0]));
}
In this case, the int main method is clearly not "based on" the OriginalLibrary class, even if you put them in the same file.
Finally, your work could be both a modification and a combined work. You could first modify the library itself, and then include that modified library inside of a larger combined work.
