<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'

	#*****************************************************************************
	#
	# eplfaq.php
	#
	# Author: 		Mike Milinkovich
	# Date:			2005-11-07
	#
	# Description: Type your page comments here - these are not sent to the browser
	#
	#
	#****************************************************************************
	
	#
	# Begin: page-specific settings.  Change these. 
	$pageTitle 		= "Eclipse Public License 1.0 (EPL) Frequently Asked Questions";
	$pageKeywords	= "epl, cpl, legal, faq, foundation, eclipse, license, licenses";
	$pageAuthor		= "Mike Milinkovich, Nov. 21, 2005";
	
	# Add page-specific Nav bars here
	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);

	# End: page-specific settings
	#
		
	# Paste your HTML content between the EOHTML markers!	
	$html = <<<EOHTML

	<div id="midcolumn">
		<h1>$pageTitle</h1>
		<p><strong>For informational purposes only.</strong></p>
		<p>This FAQ attempts to provide answers to commonly asked questions
  		related to the <a href="../org/documents/epl-v10.php">Eclipse
  		Public License (EPL)</a>.&nbsp; It is provided for informational purposes
  		only.&nbsp; It is not part of, nor does it modify, amend, or supplement the
  		terms of the EPL.&nbsp; The EPL is a legal agreement that governs the rights
  		granted to material licensed under it, so please read it carefully.&nbsp; If
  		there is any conflict between this FAQ and the EPL, the terms of the EPL shall
  		govern.&nbsp; This FAQ should not be regarded as legal advice.&nbsp; If you
  		need legal advice, you must contact your own lawyer.</p>
  		
		<div class="homeitem3col">
			<h3>Table of Contents</h3>
			<ol>
				<li><a href="#CPLEPL">What is the relationship between the CPL and the EPL?</a></li>
				<li><a href="#WHYEPL">Why was the EPL written?</a></li>
				<li><a href="#EPLDIFFER">Specifically how does the EPL differ from the CPL?</a></li>
				<li><a href="#EPLVERSION">What is the latest version of the EPL</a></li>
				<li><a href="#MEMAPPROVE">Do all Eclipse Foundation members approve of the EPL?</a></li>
				<li><a href="#TRANSITION">How and when will the Eclipse Foundation transition from the 
					CPL to the EPL?</a></li>
				<li><a href="#EPLOSI">Is the EPL approved by the Open Source Initiative (OSI)?</a></li>
				<li><a href="#LICAPP">What is required for OSI license approval?</a></li>
				<li><a href="#BUSADVOS">What are the business advantages of the Open Source model?</a></li>
				<li><a href="#TECHADVOS">What are the technical advantages of the Open Source model?</a></li>
				<li><a href="#PARTIESEPL">How are the parties defined in the EPL?</a></li>
				<li><a href="#ANONCONTR">Can a Contributor remain anonymous?</a></li>
				<li><a href="#RECRIGHTS">What rights do Contributors grant Recipients under EPL?</a></li>
				<li><a href="#USEINANOTHER">Does the EPL allow me to take
    				the Source Code for a Program licensed under it and include all or part of
    				it in another program licensed under the GPL,
    				BSD license or other Open Source license?</a></li>
				<li><a href="#COMPILEWOMOD">Can I take a Program licensed
    				under the EPL, compile it without modification, and commercially license the
    				result?</a></li>
				<li><a href="#SOURCEWOBJ">Do I need to include the source
    				code for such Program with the object code distribution?</a></li>
				<li><a href="#PROPPROD">When I incorporate a portion of a
    				Program licensed under the EPL into my own proprietary product distributed
    				in object code form, can I use a single license for the full product, in
    				other words, covering the portion of the Program plus my own code?</a></li>
				<li><a href="#AGREESTEWARD">The EPL states that it can be
    				changed by the Agreement Steward. Does a Contributor have the choice of
    				redistributing a previously distributed Program under the old or the new
    				version of the EPL?</a></li>
				<li><a href="#MODNODIST">If I modify a Program licensed
    				under the EPL, but never distribute it to anyone else, do I have to make my
    				modifications available to others?</a></li>
				<li><a href="#MODDIST">If I modify a Program licensed
    				under the EPL and distribute the object code of the modified Program for
    				free, must I make the source code available?</a></li>
				<li><a href="#MODULEDIST">If I write a module to add to a
    				Program licensed under the EPL and distribute the object code of the module
    				along with the rest of the Program, must I make the source code to my module
    				available in accordance with the terms of the EPL?</a></li>
				<li><a href="#SRCREDIST">What are my obligations if
    				I copy source code obtained from Eclipse.org and licensed under the Eclipse
    				Public License and include it in my product that I then distribute?</a></li>
				<li><a href="#EPLWARRANTY">Does the EPL offer any
    				warranty with regard to the Program?</a></li>
				<li><a href="#GETANSWER">This document does not have the answer to my
    				question.&nbsp; How can I get my question answered?</a></li>
				<li><a href="#DERIV">Some open source software communities specify what they mean by a 
					&quot;derivative work&quot;. Does the Eclipse Foundation have a position on this?</a></li>
				<li><a href="#LINK">Some free software communities say that linking to their code automatically 
  					means that your program is a derivative work. Is this the position of the Eclipse Foundation?</a></li>
				<li><a href="#EXAMPLE">I&lsquo;m a programmer not a lawyer, can you give me a clear cut example of 
  					when something is or is not a derivative work?</a></li>
  				<li><a href="#USEEPL">I am starting my own open source software project. Does the Eclipse 
  				Foundation 	allow me to use the EPL for my project?</a></li>
  				<li><a href="#CODEGEN">Many Eclipse tools and wizards use code templates which are included
				in the application that is generated.  Is the code generated by these tools
				considered a derivative work that must be licensed under the EPL?</a></li>
				<li><a href="#3RDPARTY">What licenses are acceptable for third-party code redistributed 
				by Eclipse projects?</a></li>
				<li><a href="#OSICOMPLIANT">Is an OSI-compliant license a requirement for all third-party code 
				redistributed by Eclipse projects?</a></li>
				<li><a href="#GPLCOMPATIBLE">Are the Eclipse Public License (EPL) and the General Public License (GPL) 
				compatible?</a></li>	
				<li><a href="#DUALLIC">For dual-licensed projects, which license terms apply?</a></li>								
			</ol>
		</div>
<p>&nbsp;</p>
<h3>Frequently Asked Questions</h3>
</blockquote>
<ol>
  <li><strong><a name="CPLEPL">What is the relationship between IBM&rsquo;s Common Public
    License (CPL) and the newer Eclipse Public License (EPL)?</a></strong><br/>
    </b>The Eclipse codebase was originally distributed under the
    CPL.&nbsp; The EPL was derived from 
    <a href="http://www-128.ibm.com/developerworks/library/os-cpl.html" target="_blank">CPL
    version 1.0</a>.&nbsp; As a result, much of the information provided in the 
    <a href="http://www.ibm.com/developerworks/opensource/library/os-cplfaq/index.html" target="_blank">Common
    Public License (CPL) Frequently Asked Questions</a> document is relevant to the
    EPL, as well.&nbsp; The purpose of this FAQ is to highlight the differences.<br/>
    <br/>
    </li>
  <li><strong><a name="WHYEPL">Why was the EPL written?</a></strong><br/>
    The EPL was written specifically for the <a href="../org/" target="_top">Eclipse
    Foundation</a>.&nbsp; First, it changes the Agreement Steward, formerly IBM
    for the CPL,
    to now be the Eclipse Foundation for the EPL.&nbsp; Second, it addresses concerns
    some Eclipse Foundation members had with how the CPL deals with possible
    patent litigation.<br/>
    <br/>
    </li>
  <li><strong><a name="EPLDIFFER">Specifically how does the EPL differ from the CPL?</a><br/>
    </strong>Section 7 of the CPL contained the following language:<br/>
    <br/>
    <em>&quot;If
    Recipient institutes patent litigation against a Contributor with respect to
    a patent applicable to software (including a cross-claim or counterclaim in
    a lawsuit), then any patent licenses granted by that Contributor to such
    Recipient under this Agreement shall terminate as of the date such
    litigation is filed. In
    addition, if Recipient institutes patent litigation against any entity
    (including a cross-claim or counterclaim in a lawsuit) alleging that the
    Program itself (excluding combinations of the Program with other software or
    hardware) infringes such Recipient&rsquo;s patent(s), then such Recipient&rsquo;s rights
    granted under Section 2(b) shall terminate as of the date such litigation is
    filed.&quot;<br/>
    <br/>
    </em>
    The first sentence was removed in the EPL.&nbsp;
    Many members and prospective members believed that the first sentence was
    overly broad and
    viewed it as an inhibitor to the continued growth of the Eclipse
    eco-system.  The second sentence remains unchanged in the EPL.<br/>
    <br/>
    The current <a href="../org/documents/Eclipse_IP_Policy.pdf">Eclipse
    Foundation Intellectual Property Policy</a>  further clarifies the general
    principles under which the Eclipse Foundation shall accept contributions,
    license contributions, license materials owned by the Eclipse Foundation,
    and manage other intellectual property matters.<br/>
    <br/>
    </li>
  <li><strong><a name="EPLVERSION">What is the latest version of the EPL?</a><br/>
    </strong><a href="../org/documents/epl-v10.html">Version 1.0</a>
    is the latest version of the EPL.&nbsp; It is also the initial version of
    the EPL.<br/>
    <br/>
    </li>
  <li><strong><a name="MEMAPPROVE">Do all Eclipse Foundation members approve of the
    EPL?</a><br/>
    </strong>Yes, the Eclipse Foundation membership approved the new EPL
    unanimously.&nbsp; Future members must agree to abide by the EPL and the
    Intellectual Property Policy as part of joining the Eclipse Foundation and
    signing the <a href="../org/documents/Eclipse%20MEMBERSHIP%20AGMT%202003_11_10%20Final.pdf">Eclipse
    Foundation Membership Agreement</a>.<br/>
    <br/>
    </li>
  <li><strong><a name="TRANSITION">How and when will the Eclipse Foundation transition
    from the CPL to the EPL?</a><br/>
    </strong>For details, see the <a href="cpl2epl/CPL2EPLTransitionPlan.pdf">CPL to EPL Transition Plan</a> (.pdf)
	and the <a href="cpl2epl/cpl2eplfaq.php">CPL to EPL Transition Plan FAQ</a>.<br/>
	<br/>
    </li>
  <li><strong><a name="EPLOSI">Is the EPL approved by the Open Source Initiative (OSI)?</a><br/></strong>
    Yes, the EPL has been approved.&nbsp; Version 1.0 was approved in May
    2004.&nbsp; See the complete <a href="http://opensource.org/licenses/" target="_blank">list
    of OSI-approved licenses</a>.<br/>
    <br/>
    </li>
  <li><strong><a name="LICAPP">What is required for OSI license
    approval?</a><br/></strong>
    A license qualifies for OSI approval if it conforms to the OSI&rsquo;s &quot;Open
    Source Definition&quot; or &quot;OSD.&quot; The OSD covers nine topics of
    concern. Chief among these is the requirement that a license not restrict
    any party from selling or giving away the software. Further, the Program
    must include source code, must allow distribution in source code as well as
    compiled form, and must allow modifications and derived works. Find more
    information on the <a href="http://www.opensource.org/docs/definition.php" target="_blank">OSD</a>
    at opensource.org.<br/>
    <br/>
    </li>
  <li><strong><a name="BUSADVOS">What are the business advantages
    of the Open Source model?<br/></strong>
    </a>An Open Source community provides a way for individuals and
    companies to collaborate on projects that would be difficult to achieve on their own..<br/>
    <br/>
    </li>
  <li><strong><a name="TECHADVOS">What are the technical
    advantages of the Open Source model?</strong></a><br/>
    The Open Source model has the technical advantage of turning users into
    potential co-developers. With source code readily available, users will help
    you debug quickly and promote rapid code enhancements. &quot;Given a bit of
    encouragement, your users will diagnose problems, suggest fixes, and help
    improve the code far more quickly than you could unaided.&quot; (The
    Cathedral and the Bazaar, Eric Steven Raymond. See <a href="http://tuxedo.org/~esr/writings/cathedral-bazaar/" target="_blank">http://tuxedo.org/~esr/writings/cathedral-bazaar/</a>)<br/>
    <br/>
    </li>
  <li><strong><a name="PARTIESEPL">How are the parties defined in
    the EPL?</strong></a><br/>
    There are two types of parties to the EPL. They are &quot;Contributors&quot;
    and &quot;Recipients.&quot; Contributors include an initial Contributor, who
    is the person or entity that creates the initial code distributed under the EPL,
    and subsequent Contributors, who originate changes or additions to the code
    (the combination referred to as the &quot;Program&quot;). Any person or
    entity that redistributes the Program is also a Contributor. Recipients
    include anyone who receives the Program under the EPL, including
    Contributors.<br/>
    <br/>
    </li>
  <li><strong><a name="ANONCONTR">Can a Contributor remain anonymous?</strong></a><br/>
    No. Except for those who simply redistribute the Program, each Contributor
    must identify itself as the originator of its Contribution in a way that
    later Recipients will be able to readily see.<br/>
    <br/>
    </li>
  <li><strong><a name="RECRIGHTS">What rights do Contributors grant Recipients under EPL?</strong></a><br/>
    Contributors license Recipients under the rights that they have in their
    Contributions.<br/>
    <br/>
    </li>
  <li><strong><a name="USEINANOTHER">Does the EPL allow me to take
    the Source Code for a Program licensed under it and include all or part of
    it in another program licensed under the GNU General Public License (GPL),
    Berkeley Software Distribution (BSD) license or other Open Source license?</strong></a><br/>
    No. Only the owner of software can decide whether and how to license it to
    others. Contributors to a Program licensed under the EPL understand that
    source code for the Program will be made available under the terms of the EPL.
    Unless you are the owner of the software or have received permission from
    the owner, you are not authorized to apply the terms of another license to
    the Program by including it in a program licensed under another Open Source
    license.<br/>
    <br/>
    </li>
  <li><strong><a name="COMPILEWOMOD">Can I take a Program licensed
    under the EPL, compile it without modification, and commercially license the
    result?</strong></a><br/>
    Yes. You may compile a Program licensed under the EPL without modification
    and commercially license the result in accordance with the terms of the EPL.<br/>
    <br/>
    </li>
  <li><strong><a name="SOURCEWOBJ">Do I need to include the source
    code for such Program with the object code distribution?</strong></a><br/>
    No. But you do need to include a statement that the source code is available
    from you and information on how to obtain it.<br/>
    <br/>
    </font></li>
  <li><strong><a name="PROPPROD">When I incorporate a portion of a
    Program licensed under the EPL into my own proprietary product distributed
    in object code form, can I use a single license for the full product, in
    other words, covering the portion of the Program plus my own code?</strong></a><br/>
    Yes. The object code for the product may be distributed under a single
    license as long as it references the EPL portion and complies, for that
    portion, with the terms of the EPL.<br/>
    <br/>
    </li>
  <li><strong><a name="AGREESTEWARD">The EPL states that it can be
    changed by the Agreement Steward. Does a Contributor have the choice of
    redistributing a previously distributed Program under the old or the new
    version of the EPL?</strong></a><br/>
    While Contributions are licensed under the version of the License under
    which they are originally distributed, the EPL provides for the ability of
    any Contributor to choose between that version or a later version.<br/>
    <br/>
    </li>
  <li><strong><a name="MODNODIST">If I modify a Program licensed
    under the EPL, but never distribute it to anyone else, do I have to make my
    modifications available to others?</strong></a><br/>
    No. If you do not distribute the modified Program, you do not have to make
    your modifications available to others.<br/>
    <br/>
    </li>
  <li><strong><a name="MODDIST">If I modify a Program licensed
    under the EPL and distribute the object code of the modified Program for
    free, must I make the source code available?</strong></a><br/>
    Yes. By distributing the modified Program, even if it is only a free version
    of the object code, you are obligated to make the source code to the
    modified Program available to others.<br/>
    <br/>
    </li>
  <li><strong><a name="MODULEDIST">If I write a module to add to a
    Program licensed under the EPL and distribute the object code of the module
    along with the rest of the Program, must I make the source code to my module
    available in accordance with the terms of the EPL?</strong></a><br/>
    No, as long as the module is not a derivative work of the Program.<br/>
    <br/>
    </li>
  <li><strong><a name="SRCREDIST">What are my obligations if
    I copy source code obtained from Eclipse.org and licensed under the Eclipse
    Public License and include it in my product that I then distribute?</a></strong><br/>
    Source code licensed under the EPL may only be
    redistributed under the EPL.<br/>
    <br/>
  	</li>
  <li><strong><a name="EPLWARRANTY">Does the EPL offer any
    warranty with regard to the Program?</strong></a><br/>
    No. The Program released under the EPL is provided on an &quot;as is&quot;
    basis, without warranties or conditions of any kind.<br/>
    <br/>
    </li>
  <li><strong><a name="GETANSWER">This document does not have the answer to my
    question.&nbsp; How can I get my question answered?</a><br/>
    </strong>
    You may want to check the <a href="legalfaq.php">Eclipse
    Foundation Legal Frequently Asked Questions </a>document to see if your
    question is answered there.&nbsp; If not, please send a note to the
	<a href="mailto:license@eclipse.org">Eclipse Management Office</a> and we will do our best 
	to get back to you.<br/>
	<br/>
	</li>
  <li><strong><a name="DERIV">Some open source software communities specify what they mean by a 
	&quot;derivative work&quot;. Does the Eclipse Foundation have a position on this?</a><br/></strong>
    As described in article 1(b)(ii) of the Eclipse Public License, &quot;...Contributions do not 
    include additions to the Program which: (i) are separate modules of software distributed in 
    conjunction with the Program under their own license agreement, and (ii) are not derivative 
    works of the Program.&quot; The definition of derivative work varies under the copyright laws of 
    different jurisdictions. The Eclipse Public License is governed under U.S. law. Under the U.S. 
    Copyright Act, a &quot;derivative work&quot; is defined as <em>&quot;...a work based upon one or 
    more preexisting works, such as a translation, musical arrangement, dramatization, fictionalization, 
    motion picture version, sound recording, art reproduction, abridgment, condensation, or any other 
    form in which a work may be recast, transformed, or adapted. A work consisting of editorial revisions, 
    annotations, elaborations, or other modifications which, as a whole, represent an original work of 
    authorship, is a &quot;derivative work&quot;.&quot;</em> The Eclipse Foundation interprets the term 
    &quot;derivative work&quot; in a way that is consistent with the definition in the U.S. Copyright Act, 
    as applicable to computer software. You will need to seek the advice of your own legal counsel in 
    deciding whether your program constitutes a derivative work. <br/>
	<br/>
	</li>
  <li><strong><a name="LINK">Some free software communities say that linking to their code automatically 
  	means that your program is a derivative work. Is this the position of the Eclipse Foundation?</a><br/></strong>
    No, the Eclipse Foundation interprets the term &quot;derivative work&quot; in a way that is consistent 
    with the definition in the U.S. Copyright Act, as applicable to computer software. Therefore, 
    linking to Eclipse code might or might not create a derivative work, depending on all of the other 
    facts and circumstances. <br/>   
	<br/>
	</li>
  <li><strong><a name="EXAMPLE">I&lsquo;m a programmer not a lawyer, can you give me a clear cut example of 
  		when something is or is not a derivative work?</a><br/></strong>
    If you have made a copy of existing Eclipse code and made a few minor revisions to it, that is a 
    derivative work. If you&quot;ve written your own Eclipse plug-in with 100% your own code to implement 
    functionality not currently in Eclipse, then it is not a derivative work. Scenarios between those two 
    extremes will require you to seek the advice of your own legal counsel in deciding whether your program 
    constitutes a derivative work.<br/><br/>
    For clarity, merely interfacing or interoperating with Eclipse plug-in APIs (without modification) does 
    not make an Eclipse plug-in a derivative work.<br/>
	<br/>
	</li>
  <li><strong><a name="USEEPL">I am starting my own open source software project. Does the Eclipse 
	Foundation 	allow me to use the EPL for my project?</a><br/></strong>
	Yes. The EPL is an OSI-approved open source license and may be used unaltered by projects regardless of 
	where they are hosted.<br/>
	<br/>
	</li>
  <li><strong><a name="CODEGEN">Many Eclipse tools and wizards use code templates which are included
	in the application that is generated.  Is the code generated by these tools
	considered a derivative work that must be licensed under the EPL?</a><br/></strong>
	Unfortunately, there is no clear answer to this question. To the
	extent that the code generated by a wizard is purely functional in nature and
	therefore not the proper subject matter for copyright protection, it could be
	argued that it is not subject to copyright protection, and therefore is not a
	derivative work.  An example of that type of code would include calls to APIs
	or other technical instructions which are dictated by functional or technical
	requirements.  Moreover, to the extent the generated code is a very small part
	of the final overall work, there is an argument that such use would be di
	minimus, and the final product or application should not be considered to be a
	derivative work. Finally, to the extent developers who use the generated code
	make many changes and additions to the code, there is also an argument that the
	resultant application is not a derivative work.  Of course, these are just
	arguments and not "bright line" tests,  and therefore each position could be
	subject to differing viewpoints. Eclipse cannot take a position on this issue,
	as it will ultimately be a question of the facts and circumstances associated
	with a particular use.<br/>
	<br/>
	</li>
	<li><strong><a name="3RDPARTY">What licenses are acceptable for third-party code redistributed 
	by Eclipse projects?</a><br/></strong>
	Eclipse views license compatibility through the lens of enabling successful commercial adoption 
	of Eclipse technology in software products and services. We wish to create a commercial ecosystem 
	based on the redistribution of Eclipse software technologies in commercially licensed software 
	products. Determining whether a license for third-party code is acceptable often requires the 
	input and advice of Eclipse&rsquo;s legal advisors. If you have any questions, please contact 
	<a href="mailto:license@eclipse.org">license@eclipse.org</a>.<br/><br/>
	The current list of licenses approved for use by third-party code redistributed by Eclipse projects is:
		<ul>
	    <li>Apache Software License 1.1 </li>
	    <li>Apache Software License 2.0 </li>
	    <li>W3C Software License </li>
	    <li>Common Public License Version 1.0 </li>
	    <li>IBM Public License 1.0 </li>
	    <li>Mozilla Public License Version 1.1</li>
	    <li>Common Development and Distribution License (CDDL) Version 1.0</li>
	    <li>GNU Free Documentation License Version 1.3</li>
	    <li>BSD</li>
	    <li>MIT</li></ul>
	Licenses that are not approved for use include:
		<ul>
	    <li>GNU GPL 2.0</li>
	    <li>GNU LGPL</li>
	    <li>Sun Binary Code License Agreement</li></ul>
	</li>
	<li><strong><a name="OSICOMPLIANT">Is an OSI-compliant license a requirement for all third-party code 
	redistributed by Eclipse projects?</a><br/></strong>
	Eclipse fully supports the Open Source Initiative&rsquo;s certification of open source licenses, 
	and the Eclipse Public License is certified as such. However, there are licenses for software 
	content which meet Eclipse&rsquo;s requirements for compatibility with the EPL and downstream 
	commercial re-distribution that are not OSI certified, and Eclipse projects may make use of such 
	licenses after review and approval by the Eclipse Foundation.<br/><br/> 
	The reverse is also true: there are	OSI-compliant licenses are not compatible with the EPL or do 
	not permit downstream commercial re-distribution. Such licenses are not used by Eclipse projects.<br/><br/>
	</li>
	<li><strong><a name="GPLCOMPATIBLE">Are the Eclipse Public License (EPL) and the General Public License (GPL) compatible?</a><br/></strong>
	The EPL and the GPL are not compatible in any combination where the result would be  considered either: 
	(a) a &quot;derivative work&quot;  (which Eclipse interprets  consistent with the definition of that term in the 
	U.S. Copyright Act )  or (b) a work &quot;based on&quot; the GPL code, as that phrase is used in the 
	<a href="http://www.gnu.org/licenses/old-licenses/gpl-2.0.html">GPLv2</a>, 
	<a href="http://www.fsf.org/licensing/licenses/gpl.html">GPLv3</a> 
	or the <a href="http://www.fsf.org/licensing/licenses/gpl-faq.html">GPL FAQ</a> as applicable. 
	Further, you may not combine EPL and GPL code in any scenario where source 
	code under those licenses are both the same source code module.<br/><br/>
	Based upon the <a href="http://www.fsf.org/licensing/licenses/">position</a> 
	of the Free Software Foundation, you may not combine EPL and GPL code in any 
	scenario where linking exists between code made available under those licenses. The above applies to 
	both GPL version 2 and GPL version 3. 
	</li>
	<li><strong><a name="DUALLIC">For Eclipse projects which are dual-licensed, your file headers state that 
	the code is being made available under two licenses. For example: "This program and the accompanying materials 
	are made available under the terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
	which accompanies this distribution." What is meant by the use of the conjunction "and"?</a><br/></strong>
	The code is being made available under both of the licenses. The consumer of the code can select which 
	license terms they wish to use, modify and/or further distribute the code under.
	</li>
</ol>
	</div>
	<!-- remove the entire <div> tag to omit the right column!  -->
	<div id="rightcolumn">
		<div class="sideitem">
			<h6>Related Links</h6>
			<ul>
				<li><a href="../org/documents/epl-v10.php">Eclipse Public License</a></li>
				<li><a href="http://www-128.ibm.com/developerworks/library/os-cpl.html" target="_blank">Common Public License</a></li>
				<li><a href="legalfaq.php">Eclipse Legal FAQ</a></li>
				<li><a href="epl/notice.php">Eclipse Software Use Agreement</a></li>
			</ul>
		</div>
	</div>

EOHTML;


	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>
