This documentation is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
The source code refers to the DocBook XML source files. The object code refers to the generated HTML, PostScript, PDF, and other forms.
This documentation is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License (in Appendix A, GNU General Public License) along with this documentation; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Table of Contents
List of Tables
SISCweb is a framework to facilitate writing stateful Scheme web applications in J2EE environments.
Through the use of continuations, SISCweb does away with the page-centric execution model typical of web applications (see [1].) Every time a response is sent to the browser, the program execution flow is suspended, to be then resumed from that exact point when the browser submits a request. Some consequences of this approach are:
SISCweb is open-source software licensed under the MPL, the GPL, and the LGPL.
SISCweb is based on SISC (http://sisc.sourceforge.net/), a Scheme interpreter for the JVM with full continuations, and is heavily influenced by other Lisp web frameworks:
A couple of initial design decisions were also lifted from Matthias Radestock's servlet code in the contrib section of the SISC CVS tree.
Also special thanks to Anton van Straaten, Dominique Boucher, Ben Simon, Dan Muresan, Felix Klock and Tony Garnock-Jones for bug reports, suggestions, and/or work in support of SISCweb.
[1] Christian Queinnec. "Inverting back the inversion of control or, continuations versus page-centric programming". Technical Report 7, LIP6. May 2001. ( http://www-spi.lip6.fr/~queinnec/Papers/www.ps.gz )
Using SISCweb in web applications is simple matter of including
its components in the classpath and making some entries in the
web.xml deployment descriptor.
First-time users may want to check out the example WAR file (siscweb-examples-[v].war). It can be deployed by simply dropping it into the deployment folder of a J2EE appserver, and can also be used as the starting point for developing a new application.
While the server-side REPL is disabled in the SISCweb examples WAR file available from sourceforge.net, if you build it from sources, a REPL will be bound to the localhost:5156 socket. This is a security vulnerability. You should make sure to disable this feature if you are concerned about other people on the same host gaining access to a full-fledged REPL.
SISCweb is divided into different components:
siscweb.jar. The desired components should be
placed in the context's WEB-INF/lib.
The SISC libraries, including the
sisc-heap.jar file, should be also added to
the load path. They are found in the SISC binary distribution.
Starting from SISCweb v0.5, the SISC libraries can be placed in a classpath common to multiple contexts (e.g. in an EAR root or in the application server's path).
The core siscweb.jar instead MUST be placed
in the context's WEB-INF/lib. While
SISCweb's critical data (e.g. the continuation table) is
per-context, the logger and the configuration settings
detailed below are (for now) in the Java static scope.
Beside SISCweb-specific settings, it is also possible to specify SISC parameters.
A Java adapter servlet allows the mapping of context paths to groups of sisclets. Sisclets are simply Scheme procedures associated through the publish mechanism (see Chapter 5, Publishing Procedures) to paths below that of the adapter servlet.
The adapter servlet accepts two parameters,
on-init-sexp and
on-destroy-sexp, which are invoked when the
servlet is initialized and destroyed. As the example below
shows, they are typically used to respectively publish and
unpublish sisclets.
<servlet>
<servlet-name>examples</servlet-name>
<description>siscweb examples</description>
<servlet-class>siscweb.web.SISCAdapterServlet</servlet-class>
<init-param>
<param-name>on-init-sexp</param-name>
<param-value>
<![CDATA[
;; NOTE: scm/ is not generally a good place, since it is browsable
(class-path-extension-append! '("scm/" "WEB-INF/scm/"))
(require-extension (lib siscweb/publish))
(require-extension (lib examples/hello-world))
(publish "/hello/*" 'hello-world)
;; replace round parentheses below with square ones in real life
))>
</param-value>
</init-param>
<init-param>
<param-name>on-destroy-sexp</param-name>
<param-value>
<![CDATA[
(require-extension (lib siscweb/publish))
(unpublish "/hello/*")
;; replace round parentheses with square in real life
))>
</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>examples</servlet-name>
<url-pattern>/sisclets/*</url-pattern>
</servlet-mapping>
SISCweb programs can generate HTTP responses of a variety of data types -- HTML/XML/XHTML represented in SXML notation, images --, or they can forward requests to standard JSPs/Servlet components. Procedures to generate HTTP errors are also available. Other response types can be easily plugged on top of a basic set of response procedures.
The procedures that produce HTTP responses are in the form
send-*/*, with the first pattern indicating
the type of response, and the latter determining whether or not to
save the execution state, and whether or not to clear previously
saved states.
All the procedures accept an optional association list of HTTP
response headers as the first, optional argument. The association
list is in the form ((name value)
...). This can be used to override the default
Content-Type, to set caching options, etc.
SISCweb provides a number of modules with an uniform API to produce HTML, XHTML and XML markup. Their procedures accept documents in SXML syntax, and in the case of HTML and XHTML, a few extra elements and attributes are used to assist with continuation-based programming (see the section called “Extended HTML markup”.)
Requires:
(import siscweb/html)
Requires:
(import siscweb/xhtml)
Located in:
siscweb-sxml.jar
The XHTML and HTML modules serialize SXML differently, with the former producing pure XML, and the latter producing markup tweaked to display properly in known browsers. When producing XHTML for common user agents, it is advisable to keep the HTML Compatibility Guidelines in mind.
Also, while the XHTML module implements the complete SXML
specification, the HTML module is more limited in that only
understands DTD declarations,
*VERBATIM* and
*COMMENT* elements besides the basic
element+attribute syntax. Also, while the XHTML module
considers the *TOP* element functional,
the HTML module silently ignores it.
procedure:
(send-html/suspend [header-alist] (lambda (k-url) <sxml>)) => request
procedure:(send-xhtml/suspend [header-alist] (lambda (k-url) <sxml>)) => request
procedure:
(send-html/forward [header-alist] (lambda (k-url) <sxml>)) => request
procedure:(send-xhtml/forward [header-alist] (lambda (k-url) <sxml>)) => request
Requires:
(import siscweb/xml)
Located in:
siscweb-sxml.jar
This module provides functions to send XML responses with the
same features as those in the HTML and XHTML modules. This
enables clients to conduct a stateful conversation with the
server. The same features available through the extended
(X)HTML can be reproduced in any XML element by using the
store/forward! procedure described in
the section called “Forwarding Requests”.
SISCweb's send-[html/xhtml/xml]/*
procedures accept a slightly extended version of the SXML
syntax.
Numbers in attributes and text nodes are automatically
converted to strings using pretty-print.
The element *VERBATIM* can be used to produce non-escaped text.
attribute:
`(a (@ (bindings ,binding-alist [(anchor name)]...) ...)
attribute:`(form (@ (bindings ,binding-alist) [(anchor name)] ...) ...)
attribute:`(iframe (@ (bindings ,binding-alist) [(anchor name)] ...) ...)
attribute:`(img (@ (bindings ,binding-alist) ...) ...)
attribute:`(link (@ (bindings ,binding-alist) ...) ...)
attribute:`(object (@ (bindings ,binding-alist) [(anchor name)] ...) ...)
attribute:`(script (@ (bindings ,binding-alist) ...) ...)This syntax is only usable from the
*/suspendand*/forwardprocedures. It will produce a link that, when followed, will bind the given bindings to the request object returned by these two functions. Thebinding-alistis in the format specified in Chapter 6, Request Bindings.The optional
anchorattribute allowed by some of the elements is made part of the generated URL.
attribute:
`(a (@ (href-p ,proc) [(bindings ,binding-alist)] [(anchor ,name)] ...) ...)
attribute:`(form (@ (action-p ,proc) [(bindings ,binding-alist)] [(anchor ,name)] ...) ...)
attribute:`(iframe (@ (src-p ,proc) [(bindings ,binding-alist)] [(anchor ,name)] ...) ...)
attribute:`(img (@ (src-p ,proc) [(bindings ,binding-alist)] ...))
attribute:`(link (@ (href-p ,proc) [(bindings ,binding-alist)] ...))
attribute:`(object (@ (data-p ,proc) [(bindings ,binding-alist)] [(anchor ,name) ...) ...)
attribute:`(script (@ (src-p ,proc) [(bindings ,binding-alist)] ...) ...)
attribute:
`(a (@ (href-c ,c-url) [(bindings ,binding-alist)] ...) ...)
attribute:`(form (@ (action-c ,c-url) [(bindings ,binding-alist)] ...) ...)
attribute:`(iframe (@ (src-c ,c-url) [(bindings ,binding-alist)] ...))
attribute:`(img (@ (src-c ,c-url) [(bindings ,binding-alist)] ...))
attribute:`(link (@ (href-c ,c-url) [(bindings ,binding-alist)] ...))
attribute:`(object (@ (data-c ,c-url) [(bindings ,binding-alist)] ...) ...)
attribute:`(script (@ (src-c ,c-url) [(bindings ,binding-alist)] ...) ...)
attribute:
`(a (@ (href-e ,url) ...) ...)
attribute:`(form (@ (action-e ,url) ...) ...)
attribute:`(iframe (@ (src-e ,url) ...))
attribute:`(img (@ (src-e ,url) ...))
attribute:`(link (@ (href-e ,url) ...))
attribute:`(object (@ (data-e ,url) ...) ...)
attribute:`(script (@ (src-e ,url) ...) ...)
attribute:
`(object (@ (type "graphviz") (layout ,layout) (format ,format) ...) (graph (@ (id ,id) ...))The
layoutandformatattributes are analogous to the omonymous parameters to thesend-graphviz/*functions (see the section called “Graphviz Procedures”.) However, the value offormatdetermines how the content is included:
gif, jpg, png: The graph is embedded as animgtag, and a corresponding image map is generated. Links associated to nodes, edges and records will be mapped appropriately. Just as for other document elements, the@href[-[p|c|e]]and@bindingsattributes are available, and behave as described in the section called “Extended HTML markup”.ps, svg, etc.: The graph is embedded as anobjecttag. The appropriate mime type is automatically set, and needs not be specified explicitely.In both cases, any attribute specified for the
objecttag will be applied toward the generatedobjectorimgtag.
(send-html/suspend
(lambda (k-url)
`(html
(head
(title "Embedded Graphviz")
(body
(h3 "Embedded Graphviz")
(object (@ (type "graphviz")
(layout dot) (format png))
(graph (@ (id "G"))
(node (@ (id "c") (label "scissors") (href "http://www.google.com/search?q=scissors")))
(node (@ (id "p") (label "paper") (href "http://www.google.com/search?q=paper")))
(node (@ (id "s") (label "stone") (href "http://www.google.com/search?q=stone")))
(edge (@ (from "c") (to "p") (label "cut") (href-p ,cut)))
(edge (@ (from "p") (to "s") (label "wraps") (href-c "/")))
(edge (@ (from "s") (to "c") (label "breaks") (href-e ,k-url))))))))))
Requires:
(import siscweb/text)
Located in:
siscweb.jar
This module provides functions to send plain text responses.
procedure:
(send-text/suspend [header-alist] (lambda (k-url) <text>)) => request
procedure:(send-text/forward [header-alist] (lambda (k-url) <text>)) => request
procedure:(send-text/back [header-alist] <text>) => does not return
procedure:(send-text/finish [header-alist] <text>) => does not return
Requires:
(import siscweb/forward)
Located in:
siscweb.jar
See the section called “Extracting Bindings from Java” for details on how to access bindings from Java.
procedure:
(send-forward/suspend context-url [bindings]) => requestForwards the current request and suspends. The
context-urlis relative to the context in which the SISCweb application is running. The optionalbindingsparameter is either a <bindings> object or an a-list as specified in Chapter 6, Request Bindings. The continuation URL will be set in thesiscweb.kURLrequest attribute.
procedure:
(forward/store! proc [bindings]) => k-url
procedure:(forward/store! c-url [bindings]) => k-urlwill see them as bindings in its request.In the second form
forward/store!stores a closure that forwards the request to the given context-relativec-url, including any specified bindings, if any.This function is especially useful when passing bindings through the
send-forward/*functions, as it allows to embed links to closures in JSPs and the such, and can thus be used to implement the same style of page navigation afforded by the tags@*-c+@bindingsand@*-c+@bindingsin the extended (X)HTML described in the section called “Extended HTML markup” Notably missing is the equivalent of the plain@bindings.
Requires:
(import siscweb/image)
Located in:
siscweb.jar
This module provides procedures to send images from
java.awt.image.RenderedImage or files.
procedure:
(send-image/finish [header-alist] format java.awt.image.RenderedImage) => does not return
Requires:
(import siscweb/graphviz)
Located in:
siscweb-sxml.jar
This module provides procedures to send graphs in various formats as generated by Graphviz (http://www.graphviz.org). Most of the functions accept a markup representation of DOT, the GraphViz language, in the form of DotML (see the section called “DotML”.)
The GraphViz programs (dot, neato, etc.) should be installed
somewhere in the system path. This is usually the case in
UNIX. Alternatively, it is possible to set the absolute paths to
the GraphViz programs by using the
graphiz/put-layout-command! function.
Graphs can be generated either using the
send-graphviz/* functions, or by embedding
the @type="graphviz" attribute
in the (X)HTML object tag (see the section called “Extended HTML markup”.)
Both send-graphviz/* procedures accept
the same three parameters:
layout: This is a string specifying
which Graphviz layout engine to use. The current choices are
dot, neato, twopi, circo, and fdp.
format: This is a string specifying
the output format. The most useful choices currently are
gif, jpg, 'png, 'ps, and 'svg.
<dotml>: This is an sxml
representation of the DotML language. See the section called “DotML”.
The send-graphviz/* procedures accept a
graph description expressed in DotML. DotML was created by
Martin Loetzsch, and an exhaustive description rich with
excellent examples is at http://www.martin-loetzsch.de/DOTML.
SISCweb does not use code from the DotML project, but it implements the same markup syntax in sxml form. There are a few differences between SISCweb's implementation and the original:
graph,
sub-graph, cluster
and node elements must always specify
an id attribute.
id attribute values at the moment
are limited to strings of alphanumeric characters and
underscore.
record elements must
specify an id attribute, but nested
record and node
elements do not have to.
Requires:
(import siscweb/error)
Located in:
siscweb.jar
HTTP error responses can be generated using two functions, which differ in how the affect the continuation table. Neither function returns. The error codes should abide to the RFC2616 specifications.
Saving the local state means that a for-loop can be written at the language level. (The Polyglot Hello World example included with SISCweb demonstrates this feature.) Saving the stack also means that an entire navigation flow can be represented as a subroutine returning a value, rather than as a sequence of code snippets connected by GOTOs (HREFs) finally depositing a value in the global scope.
A complete treatment of parameters is available in SRFI-39. This section is concerned with the use of the dynamic environment to maintain state shared by all requests for the same user in the same execution flow.
SRFI-39 parameters are essentially dynamically-scoped
variables. They can be defined in the global or the module scope
and then bound to the dynamic scope -- the scope of the
execution flow -- in the application entry point through the
parameterize form.
When using send-*/[suspend|forward], the
parameters, being part of the dynamic environment, are captured
in the suspended state -- the suspension of the program
execution is transparent to parameter bindings.
However procedures stored with
@href-p-style attributes or the
forward/store! procedure will run in the
base dynamic environment, and thus will see fresh values of the
parameters. In those cases on can use
forward/dynenv/store!, which instead
preserves the dynamic environment.
The Counter with SRFI-39 Parameters example demonstrates this technique.
Requires: (import siscweb/webcells)
Web Cells are a way to track program state according to the navigation flow. They are described in full in the paper Interaction-Safe State for the Web.
In essence, cells establish a dynamic scope over the navigation path of a user. Successive pages can overshadow values of bindings set in previous pages, but do not destroy them.
If a user backtracks the browser window, previous values are again visible. If the user clones the window and proceeds through two different navigation branches, each branch sees the values it overshadows.
The Counter with Webcells example demonstrates this technique.
procedure:
(webcell/set! cell value) => undefinedSets the content of the given
cellto the specifiedvalue.Of course the specified value is only accessible to the current and successive request.
Requires:
(import siscweb/session)
Located in:
siscweb.jar
The Session object can be accessed via a syntax similar to that
of SRFI-39
parameters, or via Scheme wrappers around the
Session.get/setAttribute() calls. While the
former is appropriate for storing Scheme values, the latter is
provided as a means to store and retrieve Java objects (or
java-wrapped Scheme values.)
procedure:
(session/make-parameter name) => proc(module security (define auth-token (session/make-parameter "auth-key")) ;; sets an auth token in the session object (define (login usr pwd) (auth-token (make-token usr pwd))))
Procedures can be published to virtual paths of an application server within the hierarchy of a siscweb application. Publishing can be done both interactively at the server-side REPL during development, and in the web.xml file at deployment time. (See the section called “The Adapter Servlet”.)
Requires:
(import siscweb/publish)
Located in:
siscweb.jar
Published procedures accept a single parameter in the form of a request object.
procedure:
(publish/wildcard url-wildcard-pattern (lambda (request) ...)) => undefined
procedure:(publish/wildcard url-wildcard-pattern symbol) => undefined(publish/wildcard "/hello-world/*" (lambda (request) (set! request #f) (send-html/back `(html (head (title "Hello, world!")) (body (p "Hello, world!"))))))
procedure:
(publish/regexp url-regexp-pattern (lambda (request) ...)) => undefined
procedure:(publish/regexp url-regexp-pattern symbol) => undefined
procedure:
(publish url-wildcard-pattern (lambda (request) ...)) => undefined
procedure:(publish url-wildcard-pattern symbol) => undefined
Bindings associated with the request returned by the
send-*/(suspend|forward) functions, or passed
as parameters to procedures that are either published or the
target of a dispatch, can be extracted and associated to
language-level variables.
Bindings, as returned by the function
get-bindings are contained in an opaque
object. This object can be converted to an association list via
bindings->alist, or queried in constant time
using the extract-bindings or
extract-single-binding functions. The object
is guaranteed to be serializable, but code should not rely on its
specific implementation.
Requires:
(import siscweb/bindings)
Located in:
siscweb.jar
This module assists developers in obtaining values of parameters passed in a request.
procedure:
(get-bindings [char-set] request) => bindings
The SQL library performs automatic conversion between scheme and database types. Since the exact conversion table depends on the vendor, a mechanism is provided to add support for other vendors though vendor-specific modules.
Requires:
(import sql/jdbc)
Located in:
siscweb-sql.jar
procedure:
(jdbc/get-connection datasource) => connection(import util/jndi) (jdbc/get-connection (jndi/lookup "java:/comp/env/jdbc/myDS"))
procedure:
(jdbc/open-connection url username password) => connection(jdbc/open-connection "jdbc:hsqldb:file:/tmp/my-db" "sa" "")
procedure:
(jdbc/call-with-connection connection proc) => valueprocedure:(jdbc/call/conn connection procedure) => value(jdbc/call/conn (jdbc/get-connection (jndi/lookup "java:/comp/env/jdbc/myDS")) (lambda (conn) (sql/execute conn "SELECT SYSDATE FROM DUAL")))
procedure:
(jdbc/call-with-transaction connection proc) => value
procedure:(jdbc/call/tran connection procedure) => value(jdbc/call/conn (jdbc/get-connection (jndi/lookup "java:/comp/env/jdbc/myDS")) (lambda (conn) (jdbc/call/tran conn (lambda (conn) (sql/execute-update conn "UPDATE my_table SET my_field = 0")))))
Requires:
(import sql/query)
Located in:
siscweb-sql.jar
This module provides functions to execute queries and map through result sets.
jdbc/call/conn
context, intentional or not, the JDBC ResultSet and Statement
are closed only upon garbage collection. This can be a
particularly insidious problem when using pooled connections,
and will be fixed in the future.
procedure:
(sql/execute connection sql-query [value] ...) => number/resultsetExecutes
sql-querythrough the givenconnection.A number of optional
values can be specified; these will be bound in order to the placeholders in the query. Date, time and timestamps from srfi-19 can be used to bind to SQL DATE, TIME and TIMESTAMP types.Returns the number of rows updated in case of an INSERT/UPDATE/DELETE query statement, and a result set in case of a SELECT statement. Result sets are lazy lists in the sense of srfi-45. Each element of the list is a hashtable
(field-name => value). Multiple result sets are not supported.(sql/execute conn "SELECT * FROM my_table WHERE id = ?" 12345)
Adding support for new vendors is described in the section called “Adding Support for Other Vendors”
Requires:
(import sql/oracle)
Located in:
siscweb-sql.jar
procedure:
(oracle/read-blob blob) => |java.lang.Object|;; returns an alist (id => object) (sql/map-row (sql/execute-query "SELECT id, obj FROM my_table") ((id 'id) (blob 'obj)) `(,id . ,(oracle/read-blob blob)))
Even though SISCweb applies an abstraction layer over characteristics of the HTTP protocol, it is still at times convenient to access the details of requests, responses, sessions and the servlet context in which they live.
For this reason SISCweb provides wrappers around all the methods
of the Request,
Response, Session and
ServletContextobjects. All the procedures
operate on the instances current at the time of invocation.
Requires:
(import siscweb/request)
Located in:
siscweb.jar
This module provides wrappers around the Request object current at the time of invocation.
procedure:
(request/get-parameter name) => string
procedure:
(request/get-parameter-values name) => list
procedure:
(request/get-session [create?]) => javax.servlet.http.HttpSession
Requires:
(import siscweb/response)
Located in:
siscweb.jar
This module provides wrappers around the Response object current at the time of invocation.
procedure:
(response/add-header! name value) => #!void
procedure:
(response/open-output-port) => character-output-port
procedure:
(request/set-content-type! type) => #!void
procedure:
(response/set-header! name value) => #!void
Requires:
(import siscweb/session)
Located in:
siscweb.jar
This module provides wrappers around the Response object current at the time of invocation.
procedure:
(session/make-parameter name) => proc
Requires:
(import siscweb/context)
Located in:
siscweb.jar
This module provides wrappers around the ServletContext object.
procedure:
(context/get uripath) => javax.servlet.ServletContextReturns a ServletContext object that corresponds to a specified URL on the server.
In a security conscious environment, the servlet container may return
for a given URL.
procedure:
(context/get-dispatcher c-url) => proc
procedure:(context/get-named-dispatcher servlet-name) => proc
procedure:
(context/get-resource file-path) => url
procedure:
(context/get-resource-paths) => string
procedure:
(context/make-parameter name) => proc
procedure:
(context/remove-java-attribute! name) => #!void
procedure:
(context/set-java-attribute! name jobject) => #!voidIf listeners are configured on the ServletContext the container notifies them accordingly.
If a
jnullvalue is passed, the effect is the same as callingcontext/remove-java-attribute!.
We protect your rights with two steps:
Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.
Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and modification follow.
You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:
You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.
You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.
If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License.
If the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.
In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.
You may copy and distribute the Program (or a work based on it, under Section 2 in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:
Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,
Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,
Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include 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.
If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.