<?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'

	#*****************************************************************************
	#
	# sample_3col.php
	#
	# Author: 		Denis Roy
	# 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 Foundation Legal Frequently Asked Questions (FAQ)";
	$pageKeywords	= "legal, faq, foundation";
	$pageAuthor		= "Mike Milinkovich, Nov. 22, 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><a name="top"></a>$pageTitle</h1>
		
			<p>The following FAQ answers questions about &quot;legal stuff&quot; at the Eclipse Foundation.  Questions answered in this FAQ cover such topics as:</p>
			<blockquote>
			<ul>
				<li>licensing of materials made available by the Eclipse Foundation</li>
				<li>contributions submitted to the Eclipse Foundation</li>
				<li>working as a committer on Eclipse projects</li>
				<li>cryptography in software made available by the Eclipse Foundation</li>
			</ul>
			</blockquote>
			
			<p>If you intend to use, modify, and/or redistribute materials made available by the Eclipse Foundation, you may find this FAQ useful.</p>
			
			<p>Prior to 2004, the Eclipse community used the Common Public License as the open source license for the 
			vast majority of the open source software distributed by Eclipse.org. With the creation of the independent 
			Eclipse Foundation in 2004, the community began the migration to the Eclipse Public License, which is now the 
			predominant license used at Eclipse. All projects at Eclipse now use the Eclipse Public License.</p>
			
			<p>Unless otherwise specified, any reference in this FAQ to the CPL refers to the 
			<a href="http://www-128.ibm.com/developerworks/library/os-cpl.html" target="_blank">Common Public License Version 1.0</a>
			and any reference to the EPL refers to the <a href="../org/documents/epl-v10.php">Eclipse 
			Public License Version 1.0</a>.
			This FAQ does not answer legal questions such as &quot;what is a derivative work?&quot; 
			or &quot;what is a separate module?&quot;  For answers to those and other general
			legal questions, you should consult your lawyer.  This FAQ does not answer specific questions 
			about the CPL or EPL.  For CPL-specific questions, you should
			read the <a href="http://www.ibm.com/developerworks/opensource/library/os-cplfaq/index.html" target="_blank">CPL 
			Frequently Asked Questions</a> document that was written by
			IBM and is hosted at IBM&rsquo;s developerWorks site.  For EPL-specific questions, you should read 
			the <a href="eplfaq.php">EPL Frequently Asked Questions</a>.</p>
			
			<p>This FAQ is provided for informational purposes only.  It is not part of, nor does it modify, 
			amend, or supplement the terms of the CPL, the EPL, 
			or any other legal agreement.  If there is any conflict between this FAQ and 
			a legal agreement discussed herein, the terms of the discussed legal agreement shall govern.
			This FAQ should not be regarded as legal advice. If you need legal advice, you must 
			contact your own lawyer.</p>
			
			<p>If you have a question that you would like to see answered in this FAQ, 
			please send e-mail to the <a href="mailto:license@eclipse.org">Eclipse Management Organization</a>.</p>
			<p>This FAQ was last updated on October 1, 2010.</p>

		<div class="homeitem3col">
			<h3>Table of Contents</h3>
			<ul>
				<li><strong><a href="#use">Use and Redistribution of Content</a></strong>
					<ol>
						<li><a href="#use_1">What is the Eclipse Foundation Software User Agreement?</a></li>
						<li><a href="#use_2">Why are there other notices referenced in the Eclipse Foundation Software User Agreement?</a></li>
						<li><a href="#use_3">What is the Eclipse Public License?</a></li>
						<li><a href="#use_4">Why is the Eclipse Public License used to license most of the content made available by the Eclipse Foundation?</a></li>
						<li><a href="#use_5">What other licenses (besides the Eclipse Public License) may be used by the Eclipse Foundation?</a></li>
						<li><a href="#use_6">Why does the Eclipse Foundation redistribute some content under licenses other than the Eclipse Public License?</a></li>
						<li><a href="#use_7">When I start Eclipse I see copyright notices from IBM and/or other companies.  How can it be open source software if it is copyright IBM?</a></li>
						<li><a href="#use_8">Which version of the Eclipse Public License does the Eclipse Foundation use?</a></li>
						<li><a href="#use_9">What is the Eclipse Foundation Update Manager Agreement?</a></li>
						<li><a href="#use_10">Does the Eclipse Foundation have a patent policy?</a></li>
						<li><a href="#use_11">The legal notices contained in the downloads make reference to Eclipse.org or the Eclipse Foundation as the distributor of the content.  Do I have to change these notices if I simply redistribute the content without modification?</a></li>
						<li><a href="#use_12">May I please have a quote or see a pricelist for Eclipse software?</a></li>
					</ol></li>
					
				<li><strong><a href="#contributions">Contributions and Participation</a></strong>
					<ol>
						<li><a href="#contributions_1">What agreement covers contributions I submit to an Eclipse Foundation project?</a></li>
						<li><a href="#contributions_2">Will Eclipse Foundation projects accept contributions to content that were not provided 
								under the Eclipse Public License?</a></li>
						<li><a href="#contributions_3">Do I have to place copyright notices in all my code?</a></li>
						<li><a href="#contributions_4">What if I have legal questions about my contribution to the Eclipse Foundation?</a></li>						
					</ol></li>

				<li><strong><a href="#committer">Working as a Committer</a></strong>
					<ol>
						<li><a href="#committer_1">What are my obligations as a committer working on an Eclipse Foundation project?</a></li>
						<li><a href="#committer_2">What is the due diligence that a committer must perform?</a></li>
						<li><a href="#committer_3">What if I have legal questions when I am performing due diligence as a committer?</a></li>	
						<li><a href="#committer_4">If I change employers, what happens to my committer status at Eclipse?</a></li>						
					</ol></li>
					
				<li><strong><a href="#cryptography">Cryptography</a></strong></li>
					<ol>
						<li><a href="#cryptography_1">Does software made available by the Eclipse Foundation contain cryptography?</a></li>
						<li><a href="#cryptography_2">Why is cryptography discussed in the Eclipse Foundation Software User Agreement?</a></li>
						<li><a href="#cryptography_3">Why is cryptography sometimes discussed in the Abouts or other notices?</a></li>
					</ol></li>
			</ul>
			</div>
			<small><a href="#top">go to top</a><a name="use"></a></small>
			<p>&nbsp;</p>
		<h3>Use and Redistribution of Content</h3>
				<ol>
			<li><strong><a name="use_1"></a>What is the Eclipse Foundation Software User Agreement?</strong><br>
			    <br>
				<p>The <a href="epl/notice.php">Eclipse Foundation Software User Agreement</a> is an umbrella agreement that covers the use and distribution of
				materials made available by Eclipse.</p>
				
				<p>The Eclipse Foundation Software User Agreement itself does not provide any usage or redistribution rights but instead references the EPL and other notices defined in the
				Eclipse Foundation Software User Agreement as Abouts, Feature Licenses, and Feature Update Licenses.  It is these files that grant you rights to the related content.</p>

			    <hr size="1">
			    <br>
			</li>
			<li><strong><a name="use_2"></a>Why are there other notices referenced in the Eclipse Foundation Software User Agreement?</strong><br>
			    <br>
				<p>The <a href="epl/notice.php">Eclipse Foundation Software User Agreement</a> defines Abouts, Feature Licenses, and
				Feature Update Licenses.  Some or all of these notices may be present in content made available by the Eclipse Foundation.  
				This framework of other notices is used	for a number of reasons:</p>
					
				<ul>
					<li>Content made available by the Eclipse Foundation is constantly changing as that is the nature of open source development.  
					These other notices allow licenses and other
					legal information to be changed as the content changes, without having to constantly revise the Software User Agreement.  
					Think of them as plug-ins to the Software User Agreement.</li>
				
					<li>Sometimes content obtained from Eclipse Foundation may contain portions that are made available under other licenses.  These other notices may be used to specifically
					address the licensing (and other issues) related to portions of content.</li>
				
					<li>Although Eclipse Foundation cannot and does not attempt to control how other people structure their licenses and other legal notices, they may choose to use the same
					conventions if their content is based on software obtained from Eclipse Foundation.  Since much of the software made available by the Eclipse Foundation is designed to be extendible
					or to extend software such as Eclipse Platform, legal notices from multiple sources may be able to co-exist in a consistent manner.</li>
				
					<li>Although the Eclipse Foundation makes software available as downloads, you can usually obtain all or some of the software by accessing the Eclipse Foundation source code repository.  These
					other notices are used to ensure that licenses and other important information are available no matter how the software is obtained.</li>
				</ul>
				
				<hr size="1">
			    <br>
			</li>
			<li><strong><a name="use_3"></a>What is the Eclipse Public License?</strong><br>
			    <br>
				<p>The <a href="../org/documents/epl-v10.php">Eclipse Public License (EPL)</a> is an open source license based largely on the Common Public License written by IBM and approved by the
				<a href="http://www.opensource.org/licenses/" target="_blank">Open Source Initiative</a>.  The CPL was used to license 
				almost all of the content made available by Eclipse.org prior to the creation of the Eclipse Foundation in 2004, and for a 
				transition period thereafter. The Eclipse Foundation has now transitioned to the EPL.</p>
				<p>This FAQ does not discuss either the CPL or the EPL themselves although it may discuss Eclipse.org&rsquo;s use of the CPL and the EPL. 
				IBM has written a
				<a href="http://www.ibm.com/developerworks/library/os-cplfaq.html" target="_blank">CPL FAQ</a> that is hosted at their developerWorks site.
				For further information about the EPL see the <a href="eplfaq.php">EPL Frequently Asked Questions</a>.</p>
				<hr size="1">
			    <br>
			</li>
			<li><strong><a name="use_4"></a>Why is the Eclipse Public License used to license most of the content made available by the Eclipse Foundation?</strong><br>
			    <br>
				<p>The terms and conditions of the EPL were found to be most appropriate for the Eclipse Foundation.  Software 
				made available by the Eclipse Foundation is used by developers who
				want to freely plug into and extend or alter the content.  The EPL goes to great lengths to support 
				and encourage the collaborative open source development of the
				content, while maximizing the ability to use and/or integrate the content with software 
				licensed under other licenses, including many commercial
				licenses.  Since the Eclipse Foundation seeks to encourage developers of both open source and 
				proprietary development tools to embrace the content, this
				flexibility is critical.</p>
				<hr size="1">
			    <br>
			</li>
			<li><strong><a name="use_5"></a>What other licenses (besides the Eclipse Public License) may be used by the Eclipse Foundation?</strong><br>
			    <br>
				<p>Content redistributed by the Eclipse Foundation either unmodified or as a derivative work may be made available under such licenses as the
				<a href="http://xml.apache.org/LICENSE" target="_blank">Apache Software License 1.1</a>, and the
				<a href="http://oss.software.ibm.com/developerworks/opensource/license10.html" target="_blank">IBM Public License 1.0</a>.  The complete list of other licenses
				varies with each project and the specific content and is subject to change.</p>
				<hr size="1">
			    <br>
			</li>
			<li><strong><a name="use_6"></a>Why does the Eclipse Foundation redistribute some content under licenses other than the Eclipse Public License?</strong><br>
			    <br>
				<p>Sometimes the Project Management Committee (&quot;PMC&quot;) for an Eclipse Foundation project may make a decision to include some content from another
				open source project.  If that content cannot be contributed to an Eclipse Foundation project under the <a href="termsofuse.php">Eclipse.org Terms of Use</a>
				and the content is not already licensed under the CPL and/or EPL, the PMC may decide to use and redistribute the content under the terms and conditions of another license
				which would usually be the license that the content was received under.  The Eclipse Foundation will only use non-CPL and/or non-EPL licensed content if the other license
				is an open source license approved by the <a href="http://www.opensource.org/licenses/" target="_blank">Open Source Initiative</a> and it permits
				commercial products to be built on the software without requiring any form of royalty or other payment.</p>
				
				<p>In some cases the Eclipse Foundation redistributes unmodified non-CPL and non-EPL content and in other cases it redistributes derivative works of non-CPL and non-EPL content.
				Unmodified non-CPL and non-EPL content is included as a convenience to allow Eclipse Foundation software to be used without first having to locate, obtain, and
				integrate additional software.</p>
				<hr size="1">
			    <br>
			</li>
			<li><strong><a name="use_7"></a>When I start Eclipse I see copyright notices from IBM and/or other companies.  How can it be open source software if it is copyright IBM?</strong><br>
			    <br>
				<p>You might want to do some background reading on copyright law or consult a lawyer.  &quot;Open source&quot; doesn&rsquo;t mean that the code does not have a copyright holder.
				All code has an author and that person is the copyright holder or owner unless the copyright is assigned to another party.  In the case of the Eclipse Project,
				the initial code base was contributed by IBM.  Over time, Eclipse Foundation projects have become populated with code provided by many different contributors and as result,
				different portions of the code have different copyright holders.  Licenses such as the CPL and EPL grant you a copyright license
				(subject to certain terms and conditions) and that is how you receive copyright rights to use, modify, redistribute, etc. the content.
				Although you may receive copyright rights through the CPL, EPL, or another license, it still doesn&rsquo;t change who the copyright holders are for various portions of
				the content.</p>
				<hr size="1">
			    <br>
			</li>			
			<li><strong><a name="use_8"></a>Which version of the Eclipse Public License does the Eclipse Foundation use?</strong><br>
			    <br>
				<p>The current version is <a href="../org/documents/epl-v10.php">Version 1.0</a>.</p>
				<p>Eclipse.org previously used the 
				<a href="http://www.ibm.com/developerworks/library/os-cplfaq.html" target="_blank">Common Public License</a>.  The two license are compatible.  See IBM&rsquo;s
				<a href="http://www.ibm.com/developerworks/library/os-cplfaq.html" target="_blank">Common Public License (CPL) Frequently Asked Questions</a> for more information about
				versions of the CPL.</p>
				<hr size="1">
			    <br>
			</li>			
			<li><strong><a name="use_9"></a>What is the Eclipse Foundation Update Manager Agreement?</strong><br>
			    <br>
				<p>The <a href="updatemanager.php">Eclipse Foundation Update Manager Agreement</a> was written to ensure that parties making software
				available on an Internet site for subsequent download and installation by the Eclipse Update Manager, are fully aware of the technical process used by
				the Update Manager and that they grant all legal rights necessary to facilitate the process.</p>
				<hr size="1">
			    <br>
			</li>
			<li><strong><a name="use_10"></a>Does the Eclipse Foundation have a patent policy?</strong><br>
			    <br>
				<p>Under the EPL, each Contributor grants rights to create derivative works and for worldwide, royalty-free
				software redistribution in accordance with the EPL terms, including a royalty-free license to use
				Contributor&rsquo;s patents as embodied in its contributions. Section 7 of the EPL includes the following:</p>

				<blockquote>
					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.
				</blockquote>
				<hr size="1">
			    <br>
			</li>
			<li><strong><a name="use_11"></a>The legal notices contained in the downloads make reference to Eclipse.org or the Eclipse Foundation as the distributor of the content.  Do I have to change these notices if I simply redistribute the content without modification?</strong><br>
			    <br>
				<p>If you do not make any modifications to the content covered by any legal notices then you may leave the legal notices intact.  Two cases where this commonly occurs
				is when Eclipse Foundation content is redistributed on a <a href="http://www.eclipse.org/downloads/download.php?file=/">mirror site</a> or on a CD distributed with a
				publication or at a tradeshow where Eclipse technology is being promoted.</p>
				<hr size="1">
			    <br>
			</li>
			<li><strong><a name="use_12"></a>May I please have a quote or see a pricelist for Eclipse software?</strong><br>
			    <br>
				<p>Eclipse is free and open source software that is distributed royalty-free under the terms of the <a href="http://www.eclipse.org/legal/epl/notice.php">Eclipse Software User Agreement</a>.  
				If you are going to distribute Eclipse code, you should read our <a href="http://www.eclipse.org/legal/guidetolegaldoc.php">Guidelines</a> and our <a href="http://www.eclipse.org/legal/eplfaq.php">EPL FAQ</a>.  
				They both contain a great deal of useful information.</p>
				<hr size="1">
			    <br>
			</li>
		</ol>
		<small><a href="#top">go to top</a><a name="contributions"></a></small>
		<h3>Contributions and Participation</h3>
		<ol>
			<li><strong><a name="contributions_1"></a>What agreement covers contributions I submit to an Eclipse Foundation project?</strong><br>
			    <br>
				<p>The <a href="termsofuse.php">Eclipse.org Terms of Use</a> covers
				your usage of the Eclipse Foundation web site and associated facilities and that is the legal mechanism through which contributions are accepted.  The Eclipse Foundation web site
				includes a number of associated facilities through which you may upload, submit, or otherwise make available content.  These facilities
				include the CVS repository, Bugzilla bug reporting system, mailing lists and newsgroups.  If you try to contribute something to an
				Eclipse Foundation project committer through another mechanism (e.g. private e-mail) and you intend to contribute it to the Eclipse Foundation, you will probably be asked
				to either send it through a newsgroup, mailing list or bug report, or to confirm in some other way that you are submitting it under the Terms of Use.</p>
				
				<p>This infrastructure is in place to ensure that development proceeds smoothly on Eclipse Foundation projects and that all necessary legal rights have been obtained
				and terms and conditions agreed to.  For example, if someone posts to the newsgroup with a description or the code to fix a bug, the bug can be subsequently fixed
				without the project having to ask the author to assign copyright rights as well as agree to all the other terms and conditions in the relevant license that protect
				both the author and users.</p>
			    <hr size="1">
			    <br>
			</li>
			<li><strong><a name="contributions_2"></a>Will Eclipse projects accept contributions to content that were not provided under the Eclipse Public License?</strong><br>
			    <br>
				<p>Usually the Abouts referenced in the <a href="epl/notice.php">Eclipse Foundation Software User Agreement</a> contain information
				about contributions.  The quick answer to this question is &quot;it depends&quot;.</p>
				
				<p>Content made available by the Eclipse Foundation is sometimes accompanied by or includes content based on third-party content.  This third-party content is often
				sourced from other open source projects such as those run by the Apache Software Foundation.  Eclipse Foundation projects try to avoid branching from other open source
				projects wherever possible.  However sometimes it just can&rsquo;t be avoided especially if the change is critical and the other project&rsquo;s next release date is too
				far out or they won&rsquo;t accept the change for some reason.  Subsequently, while changes to third-party content (either unmodified or derivative works of) might
				be accepted and incorporated into the Eclipse Foundation codebase, Eclipse Foundation committers may often forward these changes to other open
				source projects and/or may ask contributors of such changes to do the same.</p>
			    <hr size="1">
			    <br>
			</li>
			<li><strong><a name="contributions_3"></a>Do I have to place copyright notices in all my code?</strong><br>
			    <br>
				<p>
				Copyright notices are not legally required but it is good practice to include them in any of your code contributions.  See the
				<a href="copyrightandlicensenotice.php">default copyright and license notice template</a>.</p>
			    <hr size="1">
			    <br>
			</li>
			<li><strong><a name="contributions_4"></a>What if I have legal questions about my contribution to the Eclipse Foundation?</strong><br>
			    <br>
				<p>If the questions you have concern whether or not you can legally contribute the content to the Eclipse Foundation, you should consult a lawyer.  If you are contributing
				content on behalf of the company you work for then you should probably be asking your company&rsquo;s legal department.  It is up to you to ensure that you can satisfy
				section 2 d) of the EPL that says:</p>
				
				<blockquote><i>d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the 
				copyright license set forth in this Agreement.</i></blockquote>
				
				<p>Many companies have their own processes for handling contributions to open source projects.  For example some companies want to be sure that the code to be
				contributed could not be first patented by the company.</p>
			    <hr size="1">
			    <br>
			</li>
		</ol>
		<small><a href="#top">go to top</a><a name="committer"></a></small>
		<h3>Working as a Committer</h3>
		<ol>
			<li><strong><a name="committer_1"></a>What are my obligations as a committer working on an Eclipse Foundation project?</strong><br>
			    <br>
				<p>
				As a committer you have the ability to partially control the content distributed in the Eclipse Foundation source code repository and
				subsequently in downloads.  Contributors may provide contributions to the Eclipse Foundation but such contributions do not exist in the repository or downloads
				unless they are released by a committer.  Committers therefore have a responsibility to perform due diligence on any content they release.
				</p>
			    <hr size="1">
			    <br>
			</li>
			<li><strong><a name="committer_2"></a>What is the due diligence that a committer must perform?</strong><br>
			    <br>
				<p>
				The <a href="committerguidelines.php">Due Diligence Guidelines for Eclipse Foundation Committers</a> outline the guidelines for committers.</p>								
				</p>
			    <hr size="1">
			    <br>
			</li>
			<li><strong><a name="committer_3"></a>What if I have legal questions when I am performing due diligence as a committer?</strong><br>
			    <br>
				<p>
				You should contact the Project Management Committee (PMC) for your project.</p>
			    <hr size="1">
			    <br>
			</li>
			<li><strong><a name="committer_4"></a>If I change employers, what happens to my committer status at Eclipse?</strong><br>
			    <br>
				<p>
				Your committer status at Eclipse is not based on your employer. It is an individual recognition of your
				frequent and valuable contributions to one or more Eclipse projects. If you change employers, please contact
				the Eclipse Management Organization (<a href="mailto:emo@eclipse.org">EMO</a>). There will be some paperwork
				that needs to be completed. For more details, please see the 
				<a href="../projects/dev_process/new-committer.php#Paperwork">New Committer Process</a>.
				</p>
			    <hr size="1">
			    <br>
			</li>
		</ol>
		<small><a href="#top">go to top</a><a name="cryptography"></a></small>
		<h3>Cryptography</h3>
		<ol>
			<li><strong><a name="cryptography_1"></a>Does software made available by the Eclipse Foundation contain cryptography?</strong><br>
			    <br>
				<p>In some cases software made available by the Eclipse Foundation may contain cryptography.  For example, the Eclipse Platform contains cryptography and has been classified as
				Export Commodity Control Number (ECCN) 5D002.c.1 by the U.S. Government Department of Commerce, Bureau of Export Administration and deemed eligible for
				export from the United States of America under License Exception Technology Software Unrestricted (TSU) for both object code and source code.</p>
				
				<p>The Abouts for plug-ins with cryptography contain information about the specific algorithms, key sizes, and other important information that may be required
				to obtain additional export control classifications and approvals.</p>
			    <hr size="1">
			    <br>
			</li>
			<li><strong><a name="cryptography_2"></a>Why is cryptography discussed in the Eclipse Foundation Software User Agreement?</strong><br>
			    <br>
				<p>The <a href="epl/notice.php">Eclipse Foundation Software User Agreement</a> reminds you that some countries have restrictions regarding the
				export, import, possession, and use, and/or re-export to another country, another person or for a particular use of encryption software, but it does not restrict you
				in any way nor require you to do anything special if you receive encryption software from the Eclipse Foundation.  In other words, it is your responsibility to determine what
				laws and regulations apply to you and to act appropriately.</p>
								
			    <hr size="1">
			    <br>
			</li>
			<li><strong><a name="cryptography_3"></a>Why is cryptography sometimes discussed in the Abouts or other notices?</strong><br>
			    <br>
				<p>Details of encryption software discussed in Abouts are provided to assist you in obtaining relevant export control classification and approval
				if the laws of your country require that you do so for any reason.  For example, if you know which plug-ins have encryption, you might choose
				to remove them or modify them so that your distribution doesn&rsquo;t contain any cryptography.</p>
			    <hr size="1">
			    <br>
			</li>
		</ol>
	</div>
	<div id="rightcolumn">
		<div class="sideitem">
			<h6>Related Links</h6>
			<ul>
				<li><a href="cpl2epl/">CPL to EPL Conversion</a></li>
				<li><a href="eplfaq.php">EPL FAQ</a></li>
				<li><a href="guidetolegaldoc.php">Guide to Eclipse&rsquo;s Legal Docs</a></li>
			</ul>
		</div>
	</div>

EOHTML;


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