<html>

<head>
<title>AspectJ License</title>


</head>

<BODY BGCOLOR="white">

<h2 align="center"><b>AspectJ<sup><small>TM</small></sup>
                      Compiler and Core Tools License</b></h2>

<p>This is a binary-only release.&nbsp; Source code
is available from
<a href="http://eclipse.org/aspectj">http://eclipse.org/aspectj</a></p>

<p>The Eclipse Foundation makes available all content in this distribution ("Content").  
		Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the
		Eclipse Public License Version 1.0 ("EPL").  A copy of the EPL is available 
		at <a href="../../org/documents/epl-v10.php">http://www.eclipse.org/legal/epl-v10.html</a>.
		For purposes of the EPL, "Program" will mean the Content.</p>

		<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
		being redistributed by another party ("Redistributor") and different terms and conditions may
		apply to your use of any object code in the Content.  Check the Redistributor's license 
		that was provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
		indicated below, the terms and conditions of the EPL still apply to any source code in the Content
		and such source code may be obtained at <a href="/">http://www.eclipse.org</a>.</p>

		
		<h3>Third Party Content</h3>
		<p>The Content includes items that have been sourced from third parties as set out below. If you 
		did not receive this Content directly from the Eclipse Foundation, the following is provided 
		for informational purposes only, and you should look to the Redistributor?s license for 
		terms and conditions of use.</p>
		<em>

		<h4>BCEL v5.1</h4>
		<p>This product contains software developed by the
         Apache Software Foundation (<a href="http://www.apache.org/">http://www.apache.org</a>).</p>
 
		<p>AspectJ includes a modified version of the Apache Jakarta Byte Code Engineering Library (BCEL) v5.1.
		BCEL is available at <a href="http://jakarta.apache.org/bcel/">http://jakarta.apache.org/bcel/</a>. Source
		code for the modified version of BCEL is available at Eclipse.org in the AspectJ source tree. This code
		is made available under the Apache Software License v1.1</p>
		
		<h4>ASM v2.2.1</h4> 
		<p>AspectJ includes a binary version of ASM v2.2.1 (<a href="http://asm.objectweb.org/index.html">http://asm.objectweb.org/</a>)
		The source code for ASM is available from the ObjectWeb download site at 
		<a href="http://asm.objectweb.org/download/">http://asm.objectweb.org/download/</a>. 
		<p>The ASM license is available at <a href="http://asm.objectweb.org/license.html">http://asm.objectweb.org/license.html</a>. 
		The license is also reproduced here:
		</p>

<pre>Copyright (c) 2000-2005 INRIA, France Telecom
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.

3. Neither the name of the copyright holders nor the names of its
   contributors may be used to endorse or promote products derived from
   this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
THE POSSIBILITY OF SUCH DAMAGE.
</pre>

</em>

</body>

</html>
