diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..2f524bf
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,62 @@
+# Contributing to Eclipse Dynamic Languages Toolkit
+
+Thanks for your interest in this project.
+
+## Project description
+
+The Eclipse Dynamic Languages Toolkit (DLTK) is a tool for vendors, researchers,
+and end-users who rely on dynamic languages. DLTK is comprised of a set of
+extensible frameworks designed to reduce the complexity of building full
+featured development environments for dynamic languages such as PHP and Perl.
+Besides a set of frameworks DLTK provides exemplary Tcl, Ruby, and Python
+Integrated Development Environments ready to use out of the box.
+
+* https://projects.eclipse.org/projects/technology.dltk
+
+## Developer resources
+
+Information regarding source code management, builds, coding standards, and
+more.
+
+* https://projects.eclipse.org/projects/technology.dltk/developer
+
+The project maintains the following source code repositories
+
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.core.git
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.javascript.git
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.ruby.git
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.tcl.git
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.python.git
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.sh.git
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.releng.git
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.all.git
+
+This project uses Bugzilla to track ongoing development and issues.
+
+* Search for issues: https://eclipse.org/bugs/buglist.cgi?product=DLTK
+* Create a new report: https://eclipse.org/bugs/enter_bug.cgi?product=DLTK
+
+Be sure to search for existing bugs before you create another one. Remember that
+contributions are always welcome!
+
+## Eclipse Contributor Agreement
+
+Before your contribution can be accepted by the project team contributors must
+electronically sign the Eclipse Contributor Agreement (ECA).
+
+* http://www.eclipse.org/legal/ECA.php
+
+Commits that are provided by non-committers must have a Signed-off-by field in
+the footer indicating that the author is aware of the terms by which the
+contribution has been provided to the project. The non-committer must
+additionally have an Eclipse Foundation account and must have a signed Eclipse
+Contributor Agreement (ECA) on file.
+
+For more information, please see the Eclipse Committer Handbook:
+https://www.eclipse.org/projects/handbook/#resources-commit
+
+## Contact
+
+Contact the project developers via the project's "dev" list.
+
+* https://dev.eclipse.org/mailman/listinfo/dltk-dev
\ No newline at end of file
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..e23ece2
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,277 @@
+Eclipse Public License - v 2.0
+
+    THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+    PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION
+    OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+  a) in the case of the initial Contributor, the initial content
+     Distributed under this Agreement, and
+
+  b) in the case of each subsequent Contributor:
+     i) changes to the Program, and
+     ii) additions to the Program;
+  where such changes and/or additions to the Program originate from
+  and are Distributed by that particular Contributor. A Contribution
+  "originates" from a Contributor if it was added to the Program by
+  such Contributor itself or anyone acting on such Contributor's behalf.
+  Contributions do not include changes or additions to the Program that
+  are not Modified Works.
+
+"Contributor" means any person or entity that Distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which
+are necessarily infringed by the use or sale of its Contribution alone
+or when combined with the Program.
+
+"Program" means the Contributions Distributed in accordance with this
+Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement
+or any Secondary License (as applicable), including Contributors.
+
+"Derivative Works" shall mean any work, whether in Source Code or other
+form, that is based on (or derived from) the Program and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship.
+
+"Modified Works" shall mean any work in Source Code or other form that
+results from an addition to, deletion from, or modification of the
+contents of the Program, including, for purposes of clarity any new file
+in Source Code form that contains any contents of the Program. Modified
+Works shall not include works that contain only declarations,
+interfaces, types, classes, structures, or files of the Program solely
+in each case in order to link to, bind by name, or subclass the Program
+or Modified Works thereof.
+
+"Distribute" means the acts of a) distributing or b) making available
+in any manner that enables the transfer of a copy.
+
+"Source Code" means the form of a Program preferred for making
+modifications, including but not limited to software source code,
+documentation source, and configuration files.
+
+"Secondary License" means either the GNU General Public License,
+Version 2.0, or any later versions of that license, including any
+exceptions or additional permissions as identified by the initial
+Contributor.
+
+2. GRANT OF RIGHTS
+
+  a) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free copyright
+  license to reproduce, prepare Derivative Works of, publicly display,
+  publicly perform, Distribute and sublicense the Contribution of such
+  Contributor, if any, and such Derivative Works.
+
+  b) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free patent
+  license under Licensed Patents to make, use, sell, offer to sell,
+  import and otherwise transfer the Contribution of such Contributor,
+  if any, in Source Code or other form. This patent license shall
+  apply to the combination of the Contribution and the Program if, at
+  the time the Contribution is added by the Contributor, such addition
+  of the Contribution causes such combination to be covered by the
+  Licensed Patents. The patent license shall not apply to any other
+  combinations which include the Contribution. No hardware per se is
+  licensed hereunder.
+
+  c) Recipient understands that although each Contributor grants the
+  licenses to its Contributions set forth herein, no assurances are
+  provided by any Contributor that the Program does not infringe the
+  patent or other intellectual property rights of any other entity.
+  Each Contributor disclaims any liability to Recipient for claims
+  brought by any other entity based on infringement of intellectual
+  property rights or otherwise. As a condition to exercising the
+  rights and licenses granted hereunder, each Recipient hereby
+  assumes sole responsibility to secure any other intellectual
+  property rights needed, if any. For example, if a third party
+  patent license is required to allow Recipient to Distribute the
+  Program, it is Recipient's responsibility to acquire that license
+  before distributing the Program.
+
+  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.
+
+  e) Notwithstanding the terms of any Secondary License, no
+  Contributor makes additional grants to any Recipient (other than
+  those set forth in this Agreement) as a result of such Recipient's
+  receipt of the Program under the terms of a Secondary License
+  (if permitted under the terms of Section 3).
+
+3. REQUIREMENTS
+
+3.1 If a Contributor Distributes the Program in any form, then:
+
+  a) the Program must also be made available as Source Code, in
+  accordance with section 3.2, and the Contributor must accompany
+  the Program with a statement that the Source Code for the Program
+  is available under this Agreement, and informs Recipients how to
+  obtain it in a reasonable manner on or through a medium customarily
+  used for software exchange; and
+
+  b) the Contributor may Distribute the Program under a license
+  different than this Agreement, provided that such license:
+     i) effectively disclaims on behalf of all other Contributors all
+     warranties and conditions, express and implied, including
+     warranties or conditions of title and non-infringement, and
+     implied warranties or conditions of merchantability and fitness
+     for a particular purpose;
+
+     ii) effectively excludes on behalf of all other Contributors all
+     liability for damages, including direct, indirect, special,
+     incidental and consequential damages, such as lost profits;
+
+     iii) does not attempt to limit or alter the recipients' rights
+     in the Source Code under section 3.2; and
+
+     iv) requires any subsequent distribution of the Program by any
+     party to be under a license that satisfies the requirements
+     of this section 3.
+
+3.2 When the Program is Distributed as Source Code:
+
+  a) it must be made available under this Agreement, or if the
+  Program (i) is combined with other material in a separate file or
+  files made available under a Secondary License, and (ii) the initial
+  Contributor attached to the Source Code the notice described in
+  Exhibit A of this Agreement, then the Program may be made available
+  under the terms of such Secondary Licenses, and
+
+  b) a copy of this Agreement must be included with each copy of
+  the Program.
+
+3.3 Contributors may not remove or alter any copyright, patent,
+trademark, attribution notices, disclaimers of warranty, or limitations
+of liability ("notices") contained within the Program from any copy of
+the Program which they Distribute, provided that Contributors may add
+their own appropriate notices.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities
+with respect to end users, business partners and the like. While this
+license is intended to facilitate the commercial use of the Program,
+the Contributor who includes the Program in a commercial product
+offering should do so in a manner which does not create potential
+liability for other Contributors. Therefore, if a Contributor includes
+the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every
+other Contributor ("Indemnified Contributor") against any losses,
+damages and costs (collectively "Losses") arising from claims, lawsuits
+and other legal actions brought by a third party against the Indemnified
+Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program
+in a commercial product offering. The obligations in this section do not
+apply to any claims or Losses relating to any actual or alleged
+intellectual property infringement. In order to qualify, an Indemnified
+Contributor must: a) promptly notify the Commercial Contributor in
+writing of such claim, and b) allow the Commercial Contributor to control,
+and cooperate with the Commercial Contributor in, the defense and any
+related settlement negotiations. The Indemnified Contributor may
+participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those performance
+claims and warranties, and if a court requires any other Contributor to
+pay any damages as a result, the Commercial Contributor must pay
+those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS"
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF
+TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
+PURPOSE. Each Recipient is solely responsible for determining the
+appropriateness of using and distributing the Program and assumes all
+risks associated with its exercise of rights under this Agreement,
+including but not limited to the risks and costs of program errors,
+compliance with applicable laws, damage to or loss of data, programs
+or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS
+SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), 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 OR DISTRIBUTION OF THE PROGRAM OR THE
+EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further
+action by the parties hereto, such provision shall be reformed to the
+minimum extent necessary to make such provision valid and enforceable.
+
+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's patent(s), then such Recipient's
+rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of
+time after becoming aware of such noncompliance. If all Recipient's
+rights under this Agreement terminate, Recipient agrees to cease use
+and distribution of the Program as soon as reasonably practicable.
+However, Recipient's obligations under this Agreement and any licenses
+granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement,
+but in order to avoid inconsistency the Agreement is copyrighted and
+may only be modified in the following manner. The Agreement Steward
+reserves the right to publish new versions (including revisions) of
+this Agreement from time to time. No one other than the Agreement
+Steward has the right to modify this Agreement. The Eclipse Foundation
+is the initial Agreement Steward. The Eclipse Foundation may assign the
+responsibility to serve as the Agreement Steward to a suitable separate
+entity. Each new version of the Agreement will be given a distinguishing
+version number. The Program (including Contributions) may always be
+Distributed subject to the version of the Agreement under which it was
+received. In addition, after a new version of the Agreement is published,
+Contributor may elect to Distribute the Program (including its
+Contributions) under the new version.
+
+Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+receives no rights or licenses to the intellectual property of any
+Contributor under this Agreement, whether expressly, by implication,
+estoppel or otherwise. All rights in the Program not expressly granted
+under this Agreement are reserved. Nothing in this Agreement is intended
+to be enforceable by any entity that is not a Contributor or Recipient.
+No third-party beneficiary rights are created under this Agreement.
+
+Exhibit A - Form of Secondary Licenses Notice
+
+"This Source Code may also be made available under the following 
+Secondary Licenses when the conditions for such availability set forth 
+in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+version(s), and exceptions or additional permissions here}."
+
+  Simply including a copy of this Agreement, including this Exhibit A
+  is not sufficient to license the Source Code under Secondary Licenses.
+
+  If it is not possible or desirable to put the notice in a particular
+  file, then You may include the notice in a location (such as a LICENSE
+  file in a relevant directory) where a recipient would be likely to
+  look for such a notice.
+
+  You may add additional accurate notices of copyright ownership.
\ No newline at end of file
diff --git a/NOTICE.md b/NOTICE.md
new file mode 100644
index 0000000..48d5808
--- /dev/null
+++ b/NOTICE.md
@@ -0,0 +1,120 @@
+# Notices for Eclipse Dynamic Languages Toolkit
+
+This content is produced and maintained by the Eclipse Dynamic Languages Toolkit
+project.
+
+* Project home: https://projects.eclipse.org/projects/technology.dltk
+
+## Trademarks
+
+Eclipse Dynamic Languages Toolkit, Dynamic Languages Toolkit, Eclipse DLTK, and
+DLTK are trademarks of the Eclipse Foundation.
+
+## Copyright
+
+All content is the property of the respective authors or their employers. For
+more information regarding authorship of content, please consult the listed
+source code repository logs.
+
+## Declared Project Licenses
+
+This program and the accompanying materials are made available under the terms
+of the Eclipse Public License v. 2.0 which is available at
+http://www.eclipse.org/legal/epl-2.0.
+
+SPDX-License-Identifier: EPL-2.0
+
+## Source Code
+
+The project maintains the following source code repositories:
+
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.core.git
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.javascript.git
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.ruby.git
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.tcl.git
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.python.git
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.sh.git
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.releng.git
+* http://git.eclipse.org/c/dltk/org.eclipse.dltk.all.git
+
+## Third-party Content
+
+This project leverages the following third party content.
+
+ANTLR Runtime (Only) (3.0)
+
+* License: New BSD license
+
+Apache Lucene analyzers-common (7.1.0)
+
+* License: Apache-2.0 AND BSD-3-Clause AND BSD-2-Clause
+
+Apache Lucene Core (7.1.0)
+
+* License: Apache-2.0 AND MIT AND BSD-3-Clause
+
+Apache Lucene Core (7.5)
+
+* License: Apache-2.0 AND MIT AND BSD-3-Clause
+
+Apache Lucene Misc (7.1)
+
+* License: Apache-2.0
+* Project: https://lucene.apache.org/core/
+* Source:
+   https://archive.apache.org/dist/lucene/java/7.1.0/lucene-7.1.0-src.tgz
+
+h2 Database (1.1.117)
+
+* License: Eclipse Public License
+* Project: http://www.h2database.com
+* Source: http://www.h2database.com/html/download.html
+
+h2 Database (1.2.147)
+
+* License: Eclipse Public License
+
+JRuby (0.9.1)
+
+* License: Common Public License 1.0
+
+lucene misc (5.2.1)
+
+* License: Apache License, 2.0
+
+lucene-analyzers-common (5.2.1)
+
+* License: Apache License, 2.0, New BSD license, W3C License
+
+lucene-analyzers-common (6.1.0)
+
+* License: Apache License, 2.0, New BSD license, W3C License	
+
+lucene-core (5.2.1)
+
+* License: Apache License, 2.0, BSD Style, MIT License
+
+lucene-core (6.1.0)
+
+* License: Apache License, 2.0, BSD Style, MIT License
+
+lucene-misc (6.1.0)
+
+* License: Apache License, 2.0
+
+org.apache.xmlbeans (2.3)
+
+* License: Apache License, 2.0
+
+Rhino (1.6)
+
+* License: Netscape Public License 1.1 (NPL)
+
+## Cryptography
+
+Content may contain encryption software. The country in which you are currently
+may have restrictions on the import, possession, and use, and/or re-export to
+another country, of encryption software. BEFORE using any encryption software,
+please check the country's laws, regulations and policies concerning the import,
+possession, or use, and re-export of encryption software, to see if this is
+permitted.
diff --git a/features/org.eclipse.dltk.sh-feature/about.html b/features/org.eclipse.dltk.sh-feature/about.html
index 7c8477f..164f781 100644
--- a/features/org.eclipse.dltk.sh-feature/about.html
+++ b/features/org.eclipse.dltk.sh-feature/about.html
@@ -2,27 +2,35 @@
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>About</title>
 </head>
 <body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>June 5, 2008</p>	
-<h3>License</h3>
+	<h2>About This Content</h2>
 
-<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
-indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+	<p>November 30, 2017</p>
+	<h3>License</h3>
 
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
-being redistributed by another party (&quot;Redistributor&quot;) 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">http://www.eclipse.org</a>.</p>
+	<p>
+		The Eclipse Foundation makes available all content in this plug-in
+		(&quot;Content&quot;). Unless otherwise indicated below, the Content
+		is provided to you under the terms and conditions of the Eclipse
+		Public License Version 2.0 (&quot;EPL&quot;). A copy of the EPL is
+		available at <a href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; 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
+		(&quot;Redistributor&quot;) 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/">http://www.eclipse.org</a>.
+	</p>
 
 </body>
 </html>
\ No newline at end of file
diff --git a/features/org.eclipse.dltk.sh-feature/feature.properties b/features/org.eclipse.dltk.sh-feature/feature.properties
index bda44c7..a2022ce 100644
--- a/features/org.eclipse.dltk.sh-feature/feature.properties
+++ b/features/org.eclipse.dltk.sh-feature/feature.properties
@@ -5,8 +5,9 @@
 copyright=\
 Copyright (c) 2014 Red Hat Inc and others.\n\
 \n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n
+This program and the accompanying materials are made available under the\n\
+terms of the Eclipse Public License v. 2.0 which is available at\n\
+http://www.eclipse.org/legal/epl-2.0.\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n
 ################ end of copyright property ####################################
diff --git a/features/org.eclipse.dltk.sh-feature/pom.xml b/features/org.eclipse.dltk.sh-feature/pom.xml
index 0ae56fc..eb4f1d8 100644
--- a/features/org.eclipse.dltk.sh-feature/pom.xml
+++ b/features/org.eclipse.dltk.sh-feature/pom.xml
@@ -2,10 +2,11 @@
 <!--
    Copyright (C) 2011, Red Hat, Inc.
 
-   All rights reserved. This program and the accompanying materials
-   are made available under the terms of the Eclipse Public License v1.0
-   which accompanies this distribution, and is available at
-   http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
 -->
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
diff --git a/features/org.eclipse.dltk.sh.sdk/about.html b/features/org.eclipse.dltk.sh.sdk/about.html
index 7c8477f..164f781 100644
--- a/features/org.eclipse.dltk.sh.sdk/about.html
+++ b/features/org.eclipse.dltk.sh.sdk/about.html
@@ -2,27 +2,35 @@
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>About</title>
 </head>
 <body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>June 5, 2008</p>	
-<h3>License</h3>
+	<h2>About This Content</h2>
 
-<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
-indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+	<p>November 30, 2017</p>
+	<h3>License</h3>
 
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
-being redistributed by another party (&quot;Redistributor&quot;) 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">http://www.eclipse.org</a>.</p>
+	<p>
+		The Eclipse Foundation makes available all content in this plug-in
+		(&quot;Content&quot;). Unless otherwise indicated below, the Content
+		is provided to you under the terms and conditions of the Eclipse
+		Public License Version 2.0 (&quot;EPL&quot;). A copy of the EPL is
+		available at <a href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; 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
+		(&quot;Redistributor&quot;) 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/">http://www.eclipse.org</a>.
+	</p>
 
 </body>
 </html>
\ No newline at end of file
diff --git a/features/org.eclipse.dltk.sh.sdk/feature.properties b/features/org.eclipse.dltk.sh.sdk/feature.properties
index b5a0c9d..ce5c7c2 100644
--- a/features/org.eclipse.dltk.sh.sdk/feature.properties
+++ b/features/org.eclipse.dltk.sh.sdk/feature.properties
@@ -5,8 +5,9 @@
 copyright=\
 Copyright (c) 2014 Red Hat Inc and others.\n\
 \n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n
+This program and the accompanying materials are made available under the\n\
+terms of the Eclipse Public License v. 2.0 which is available at\n\
+http://www.eclipse.org/legal/epl-2.0.\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n
 ################ end of copyright property ####################################
diff --git a/features/org.eclipse.dltk.sh.sdk/pom.xml b/features/org.eclipse.dltk.sh.sdk/pom.xml
index ef56cb4..05b1ed1 100644
--- a/features/org.eclipse.dltk.sh.sdk/pom.xml
+++ b/features/org.eclipse.dltk.sh.sdk/pom.xml
@@ -2,10 +2,11 @@
 <!--
    Copyright (C) 2011, Red Hat, Inc.
 
-   All rights reserved. This program and the accompanying materials
-   are made available under the terms of the Eclipse Public License v1.0
-   which accompanies this distribution, and is available at
-   http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
 -->
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
diff --git a/plugins/org.eclipse.dltk.sh.core/about.html b/plugins/org.eclipse.dltk.sh.core/about.html
index 7c8477f..164f781 100644
--- a/plugins/org.eclipse.dltk.sh.core/about.html
+++ b/plugins/org.eclipse.dltk.sh.core/about.html
@@ -2,27 +2,35 @@
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>About</title>
 </head>
 <body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>June 5, 2008</p>	
-<h3>License</h3>
+	<h2>About This Content</h2>
 
-<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
-indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+	<p>November 30, 2017</p>
+	<h3>License</h3>
 
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
-being redistributed by another party (&quot;Redistributor&quot;) 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">http://www.eclipse.org</a>.</p>
+	<p>
+		The Eclipse Foundation makes available all content in this plug-in
+		(&quot;Content&quot;). Unless otherwise indicated below, the Content
+		is provided to you under the terms and conditions of the Eclipse
+		Public License Version 2.0 (&quot;EPL&quot;). A copy of the EPL is
+		available at <a href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; 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
+		(&quot;Redistributor&quot;) 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/">http://www.eclipse.org</a>.
+	</p>
 
 </body>
 </html>
\ No newline at end of file
diff --git a/plugins/org.eclipse.dltk.sh.core/pom.xml b/plugins/org.eclipse.dltk.sh.core/pom.xml
index 9a9dc81..a400cd4 100644
--- a/plugins/org.eclipse.dltk.sh.core/pom.xml
+++ b/plugins/org.eclipse.dltk.sh.core/pom.xml
@@ -2,10 +2,11 @@
 <!--
    Copyright (C) 2011, Red Hat, Inc. and others
 
-   All rights reserved. This program and the accompanying materials
-   are made available under the terms of the Eclipse Public License v1.0
-   which accompanies this distribution, and is available at
-   http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
 
    Contributors:
        Red Hat Incorporated - initial implementation
diff --git a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/core/ShellScriptLanguageToolkit.java b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/core/ShellScriptLanguageToolkit.java
index 907b539..3666776 100644
--- a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/core/ShellScriptLanguageToolkit.java
+++ b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/core/ShellScriptLanguageToolkit.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/core/ShelledContentDescriber.java b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/core/ShelledContentDescriber.java
index 129abee..159d515 100644
--- a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/core/ShelledContentDescriber.java
+++ b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/core/ShelledContentDescriber.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/core/ShelledNature.java b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/core/ShelledNature.java
index e9ef986..64a964e 100644
--- a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/core/ShelledNature.java
+++ b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/core/ShelledNature.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/FunctionInfo.java b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/FunctionInfo.java
index a93a4ea..1d68f2b 100644
--- a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/FunctionInfo.java
+++ b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/FunctionInfo.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellModel.java b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellModel.java
index c9281d1..2b3ca69 100644
--- a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellModel.java
+++ b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellModel.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellModuleDeclaration.java b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellModuleDeclaration.java
index 98324f7..9ce4654 100644
--- a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellModuleDeclaration.java
+++ b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellModuleDeclaration.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellScriptSourceParser.java b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellScriptSourceParser.java
index 1f36fc3..8420c34 100644
--- a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellScriptSourceParser.java
+++ b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellScriptSourceParser.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellScriptSourceParserFactory.java b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellScriptSourceParserFactory.java
index 3b12d39..1618d5b 100644
--- a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellScriptSourceParserFactory.java
+++ b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShellScriptSourceParserFactory.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShelledSourceElementParser.java b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShelledSourceElementParser.java
index fa73f0f..2c5f2b3 100644
--- a/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShelledSourceElementParser.java
+++ b/plugins/org.eclipse.dltk.sh.core/src/org/eclipse/dltk/sh/internal/core/parser/ShelledSourceElementParser.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.doc/about.html b/plugins/org.eclipse.dltk.sh.doc/about.html
index 7c8477f..164f781 100644
--- a/plugins/org.eclipse.dltk.sh.doc/about.html
+++ b/plugins/org.eclipse.dltk.sh.doc/about.html
@@ -2,27 +2,35 @@
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>About</title>
 </head>
 <body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>June 5, 2008</p>	
-<h3>License</h3>
+	<h2>About This Content</h2>
 
-<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
-indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+	<p>November 30, 2017</p>
+	<h3>License</h3>
 
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
-being redistributed by another party (&quot;Redistributor&quot;) 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">http://www.eclipse.org</a>.</p>
+	<p>
+		The Eclipse Foundation makes available all content in this plug-in
+		(&quot;Content&quot;). Unless otherwise indicated below, the Content
+		is provided to you under the terms and conditions of the Eclipse
+		Public License Version 2.0 (&quot;EPL&quot;). A copy of the EPL is
+		available at <a href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; 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
+		(&quot;Redistributor&quot;) 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/">http://www.eclipse.org</a>.
+	</p>
 
 </body>
 </html>
\ No newline at end of file
diff --git a/plugins/org.eclipse.dltk.sh.doc/pom.xml b/plugins/org.eclipse.dltk.sh.doc/pom.xml
index 7642b7b..e212ea4 100644
--- a/plugins/org.eclipse.dltk.sh.doc/pom.xml
+++ b/plugins/org.eclipse.dltk.sh.doc/pom.xml
@@ -2,10 +2,11 @@
 <!--
    Copyright (C) 2011, Red Hat, Inc. and others
 
-   All rights reserved. This program and the accompanying materials
-   are made available under the terms of the Eclipse Public License v1.0
-   which accompanies this distribution, and is available at
-   http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
 
    Contributors:
        Red Hat Incorporated - initial implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/about.html b/plugins/org.eclipse.dltk.sh.ui/about.html
index 7c8477f..164f781 100644
--- a/plugins/org.eclipse.dltk.sh.ui/about.html
+++ b/plugins/org.eclipse.dltk.sh.ui/about.html
@@ -2,27 +2,35 @@
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>About</title>
 </head>
 <body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>June 5, 2008</p>	
-<h3>License</h3>
+	<h2>About This Content</h2>
 
-<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
-indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+	<p>November 30, 2017</p>
+	<h3>License</h3>
 
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
-being redistributed by another party (&quot;Redistributor&quot;) 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">http://www.eclipse.org</a>.</p>
+	<p>
+		The Eclipse Foundation makes available all content in this plug-in
+		(&quot;Content&quot;). Unless otherwise indicated below, the Content
+		is provided to you under the terms and conditions of the Eclipse
+		Public License Version 2.0 (&quot;EPL&quot;). A copy of the EPL is
+		available at <a href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; 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
+		(&quot;Redistributor&quot;) 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/">http://www.eclipse.org</a>.
+	</p>
 
 </body>
 </html>
\ No newline at end of file
diff --git a/plugins/org.eclipse.dltk.sh.ui/pom.xml b/plugins/org.eclipse.dltk.sh.ui/pom.xml
index 8417bc4..d0cb3ff 100644
--- a/plugins/org.eclipse.dltk.sh.ui/pom.xml
+++ b/plugins/org.eclipse.dltk.sh.ui/pom.xml
@@ -2,10 +2,11 @@
 <!--
    Copyright (C) 2011, Red Hat, Inc. and others
 
-   All rights reserved. This program and the accompanying materials
-   are made available under the terms of the Eclipse Public License v1.0
-   which accompanies this distribution, and is available at
-   http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
 
    Contributors:
        Red Hat Incorporated - initial implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/Activator.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/Activator.java
index 4d59082..54296c6 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/Activator.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/Activator.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/IShellColorConstants.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/IShellColorConstants.java
index 292f219..f4b9696 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/IShellColorConstants.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/IShellColorConstants.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/LaunchConfigurationDelegate.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/LaunchConfigurationDelegate.java
index 21552a8..71bb730 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/LaunchConfigurationDelegate.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/LaunchConfigurationDelegate.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/LaunchShortcut.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/LaunchShortcut.java
index 44f556e..ff3a7ba 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/LaunchShortcut.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/LaunchShortcut.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/MainPreferencePage.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/MainPreferencePage.java
index c363c50..d316cbb 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/MainPreferencePage.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/MainPreferencePage.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShellContentAssistPreference.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShellContentAssistPreference.java
index fd387a2..698d740 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShellContentAssistPreference.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShellContentAssistPreference.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShellTodoParserType.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShellTodoParserType.java
index da420ec..1b81f2f 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShellTodoParserType.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShellTodoParserType.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShelledUILanguageToolkit.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShelledUILanguageToolkit.java
index c571aa7..5110df1 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShelledUILanguageToolkit.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShelledUILanguageToolkit.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShelledUIPreferenceInitializer.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShelledUIPreferenceInitializer.java
index 9786da6..6d4a46a 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShelledUIPreferenceInitializer.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/ShelledUIPreferenceInitializer.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/AbstractProjectHandler.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/AbstractProjectHandler.java
index d09e081..9379105 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/AbstractProjectHandler.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/AbstractProjectHandler.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2010, 2018 Mat Booth and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *******************************************************************************/
 package org.eclipse.dltk.sh.internal.ui.commands;
 
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/AddNature.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/AddNature.java
index 24b7f23..7647615 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/AddNature.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/AddNature.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2010 Mat Booth and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *******************************************************************************/
 package org.eclipse.dltk.sh.internal.ui.commands;
 
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/RemoveNature.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/RemoveNature.java
index 61a0f5d..e12db94 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/RemoveNature.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/RemoveNature.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2010 Mat Booth and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *******************************************************************************/
 package org.eclipse.dltk.sh.internal.ui.commands;
 
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/ShowManHandler.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/ShowManHandler.java
index f8d0f40..6dc930c 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/ShowManHandler.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/commands/ShowManHandler.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009, 2017 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionEngine.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionEngine.java
index 4164edc..cc0dd68 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionEngine.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionEngine.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009, 2016 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProcessor.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProcessor.java
index 3aa3d91..b27ab9c 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProcessor.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProcessor.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProposal.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProposal.java
index b58b48f..644ad53 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProposal.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProposal.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProposalCollector.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProposalCollector.java
index 6d0b2ab..2786d3d 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProposalCollector.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProposalCollector.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProposalComputer.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProposalComputer.java
index 8e860d9..2b1ffbc 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProposalComputer.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/completion/ShellCompletionProposalComputer.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/editor/ShellDocumentSetupParticipant.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/editor/ShellDocumentSetupParticipant.java
index 6d73e3e..52be436 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/editor/ShellDocumentSetupParticipant.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/editor/ShellDocumentSetupParticipant.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/editor/ShellScriptEditor.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/editor/ShellScriptEditor.java
index 927b01f..e42c218 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/editor/ShellScriptEditor.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/editor/ShellScriptEditor.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009, 2016 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/editor/ShellSourceViewerConfiguration.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/editor/ShellSourceViewerConfiguration.java
index a7d50c4..3ee13ca 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/editor/ShellSourceViewerConfiguration.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/editor/ShellSourceViewerConfiguration.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009, 2017 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/AddShellScriptInterpreterDialog.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/AddShellScriptInterpreterDialog.java
index 118eb93..350c89e 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/AddShellScriptInterpreterDialog.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/AddShellScriptInterpreterDialog.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellInterpreterPreferencePage.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellInterpreterPreferencePage.java
index 3b13bcd..3a7462e 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellInterpreterPreferencePage.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellInterpreterPreferencePage.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellMainLaunchConfigurationTab.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellMainLaunchConfigurationTab.java
index 05d7e29..98050aa 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellMainLaunchConfigurationTab.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellMainLaunchConfigurationTab.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInstall.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInstall.java
index 42aab8f..9791348 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInstall.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInstall.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInstallType.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInstallType.java
index a88fcb3..ae4b1dd 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInstallType.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInstallType.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInterpreterLibraryBlock.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInterpreterLibraryBlock.java
index cda502e..f3966a0 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInterpreterLibraryBlock.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInterpreterLibraryBlock.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInterpretersBlock.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInterpretersBlock.java
index 5170f86..9cbb47e 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInterpretersBlock.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellScriptInterpretersBlock.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellTabGroup.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellTabGroup.java
index 08ccec8..bf8738a 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellTabGroup.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/interpreter/ShellTabGroup.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellColoringConfigurationBlock.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellColoringConfigurationBlock.java
index 58c3415..19d0744 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellColoringConfigurationBlock.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellColoringConfigurationBlock.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellEditorPreferencesPage.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellEditorPreferencesPage.java
index 98bd057..1bc946b 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellEditorPreferencesPage.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellEditorPreferencesPage.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellFoldingPreferencePage.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellFoldingPreferencePage.java
index 676568d..b92cada 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellFoldingPreferencePage.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellFoldingPreferencePage.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2014 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Peter Palaga - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellSyntaxColoringPreferencePage.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellSyntaxColoringPreferencePage.java
index 0f2eea4..d1a0d87 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellSyntaxColoringPreferencePage.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellSyntaxColoringPreferencePage.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellTodoTaskPreferencePage.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellTodoTaskPreferencePage.java
index 47e1754..4e3f1b9 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellTodoTaskPreferencePage.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/ShellTodoTaskPreferencePage.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/SimpleShellSourceViewerConfiguration.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/SimpleShellSourceViewerConfiguration.java
index 6a851cb..8d50dfd 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/SimpleShellSourceViewerConfiguration.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/preferences/SimpleShellSourceViewerConfiguration.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/search/ShelledMatchLocationParser.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/search/ShelledMatchLocationParser.java
index 85933c7..b8c24d2 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/search/ShelledMatchLocationParser.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/search/ShelledMatchLocationParser.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/search/ShelledSearchFactory.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/search/ShelledSearchFactory.java
index 70972b1..f36afb3 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/search/ShelledSearchFactory.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/search/ShelledSearchFactory.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/search/ShelledSearchPage.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/search/ShelledSearchPage.java
index 0c64ca9..6ca2762 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/search/ShelledSearchPage.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/search/ShelledSearchPage.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/selection/ShellDocumentationProvider.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/selection/ShellDocumentationProvider.java
index 8787cdb..15a535a 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/selection/ShellDocumentationProvider.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/selection/ShellDocumentationProvider.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009, 2017 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/selection/ShelledSelectionEngine.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/selection/ShelledSelectionEngine.java
index 2911e0d..e31c0ea 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/selection/ShelledSelectionEngine.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/selection/ShelledSelectionEngine.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009, 2016 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/AssignmentDetector.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/AssignmentDetector.java
index 5b251b2..346dc00 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/AssignmentDetector.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/AssignmentDetector.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2011 Mat Booth and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Mat Booth
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/AssignmentRule.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/AssignmentRule.java
index 51a0d86..8b93611 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/AssignmentRule.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/AssignmentRule.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DocumentAndCommandScanner.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DocumentAndCommandScanner.java
index cd0db4b..04e2efc 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DocumentAndCommandScanner.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DocumentAndCommandScanner.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DollarBraceCountingRule.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DollarBraceCountingRule.java
index dac3543..ee76c78 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DollarBraceCountingRule.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DollarBraceCountingRule.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Mat Booth and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *******************************************************************************/
 package org.eclipse.dltk.sh.internal.ui.text;
 
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DollarDetector.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DollarDetector.java
index b4835ac..f725df0 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DollarDetector.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DollarDetector.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *******************************************************************************/
 package org.eclipse.dltk.sh.internal.ui.text;
 
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DollarRule.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DollarRule.java
index 74eb369..aa4f19d 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DollarRule.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DollarRule.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DoubleQuoteScanner.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DoubleQuoteScanner.java
index b25cc35..2dbc5e2 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DoubleQuoteScanner.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/DoubleQuoteScanner.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009-2010 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/EvalScanner.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/EvalScanner.java
index a9bce1b..1e6b129 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/EvalScanner.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/EvalScanner.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2010 Mat Booth and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *******************************************************************************/
 package org.eclipse.dltk.sh.internal.ui.text;
 
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/IShellPartitions.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/IShellPartitions.java
index 0ed368f..b556b2b 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/IShellPartitions.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/IShellPartitions.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/IndentType.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/IndentType.java
index c5635af..e8839d8 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/IndentType.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/IndentType.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ScriptAutoIndentStrategy.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ScriptAutoIndentStrategy.java
index 16ea5b7..5d17cce 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ScriptAutoIndentStrategy.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ScriptAutoIndentStrategy.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009, 2017 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ShellCodeScanner.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ShellCodeScanner.java
index b811dbf..dd29d63 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ShellCodeScanner.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ShellCodeScanner.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009, 2017 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ShellPartitionScanner.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ShellPartitionScanner.java
index 6690671..6c80b80 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ShellPartitionScanner.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ShellPartitionScanner.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ShellTextTools.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ShellTextTools.java
index 9672d1b..4d12008 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ShellTextTools.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ShellTextTools.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/WhitespaceDetector.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/WhitespaceDetector.java
index 4f5ee07..7f59aaf 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/WhitespaceDetector.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/WhitespaceDetector.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/FoldingBlockKind.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/FoldingBlockKind.java
index 734a724..d2d93ad 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/FoldingBlockKind.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/FoldingBlockKind.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2012 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCodeFoldingBlockProvider.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCodeFoldingBlockProvider.java
index 9ffb9c1..f5142a8 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCodeFoldingBlockProvider.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCodeFoldingBlockProvider.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2012 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCodeFoldingPreferenceBlock.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCodeFoldingPreferenceBlock.java
index 254dcce..9a0fee4 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCodeFoldingPreferenceBlock.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCodeFoldingPreferenceBlock.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2014 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Peter Palaga - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCommentFoldingBlockProvider.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCommentFoldingBlockProvider.java
index 6394773..4eabaf8 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCommentFoldingBlockProvider.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCommentFoldingBlockProvider.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2012 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCommentFoldingPreferenceBlock.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCommentFoldingPreferenceBlock.java
index 60610ab..2b501b5 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCommentFoldingPreferenceBlock.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/folding/ShellCommentFoldingPreferenceBlock.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2014 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Peter Palaga - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/hyperlink/SourceHyperlinkDetector.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/hyperlink/SourceHyperlinkDetector.java
index a2f2235..def982c 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/hyperlink/SourceHyperlinkDetector.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/hyperlink/SourceHyperlinkDetector.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2017 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/wizards/NewShellScriptFilePage.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/wizards/NewShellScriptFilePage.java
index f0c9895..d02e3c5 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/wizards/NewShellScriptFilePage.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/wizards/NewShellScriptFilePage.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2015 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/wizards/NewShellScriptFileWizard.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/wizards/NewShellScriptFileWizard.java
index 2213ee2..cf98700 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/wizards/NewShellScriptFileWizard.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/wizards/NewShellScriptFileWizard.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2015 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/wizards/ShellScriptProjectWizard.java b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/wizards/ShellScriptProjectWizard.java
index 321ddc8..ebe7330 100644
--- a/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/wizards/ShellScriptProjectWizard.java
+++ b/plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/wizards/ShellScriptProjectWizard.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2015 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/pom.xml b/pom.xml
index a0084c6..24c66b5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,8 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- Copyright (C) 2011, Red Hat, Inc. and others All rights reserved. This program
-	and the accompanying materials are made available under the terms of the Eclipse
-	Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
-	Contributors: Red Hat Incorporated - initial implementation -->
+<!-- Copyright (C) 2011, Red Hat, Inc. and others 
+	
+	This program and the accompanying materials are made available under the
+	terms of the Eclipse Public License v. 2.0 which is available at
+	http://www.eclipse.org/legal/epl-2.0.
+
+	SPDX-License-Identifier: EPL-2.0 -->
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/tests/org.eclipse.dltk.sh.core.tests/about.html b/tests/org.eclipse.dltk.sh.core.tests/about.html
index 7c8477f..164f781 100644
--- a/tests/org.eclipse.dltk.sh.core.tests/about.html
+++ b/tests/org.eclipse.dltk.sh.core.tests/about.html
@@ -2,27 +2,35 @@
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>About</title>
 </head>
 <body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>June 5, 2008</p>	
-<h3>License</h3>
+	<h2>About This Content</h2>
 
-<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
-indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+	<p>November 30, 2017</p>
+	<h3>License</h3>
 
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
-being redistributed by another party (&quot;Redistributor&quot;) 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">http://www.eclipse.org</a>.</p>
+	<p>
+		The Eclipse Foundation makes available all content in this plug-in
+		(&quot;Content&quot;). Unless otherwise indicated below, the Content
+		is provided to you under the terms and conditions of the Eclipse
+		Public License Version 2.0 (&quot;EPL&quot;). A copy of the EPL is
+		available at <a href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; 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
+		(&quot;Redistributor&quot;) 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/">http://www.eclipse.org</a>.
+	</p>
 
 </body>
 </html>
\ No newline at end of file
diff --git a/tests/org.eclipse.dltk.sh.core.tests/pom.xml b/tests/org.eclipse.dltk.sh.core.tests/pom.xml
index c7bed67..11988a9 100644
--- a/tests/org.eclipse.dltk.sh.core.tests/pom.xml
+++ b/tests/org.eclipse.dltk.sh.core.tests/pom.xml
@@ -2,10 +2,11 @@
 <!--
    Copyright (C) 2011, Red Hat, Inc.
 
-   All rights reserved. This program and the accompanying materials
-   are made available under the terms of the Eclipse Public License v1.0
-   which accompanies this distribution, and is available at
-   http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
 -->
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
diff --git a/tests/org.eclipse.dltk.sh.core.tests/src/org/eclipse/dltk/sh/core/tests/AllTests.java b/tests/org.eclipse.dltk.sh.core.tests/src/org/eclipse/dltk/sh/core/tests/AllTests.java
index 4aaa128..8cf1b0c 100644
--- a/tests/org.eclipse.dltk.sh.core.tests/src/org/eclipse/dltk/sh/core/tests/AllTests.java
+++ b/tests/org.eclipse.dltk.sh.core.tests/src/org/eclipse/dltk/sh/core/tests/AllTests.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2010 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/tests/org.eclipse.dltk.sh.core.tests/src/org/eclipse/dltk/sh/internal/core/parser/tests/ShellScriptSourceParserTest.java b/tests/org.eclipse.dltk.sh.core.tests/src/org/eclipse/dltk/sh/internal/core/parser/tests/ShellScriptSourceParserTest.java
index 1feade2..54bcba3 100644
--- a/tests/org.eclipse.dltk.sh.core.tests/src/org/eclipse/dltk/sh/internal/core/parser/tests/ShellScriptSourceParserTest.java
+++ b/tests/org.eclipse.dltk.sh.core.tests/src/org/eclipse/dltk/sh/internal/core/parser/tests/ShellScriptSourceParserTest.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2010 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/tests/org.eclipse.dltk.sh.ui.tests/about.html b/tests/org.eclipse.dltk.sh.ui.tests/about.html
index 7c8477f..164f781 100644
--- a/tests/org.eclipse.dltk.sh.ui.tests/about.html
+++ b/tests/org.eclipse.dltk.sh.ui.tests/about.html
@@ -2,27 +2,35 @@
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>About</title>
 </head>
 <body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>June 5, 2008</p>	
-<h3>License</h3>
+	<h2>About This Content</h2>
 
-<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
-indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+	<p>November 30, 2017</p>
+	<h3>License</h3>
 
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
-being redistributed by another party (&quot;Redistributor&quot;) 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">http://www.eclipse.org</a>.</p>
+	<p>
+		The Eclipse Foundation makes available all content in this plug-in
+		(&quot;Content&quot;). Unless otherwise indicated below, the Content
+		is provided to you under the terms and conditions of the Eclipse
+		Public License Version 2.0 (&quot;EPL&quot;). A copy of the EPL is
+		available at <a href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; 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
+		(&quot;Redistributor&quot;) 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/">http://www.eclipse.org</a>.
+	</p>
 
 </body>
 </html>
\ No newline at end of file
diff --git a/tests/org.eclipse.dltk.sh.ui.tests/pom.xml b/tests/org.eclipse.dltk.sh.ui.tests/pom.xml
index 3f96193..58b9eb8 100644
--- a/tests/org.eclipse.dltk.sh.ui.tests/pom.xml
+++ b/tests/org.eclipse.dltk.sh.ui.tests/pom.xml
@@ -1,7 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- Copyright (C) 2011, Red Hat, Inc. All rights reserved. This program and the 
-	accompanying materials are made available under the terms of the Eclipse Public License 
-	v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html -->
+<!-- Copyright (C) 2011, Red Hat, Inc. 
+	
+	This program and the accompanying materials are made available under the
+	terms of the Eclipse Public License v. 2.0 which is available at
+	http://www.eclipse.org/legal/epl-2.0.
+
+	SPDX-License-Identifier: EPL-2.0 -->
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/tests/AllTests.java b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/tests/AllTests.java
index 90dc3ae..619abc8 100644
--- a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/tests/AllTests.java
+++ b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/tests/AllTests.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/AbstractScannerTester.java b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/AbstractScannerTester.java
index a6d4539..b40da90 100644
--- a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/AbstractScannerTester.java
+++ b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/AbstractScannerTester.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2010 Mat Booth and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *******************************************************************************/
 package org.eclipse.dltk.sh.internal.ui.text.tests;
 
diff --git a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/AssignmentRuleTest.java b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/AssignmentRuleTest.java
index 2d47e5b..6a67fd5 100644
--- a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/AssignmentRuleTest.java
+++ b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/AssignmentRuleTest.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2011 Mat Booth and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Mat Booth
diff --git a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/DollarBraceCountingRuleTest.java b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/DollarBraceCountingRuleTest.java
index 8e99cd8..b36b25d 100644
--- a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/DollarBraceCountingRuleTest.java
+++ b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/DollarBraceCountingRuleTest.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Mat Booth and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *******************************************************************************/
 package org.eclipse.dltk.sh.internal.ui.text.tests;
 
diff --git a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/DollarRuleTest.java b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/DollarRuleTest.java
index a1a3e49..3581a52 100644
--- a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/DollarRuleTest.java
+++ b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/DollarRuleTest.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/DoubleQuoteScannerTest.java b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/DoubleQuoteScannerTest.java
index cdfd9c0..d634869 100644
--- a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/DoubleQuoteScannerTest.java
+++ b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/DoubleQuoteScannerTest.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2010 Mat Booth and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *******************************************************************************/
 package org.eclipse.dltk.sh.internal.ui.text.tests;
 
diff --git a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/EvalScannerTest.java b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/EvalScannerTest.java
index e78efda..d0bbf1f 100644
--- a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/EvalScannerTest.java
+++ b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/EvalScannerTest.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2010 Mat Booth and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *******************************************************************************/
 package org.eclipse.dltk.sh.internal.ui.text.tests;
 
diff --git a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/MockScanner.java b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/MockScanner.java
index 592d4f3..42adb74 100644
--- a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/MockScanner.java
+++ b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/MockScanner.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009 Mat Booth and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *******************************************************************************/
 package org.eclipse.dltk.sh.internal.ui.text.tests;
 
diff --git a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/TextSuite.java b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/TextSuite.java
index cab03c1..6900bd8 100644
--- a/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/TextSuite.java
+++ b/tests/org.eclipse.dltk.sh.ui.tests/src/org/eclipse/dltk/sh/internal/ui/text/tests/TextSuite.java
@@ -1,9 +1,10 @@
 /*******************************************************************************
  * Copyright (c) 2009-2011 Red Hat Inc. and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Alexander Kurtakov - initial API and implementation
diff --git a/update.site/pom.xml b/update.site/pom.xml
index 049e5bb..b45693a 100644
--- a/update.site/pom.xml
+++ b/update.site/pom.xml
@@ -2,10 +2,11 @@
 <!--
    Copyright (C) 2011, Red Hat, Inc. and others
 
-   All rights reserved. This program and the accompanying materials
-   are made available under the terms of the Eclipse Public License v1.0
-   which accompanies this distribution, and is available at
-   http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
 
    Contributors:
        Red Hat Incorporated - initial implementation
