LLGPL Clarification

[John Foderaro]

>> The
>> prevailing notion of software copyright (in my non-professional
>> understanding) is that object code implicitly carries the copyright of
>> the source code from which it was compiled. 


 But you have to understand that Lisp macros are functions
that operate in an internal form and return objects in an internal
form.  The purpose of a library of functions is to supply useful
functionality.  A macro in a library is there to be used.
The idea that using a macro as it was designed to be used 
is somehow stealing its definition is something I find completly
illogical.  There are an infinite number of illogical things
you can propose and having a license agreement refute each of
these would make for a very long license agreement.


  You keep implying that everything derived from source
is source.

I wrote this macro

    (defun add2 (x y) `(+ ,x ,y))

and you think that the macroexpansion

    (add2 1 2)  to    (+ 1 2)

looks so much like the original source that the lisp system
must have just copied the source code and done a cpp like
textual substition.

What if I wrote the macro like
    
    (defmacro add2 (x y) (list '+ x y))

are you satisfied now that (add2 1 2) to (+ 1 2) is not
recovering source from the original copyrighted code.

If now, how about

   (defmacro add2 (x y) (cons '+ (cons x (cons y nil))))


are we getting far enough away that you're satisifed that using
the add2 macro isn't recovering actual source code?


If you think that this distiction between a lisp macro returning
an internal representation and a lisp macro printing out a 
lisp source and then reading it in is trivial, then I urge you 
to try to write a large lisp program where macros expansions
are always printed and then read in.   It won't be common lisp
for sure and it won't even be a lisp in which you'll find very 
macros very useful.  


>>  Lisp macros generate something that is derived from
>> the source of both the macro definition (macro boilerplate that is part
>> of the Library code) and the macro call (the application code);

 In each of my three definitions of add2 show me the macro boilerplate
to which you refer.  If there is no macro boilerplate do you
believe that the code using that macro is not derived from
the source code of the macro?