This commit was manufactured by cvs2svn to create branch 'JohnWork'.

Cherrypick from master 2001-08-27 18:19:14 UTC John Arthorne <johna> 'New path implementation using String[] for segments':
    bundles/org.eclipse.core.runtime/.classpath
    bundles/org.eclipse.core.runtime/.cvsignore
    bundles/org.eclipse.core.runtime/.options
    bundles/org.eclipse.core.runtime/.vcm_meta
    bundles/org.eclipse.core.runtime/build.properties
    bundles/org.eclipse.core.runtime/doc/hglegal.htm
    bundles/org.eclipse.core.runtime/doc/ngibmcpy.gif
    bundles/org.eclipse.core.runtime/doc/org_eclipse_core_runtime.html
    bundles/org.eclipse.core.runtime/doc/org_eclipse_core_runtime_applications.html
    bundles/org.eclipse.core.runtime/doc/org_eclipse_core_runtime_urlHandlers.html
    bundles/org.eclipse.core.runtime/plugin.jars
    bundles/org.eclipse.core.runtime/plugin.properties
    bundles/org.eclipse.core.runtime/plugin.xml
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/ConfigurationElement.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/ConfigurationProperty.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/DefaultPlugin.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/Extension.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/ExtensionPoint.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/FragmentDescriptor.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/IModel.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/IPluginVisitor.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/InternalFactory.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/Library.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginClassLoader.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginDescriptor.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginParser.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginPrerequisite.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginRegistry.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryCacheReader.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryCacheWriter.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryLoader.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryResolver.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryWriter.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/AdapterManager.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Assert.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/AssertionFailedException.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/AuthorizationDatabase.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Cipher.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/CipherInputStream.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/CipherOutputStream.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/InternalPlatform.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Log.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformLogListener.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformMetaArea.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformURLFragmentConnection.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformURLPluginConnection.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformURLPluginHandlerFactory.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PluginStats.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Policy.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/RuntimeStats.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/SafeFileInputStream.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/SafeFileOutputStream.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/URLTool.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/messages.properties
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/CoreException.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IAdaptable.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IAdapterFactory.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IAdapterManager.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IConfigurationElement.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IExecutableExtension.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IExtension.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IExtensionPoint.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ILibrary.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ILog.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ILogListener.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPath.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPluginDescriptor.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPluginPrerequisite.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPluginRegistry.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IProgressMonitor.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ISafeRunnable.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IStatus.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/MultiStatus.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/NullProgressMonitor.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/OperationCanceledException.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Path.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Platform.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/PlatformObject.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Plugin.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/PluginVersionIdentifier.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ProgressMonitorWrapper.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/QualifiedName.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Status.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/SubProgressMonitor.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ComponentModel.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ConfigurationElementModel.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ConfigurationModel.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ConfigurationPropertyModel.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ExtensionModel.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ExtensionPointModel.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/Factory.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/InstallModel.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/LibraryModel.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/PluginDescriptorModel.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/PluginFragmentModel.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/PluginModel.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/PluginModelObject.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/PluginPrerequisiteModel.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/PluginRegistryModel.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/URLModel.java
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/package.html
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/package.html
Cherrypick from master 2001-08-10 18:19:38 UTC dwilson <dwilson> 'Some error reporting + 1GGEPM1: ITPCORE:WIN2000 - More than one runtime element allowed in plugin.xml':
    bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Messages.properties
diff --git a/bundles/org.eclipse.core.runtime/.classpath b/bundles/org.eclipse.core.runtime/.classpath
new file mode 100644
index 0000000..3483c51
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+    <classpathentry kind="var" path="JRE_LIB" rootpath="JRE_SRCROOT" sourcepath="JRE_SRC"/>
+    <classpathentry kind="src" path="/org.eclipse.core.boot"/>
+    <classpathentry kind="src" path="Eclipse Core Runtime"/>
+    <classpathentry kind="var" path="TARGET/org.apache.xerces/xerces.jar"/>
+    <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/bundles/org.eclipse.core.runtime/.cvsignore b/bundles/org.eclipse.core.runtime/.cvsignore
new file mode 100644
index 0000000..c5e82d7
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/.cvsignore
@@ -0,0 +1 @@
+bin
\ No newline at end of file
diff --git a/bundles/org.eclipse.core.runtime/.options b/bundles/org.eclipse.core.runtime/.options
new file mode 100644
index 0000000..c1fa3e2
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/.options
@@ -0,0 +1,18 @@
+org.eclipse.core.runtime/debug=true

+org.eclipse.core.runtime/registry/debug=false

+org.eclipse.core.runtime/registry/debug/resolve=false

+org.eclipse.core.runtime/loader/debug=false

+org.eclipse.core.runtime/loader/debug/create=false

+org.eclipse.core.runtime/loader/debug/activateplugin=false

+org.eclipse.core.runtime/loader/debug/actions=false

+org.eclipse.core.runtime/loader/debug/success=false

+org.eclipse.core.runtime/loader/debug/failure=false

+org.eclipse.core.runtime/loader/debug/filter/loader=*

+org.eclipse.core.runtime/loader/debug/filter/class=*

+org.eclipse.core.runtime/loader/debug/filter/resource=*

+org.eclipse.core.runtime/loader/debug/filter/native=*

+org.eclipse.core.runtime/url/debug=false

+org.eclipse.core.runtime/url/debug/connect=false

+org.eclipse.core.runtime/url/debug/cachelookup=false

+org.eclipse.core.runtime/url/debug/cachecopy=false

+org.eclipse.core.runtime/update/debug=false
\ No newline at end of file
diff --git a/bundles/org.eclipse.core.runtime/.vcm_meta b/bundles/org.eclipse.core.runtime/.vcm_meta
new file mode 100644
index 0000000..559fef2
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/.vcm_meta
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<project-description>

+	<comment></comment>

+	<nature id="org.eclipse.jdt.core.javanature"/>

+	<reference project-name="org.eclipse.core.boot"/>

+	<builder name="org.eclipse.jdt.core.javabuilder">

+	</builder>

+</project-description>

diff --git a/bundles/org.eclipse.core.runtime/build.properties b/bundles/org.eclipse.core.runtime/build.properties
new file mode 100644
index 0000000..d3c51b3
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/build.properties
@@ -0,0 +1,8 @@
+# VAJ build contribution

+build.includes=doc/,.options,plugin.jars,plugin.xml,build.properties,plugin.properties

+build.vaj.Eclipse\ Core\ Runtime=Eclipse Core Runtime

+

+# Eclipse build contribution

+source.runtime.jar=Eclipse Core Runtime

+bin.includes=.options,plugin.xml,*.jar,plugin.properties

+javadoc.packages=org.eclipse.core.runtime.*

diff --git a/bundles/org.eclipse.core.runtime/doc/hglegal.htm b/bundles/org.eclipse.core.runtime/doc/hglegal.htm
new file mode 100644
index 0000000..b071dbd
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/doc/hglegal.htm
@@ -0,0 +1,14 @@
+<!doctype html public "-//w3c//dtd html 4.0 transitional//en">

+<html>

+<head>

+   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">

+   <meta name="GENERATOR" content="Mozilla/4.73 [en] (Win98; U) [Netscape]">

+   <title>Legal Notices</title>

+</head>

+<body>

+

+<h3>

+<a NAME="Notices"></a>Notices</h3>

+(c) Copyright IBM Corp. 2000, 2001. All Rights Reserved.

+</body>

+</html>

diff --git a/bundles/org.eclipse.core.runtime/doc/ngibmcpy.gif b/bundles/org.eclipse.core.runtime/doc/ngibmcpy.gif
new file mode 100644
index 0000000..360f8e9
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/doc/ngibmcpy.gif
Binary files differ
diff --git a/bundles/org.eclipse.core.runtime/doc/org_eclipse_core_runtime.html b/bundles/org.eclipse.core.runtime/doc/org_eclipse_core_runtime.html
new file mode 100644
index 0000000..bc20559
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/doc/org_eclipse_core_runtime.html
@@ -0,0 +1,27 @@
+<!doctype html public "-//w3c//dtd html 4.0 transitional//en">

+<html>

+<head>

+   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">

+   <title>Workbench Extension Points</title>

+</head>

+<body link="#0000FF" vlink="#800080">

+

+<center>

+<h1>Core Runtime Plug-in</h1></center>

+This document lists all of the extension points that the core runtime makes available to tool developers.

+<p>

+<hr WIDTH="100%">

+<h1>

+General Extension Points</h1>

+The following extension points can be used to extend the fundamental capabilities

+of the runtime plug-in:

+<ul>

+<li>

+<a href="org_eclipse_core_runtime_applications.html">org.eclipse.core.runtime.applications</a></li>

+

+<li>

+<a href="org_eclipse_core_runtime_urlHandlers.html">org.eclipse.core.runtime.urlHandlers</a></li>

+</ul>

+<a href="hglegal.htm"><img SRC="ngibmcpy.gif" ALT="Copyright IBM Corp. 2000, 2001.  All Rights Reserved." BORDER=0 height=12 width=195></a>

+</body>

+</html>

diff --git a/bundles/org.eclipse.core.runtime/doc/org_eclipse_core_runtime_applications.html b/bundles/org.eclipse.core.runtime/doc/org_eclipse_core_runtime_applications.html
new file mode 100644
index 0000000..07c59b2
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/doc/org_eclipse_core_runtime_applications.html
@@ -0,0 +1,65 @@
+<!doctype html public "-//w3c//dtd html 4.0 transitional//en">

+<html>

+<head>

+   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">

+   <title>Workbench Extension Points</title>

+</head>

+<body link="#0000FF" vlink="#800080">

+

+<center>

+<h1>

+Applications</h1></center>

+<b><i>Identifier: </i></b>org.eclipse.core.runtime.applications<p><b><i>Description:

+</i></b>Platform runtime supports plug-ins which would like to declare main

+entry points.&nbsp; That is, programs which would like to run using the platform

+runtime but yet control all aspects of execution can declare themselves as an <i>application</i>.&nbsp;

+Declared applications can be run directly from the main platform launcher by

+specifying the <i>-application</i> argument where the parameter is the id of an

+extension supplied to the applications extension point described here.&nbsp;

+This application is instantiated and run by the platform.&nbsp; Platform clients

+can also use the platform to lookup and run multiple applications.&nbsp;&nbsp;

+<p><b><i>Configuration Markup:</i></b>

+<p><tt>&nbsp;&nbsp; &lt;!ELEMENT application run?></tt>

+<p>

+<tt>&nbsp;&nbsp; &lt;!ELEMENT run parameter*></tt>

+<br><tt>&nbsp;&nbsp; &lt;!ATTLIST run</tt>

+<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; class&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

+CDATA #REQUIRED</tt>

+<br><tt>&nbsp;&nbsp; ></tt>

+<ul>

+<li>

+<b>class -</b> the fully-qualified name of a class which implements&nbsp; <tt>org.eclipse.core.boot.IPlatformRunnable</tt>.</li>

+</ul>

+<tt>&nbsp;&nbsp; &lt;!ELEMENT parameter EMPTY></tt>

+<br><tt>&nbsp;&nbsp; &lt;!ATTLIST parameter</tt>

+<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; name&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

+CDATA #REQUIRED</tt>

+<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; value&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

+CDATA #REQUIRED</tt>

+<br><tt>&nbsp;&nbsp; ></tt>

+<ul>

+<li>

+<b>name</b> - the name of this parameter made available to instances of

+the specified application class</li>

+

+<li>

+<b>value</b> - an arbitrary value associated with the given name and made

+available to instances of the specified application class</li>

+</ul>

+<b><i>Examples:</i></b>

+<p>Following is an example of a builder configuration:

+<p><tt>&nbsp;&nbsp; &lt;extension id=&quot;coolApplication&quot; point=&quot;org.eclipse.core.runtime.applications&quot;&gt;</tt>

+<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;application&gt;</tt>

+<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;run class=&quot;com.xyz.applications.Cool&quot;&gt;</tt>

+<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

+&lt;parameter name="optimize" value="true"/></tt>

+<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/run></tt>

+<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/application&gt;</tt>

+<br><tt>&nbsp;&nbsp; &lt;/extension></tt>

+<p><b><i>API Information</i>: </b>The value of the <tt>class</tt> attribute

+must represent an implementor of <tt>org.eclipse.core.boot.IPlatformRunnable</tt>.

+<p><b><i>Supplied Implementation:</i></b> The platform itself supplies a number

+of applications including the platform workbench itself.

+<p><a href="hglegal.htm"><img SRC="ngibmcpy.gif" ALT="Copyright IBM Corp. 2000, 2001.  All Rights Reserved." BORDER=0 height=12 width=195></a>

+</body>

+</html>

diff --git a/bundles/org.eclipse.core.runtime/doc/org_eclipse_core_runtime_urlHandlers.html b/bundles/org.eclipse.core.runtime/doc/org_eclipse_core_runtime_urlHandlers.html
new file mode 100644
index 0000000..b1931c0
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/doc/org_eclipse_core_runtime_urlHandlers.html
@@ -0,0 +1,45 @@
+<!doctype html public "-//w3c//dtd html 4.0 transitional//en">

+<html>

+<head>

+   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">

+   <meta name="GENERATOR" content="Mozilla/4.5 [en] (WinNT; U) [Netscape]">

+   <title>Workbench Extension Points</title>

+</head>

+<body link="#0000FF" vlink="#800080">

+

+<center>

+<h1>

+URL Stream Handlers</h1></center>

+<b><i>Identifier: </i></b>org.eclipse.core.runtime.urlHandlers

+<p><b><i>Description:

+</i></b>This extension point is used to register

+additional URL handlers to the platform search path. Note, that because

+of the platform class loader structure, URL handlers registered by a plug-in

+using the standard Java mechanisms will not be found.

+<p><b><i>Configuration Markup:</i></b>

+<p><tt>&nbsp;&nbsp; &lt;!ELEMENT handler EMPTY></tt>

+<p><tt>&nbsp;&nbsp; &lt;!ATTLIST handler</tt>

+<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; protocol&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

+CDATA #REQUIRED</tt>

+<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; class&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

+CDATA #REQUIRED</tt>

+<br><tt>&nbsp;&nbsp; ></tt>

+<ul>

+<li>

+<b>protocol -</b> URL protocol</li>

+

+<li>

+<b>class</b> - URL stream handler contributed by plug-in</li>

+</ul>

+<b><i>Examples:</i></b>

+<p>Following is an example of a handler configuration:

+<p><tt>&nbsp;&nbsp; &lt;extension point="org.eclipse.core.runtime.urlHandlers"></tt>

+<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;handler protocol="foo" class="org.eclipse.handlers.FooHandler"/></tt>

+<br><tt>&nbsp;&nbsp; &lt;/extension></tt>

+<p><b><i>API Information</i>: </b>The value of the <tt>class</tt> attribute

+must represent an implementor of implementation of <tt>java.net.URLStreamHandler</tt>

+<p><b><i>Supplied Implementation:</i></b> The platform itself does not

+supply any URL handlers registered through this extension point..

+<p><a href="hglegal.htm"><img SRC="ngibmcpy.gif" ALT="Copyright IBM Corp. 2000, 2001.  All Rights Reserved." BORDER=0 height=12 width=195></a>

+</body>

+</html>

diff --git a/bundles/org.eclipse.core.runtime/plugin.jars b/bundles/org.eclipse.core.runtime/plugin.jars
new file mode 100644
index 0000000..5bfba12
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/plugin.jars
@@ -0,0 +1 @@
+runtime.jar=Eclipse Core Runtime

diff --git a/bundles/org.eclipse.core.runtime/plugin.properties b/bundles/org.eclipse.core.runtime/plugin.properties
new file mode 100644
index 0000000..e35523e
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/plugin.properties
@@ -0,0 +1,3 @@
+pluginName = Core Runtime

+applicationsName = Applications

+handlersName = URL Stream Handlers

diff --git a/bundles/org.eclipse.core.runtime/plugin.xml b/bundles/org.eclipse.core.runtime/plugin.xml
new file mode 100644
index 0000000..15ae645
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/plugin.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<plugin

+  name="%pluginName"

+  id="org.eclipse.core.runtime"

+  version="1.0"

+  provider-name="Object Technology International, Inc.">

+

+  <runtime>

+    <library name="runtime.jar">

+      <export name="*"/>

+    </library>

+  </runtime>

+

+  <requires>

+    <import plugin="org.apache.xerces"/>

+  </requires>

+

+  <extension-point name="%applicationsName" id="applications"/>

+  <extension-point name="%handlersName" id="urlHandlers"/>

+

+</plugin>

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/ConfigurationElement.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/ConfigurationElement.java
new file mode 100644
index 0000000..3256dfb
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/ConfigurationElement.java
@@ -0,0 +1,156 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import org.eclipse.core.runtime.model.*;

+import org.eclipse.core.internal.runtime.InternalPlatform;

+import org.eclipse.core.internal.runtime.Policy;

+import java.util.*;

+

+public class ConfigurationElement extends ConfigurationElementModel implements IConfigurationElement {

+  public ConfigurationElement()

+  {

+	super();

+  }  

+public Object createExecutableExtension(String attributeName) throws CoreException {

+	String prop = null;

+	String executable;

+	String pluginName = null;

+	String className = null;

+	Object initData = null;

+	int i;

+

+	if (attributeName != null)

+		prop = getAttribute(attributeName);

+	else {

+		// property not specified, try as element value

+		prop = getValue();

+		if (prop != null) {

+			prop = prop.trim();

+			if (prop.equals(""))

+				prop = null;

+		}

+	}

+

+	if (prop == null) {

+		// property not defined, try as a child element

+		IConfigurationElement[] exec;

+		IConfigurationElement[] parms;

+		IConfigurationElement element;

+		Hashtable initParms;

+		String pname;

+

+		exec = getChildren(attributeName);

+		if (exec.length != 0) {

+			element = exec[0]; // assumes single definition

+			pluginName = (String) element.getAttribute("plugin");

+			className = (String) element.getAttribute("class");

+			parms = element.getChildren("parameter");

+			if (parms != null) {

+				initParms = new Hashtable(parms.length + 1);

+				for (i = 0; i < parms.length; i++) {

+					pname = (String) parms[i].getAttribute("name");

+					if (pname != null)

+						initParms.put(pname, parms[i].getAttribute("value"));

+				}

+				if (!initParms.isEmpty())

+					initData = initParms;

+			}

+		}

+

+		// specified name is not a simple attribute nor child element

+		else {

+			String message = Policy.bind("plugin.extDefNotFound", attributeName);

+			IStatus status = new Status(IStatus.ERROR, Platform.PI_RUNTIME, Platform.PLUGIN_ERROR, message, null);

+			throw new CoreException(status);

+		}

+	} else {

+		// simple property or element value, parse it into its components

+		i = prop.indexOf(':');

+		if (i != -1) {

+			executable = prop.substring(0, i).trim();

+			initData = prop.substring(i + 1).trim();

+		} else

+			executable = prop;

+

+		i = executable.indexOf('/');

+		if (i != -1) {

+			pluginName = executable.substring(0, i).trim();

+			className = executable.substring(i + 1).trim();

+		} else

+			className = executable;

+	}

+

+	if (className == null || className.equals("")) {

+		String message = Policy.bind("plugin.extDefNoClass", attributeName );

+		IStatus status = new Status(IStatus.ERROR, Platform.PI_RUNTIME, Platform.PLUGIN_ERROR, message, null);

+		logError(status);

+		throw new CoreException(status);

+	}

+

+	IPluginDescriptor plugin = getDeclaringExtension().getDeclaringPluginDescriptor();

+	return ((PluginDescriptor) plugin).createExecutableExtension(pluginName, className, initData, this, attributeName);

+}

+public String getAttribute(String name) {

+

+	String s = getAttributeAsIs(name);	

+	return s==null ? null : getDeclaringExtension().getDeclaringPluginDescriptor().getResourceString(s);

+}

+public String getAttributeAsIs(String name) {

+	ConfigurationPropertyModel[] list = (ConfigurationPropertyModel[]) getProperties();

+	if (list == null)

+		return null;

+	for (int i = 0; i < list.length; i++)

+		if (name.equals(list[i].getName()))

+			return list[i].getValue();

+	return null;

+}

+public String[] getAttributeNames() {

+	ConfigurationPropertyModel[] list = getProperties();

+	if (list == null)

+		return new String[0];

+	String[] result = new String[list.length];

+	for (int i = 0; i < list.length; i++)

+		result[i] = list[i].getName();

+	return result;

+}

+public IConfigurationElement[] getChildren() {

+	ConfigurationElementModel[] list = getSubElements();

+	if (list == null)

+		return new IConfigurationElement[0];

+	IConfigurationElement[] newValues = new IConfigurationElement[list.length];

+	System.arraycopy(list, 0, newValues, 0, list.length);

+	return newValues;

+}

+public IConfigurationElement[] getChildren(String name) {

+	ConfigurationElementModel[] list = getSubElements();

+	if (list == null)

+		return new IConfigurationElement[0];

+	ArrayList children = new ArrayList();

+	for (int i = 0; i < list.length; i++) {

+		ConfigurationElementModel	element = list[i];

+		if (name.equals(element.getName()))

+			children.add(list[i]);

+	}

+	return (IConfigurationElement[]) children.toArray(new IConfigurationElement[children.size()]);

+}

+public IExtension getDeclaringExtension() {

+	return (IExtension) getParentExtension();

+}

+public String getValue() {

+	String s = getValueAsIs();

+	return s == null ? null : getDeclaringExtension().getDeclaringPluginDescriptor().getResourceString(s);

+}

+public String getValueAsIs() {

+	return super.getValue();

+}

+private void logError(IStatus status) {

+	InternalPlatform.getRuntimePlugin().getLog().log(status);

+	if (InternalPlatform.DEBUG)

+		System.out.println(status.getMessage());

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/ConfigurationProperty.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/ConfigurationProperty.java
new file mode 100644
index 0000000..20ba74d
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/ConfigurationProperty.java
@@ -0,0 +1,16 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import org.eclipse.core.runtime.model.*;

+import java.io.PrintWriter;

+

+public class ConfigurationProperty extends ConfigurationPropertyModel {

+public ConfigurationProperty() {

+	super();

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/DefaultPlugin.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/DefaultPlugin.java
new file mode 100644
index 0000000..e58798d
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/DefaultPlugin.java
@@ -0,0 +1,19 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * Dummy plugin runtime class implementation

+ */

+import org.eclipse.core.runtime.Plugin;

+import org.eclipse.core.runtime.IPluginDescriptor;

+

+public class DefaultPlugin extends Plugin {

+

+public DefaultPlugin(IPluginDescriptor descriptor) {

+	super(descriptor);

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/Extension.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/Extension.java
new file mode 100644
index 0000000..94b04d4
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/Extension.java
@@ -0,0 +1,49 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import org.eclipse.core.runtime.model.*;

+import org.eclipse.core.internal.plugins.IModel;

+import org.eclipse.core.internal.runtime.Policy;

+import java.util.*;

+

+public class Extension extends ExtensionModel implements IExtension {

+  public Extension()

+  {

+	super();

+  }  

+public IConfigurationElement[] getConfigurationElements() {

+	ConfigurationElementModel[] list = getSubElements();

+	if (list == null)

+		return new IConfigurationElement[0];

+	IConfigurationElement[] newValues = new IConfigurationElement[list.length];

+	System.arraycopy(list, 0, newValues, 0, list.length);

+	return newValues;

+}

+public IPluginDescriptor getDeclaringPluginDescriptor() {

+	return (IPluginDescriptor) getParentPluginDescriptor();

+}

+public String getExtensionPointUniqueIdentifier() {

+	return getExtensionPoint();

+}

+public String getLabel() {

+	String s = getName();

+	return s == null ? "" : ((PluginDescriptor) getDeclaringPluginDescriptor()).getResourceString(s);

+}

+public String getSimpleIdentifier() {

+	return getId();

+}

+public String getUniqueIdentifier() {

+	String simple = getSimpleIdentifier();

+	if (simple == null)

+		return null;

+	return getParentPluginDescriptor().getId() + "." + simple;

+}

+public String toString() {

+	return getParent().getPluginId() + "." + getSimpleIdentifier();

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/ExtensionPoint.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/ExtensionPoint.java
new file mode 100644
index 0000000..2875189
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/ExtensionPoint.java
@@ -0,0 +1,72 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import org.eclipse.core.runtime.model.*;

+import org.eclipse.core.internal.plugins.IModel;

+import java.util.*;

+import java.io.File;

+

+public class ExtensionPoint extends ExtensionPointModel implements IExtensionPoint {

+  public ExtensionPoint()

+  {

+	super();

+  }  

+public IConfigurationElement[] getConfigurationElements() {

+	ExtensionModel[] list = getDeclaredExtensions();

+	if (list == null)

+		return new IConfigurationElement[0];

+	ArrayList result = new ArrayList();

+	for (int i = 0; i < list.length; i++) {

+		ConfigurationElementModel[] configs = list[i].getSubElements();

+		if (configs != null)

+			for (int j = 0; j < configs.length; j++)

+				result.add(configs[j]);

+	}

+	return (IConfigurationElement[]) result.toArray(new IConfigurationElement[result.size()]);

+}

+public IPluginDescriptor getDeclaringPluginDescriptor() {

+	return (IPluginDescriptor) getParentPluginDescriptor();

+}

+public IExtension getExtension(String id) {

+	if (id == null)

+		return null;

+	ExtensionModel[] list = getDeclaredExtensions();

+	if (list == null)

+		return null;

+	for (int i = 0; i < list.length; i++) {

+		if (id.equals(((Extension) list[i]).getUniqueIdentifier()))

+			return (IExtension) list[i];

+	}

+	return null;

+}

+public IExtension[] getExtensions() {

+	ExtensionModel[] list = getDeclaredExtensions();

+	if (list == null)

+		return new IExtension[0];

+	IExtension[] newValues = new IExtension[list.length];

+	System.arraycopy(list, 0, newValues, 0, list.length);

+	return newValues;

+}

+public String getLabel() {

+	String s = getName();

+	return s == null ? "" : ((PluginDescriptor) getDeclaringPluginDescriptor()).getResourceString(s);

+}

+public java.lang.String getSchemaReference() {

+	String s = getSchema();

+	return s == null ? "" : s.replace(File.separatorChar, '/');

+}

+public String getSimpleIdentifier() {

+	return getId();

+}

+public String getUniqueIdentifier() {

+	return getParentPluginDescriptor().getId() + "." + getSimpleIdentifier();

+}

+public String toString() {

+	return getParent().getPluginId() + "." + getSimpleIdentifier();

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/FragmentDescriptor.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/FragmentDescriptor.java
new file mode 100644
index 0000000..261af03
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/FragmentDescriptor.java
Binary files differ
diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/IModel.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/IModel.java
new file mode 100644
index 0000000..d3f0db0
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/IModel.java
@@ -0,0 +1,118 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+public interface IModel {

+

+	public static final int INDENT = 2;

+	public static final int RADIX = 36;

+

+	public static final String TRUE = "true";

+	public static final String FALSE = "false";

+

+	public static final String REGISTRY = "plugin-registry";

+	public static final String REGISTRY_PATH = "path";

+

+	public static final String FRAGMENT = "fragment";

+	public static final String FRAGMENT_ID = "id";

+	public static final String FRAGMENT_NAME = "name";

+	public static final String FRAGMENT_PROVIDER = "provider-name";

+	public static final String FRAGMENT_VERSION = "version";

+	public static final String FRAGMENT_PLUGIN_ID = "plugin-id";

+	public static final String FRAGMENT_PLUGIN_VERSION = "plugin-version";

+

+	public static final String PLUGIN = "plugin";

+	public static final String PLUGIN_ID = "id";

+	public static final String PLUGIN_NAME = "name";

+	public static final String PLUGIN_VENDOR = "vendor-name";

+	public static final String PLUGIN_PROVIDER = "provider-name";

+	public static final String PLUGIN_VERSION = "version";

+	public static final String PLUGIN_CLASS = "class";

+

+	public static final String PLUGIN_REQUIRES = "requires";

+	public static final String PLUGIN_REQUIRES_PLATFORM = "platform-version";

+	public static final String PLUGIN_REQUIRES_PLUGIN = "plugin";

+	public static final String PLUGIN_REQUIRES_PLUGIN_VERSION = "version";

+	public static final String PLUGIN_REQUIRES_OPTIONAL = "optional";

+	public static final String PLUGIN_REQUIRES_IMPORT = "import";

+	public static final String PLUGIN_REQUIRES_EXPORT = "export";

+	public static final String PLUGIN_REQUIRES_MATCH = "match";

+	public static final String PLUGIN_REQUIRES_MATCH_EXACT = "exact";

+	public static final String PLUGIN_REQUIRES_MATCH_COMPATIBLE = "compatible";

+

+	public static final String PLUGIN_KEY_VERSION_SEPARATOR = "_";

+

+	public static final String RUNTIME = "runtime";

+

+	public static final String LIBRARY = "library";

+	public static final String LIBRARY_NAME = "name";

+	public static final String LIBRARY_SOURCE = "source";

+	public static final String LIBRARY_TYPE = "type";

+	public static final String LIBRARY_EXPORT = "export";

+	public static final String LIBRARY_EXPORT_MASK = "name";

+

+	public static final String EXTENSION_POINT = "extension-point";

+	public static final String EXTENSION_POINT_NAME = "name";

+	public static final String EXTENSION_POINT_ID = "id";

+	public static final String EXTENSION_POINT_SCHEMA = "schema";

+

+	public static final String EXTENSION = "extension";

+	public static final String EXTENSION_NAME = "name";

+	public static final String EXTENSION_ID = "id";

+	public static final String EXTENSION_TARGET = "point";

+

+	public static final String ELEMENT = "element";

+	public static final String ELEMENT_NAME = "name";

+	public static final String ELEMENT_VALUE = "value";

+

+	public static final String PROPERTY = "property";

+	public static final String PROPERTY_NAME = "name";

+	public static final String PROPERTY_VALUE = "value";

+

+	public static final String COMPONENT = "component";

+	public static final String COMPONENT_LABEL = "label";

+	public static final String COMPONENT_ID = "id";

+	public static final String COMPONENT_VERSION = "version";

+	public static final String COMPONENT_PROVIDER = "provider-name";

+

+	public static final String COMPONENT_DESCRIPTION = "description";

+

+	public static final String COMPONENT_URL = "url";

+

+	public static final String COMPONENT_PLUGIN = "plugin";

+	public static final String COMPONENT_PLUGIN_LABEL = "label";

+	public static final String COMPONENT_PLUGIN_ID = "id";

+	public static final String COMPONENT_PLUGIN_VERSION = "version";

+

+	public static final String COMPONENT_FRAGMENT = "fragment";

+	public static final String COMPONENT_FRAGMENT_LABEL = "label";

+	public static final String COMPONENT_FRAGMENT_ID = "id";

+	public static final String COMPONENT_FRAGMENT_VERSION = "version";

+

+	public static final String CONFIGURATION = "configuration";

+	public static final String CONFIGURATION_LABEL = "label";

+	public static final String CONFIGURATION_ID = "id";

+	public static final String CONFIGURATION_VERSION = "version";

+	public static final String CONFIGURATION_PROVIDER = "provider-name";

+	public static final String CONFIGURATION_APPLICATION = "application";

+

+	public static final String CONFIGURATION_DESCRIPTION = "description";

+

+	public static final String CONFIGURATION_URL = "url";

+

+	public static final String CONFIGURATION_COMPONENT = "component";

+	public static final String CONFIGURATION_COMPONENT_LABEL = "label";

+	public static final String CONFIGURATION_COMPONENT_ID = "id";

+	public static final String CONFIGURATION_COMPONENT_VERSION = "version";

+	public static final String CONFIGURATION_COMPONENT_ALLOW_UPGRADE = "allowUpgrade";

+	public static final String CONFIGURATION_COMPONENT_OPTIONAL = "optional";

+

+	public static final String URL_UPDATE = "update";

+	public static final String URL_DISCOVERY = "discovery";

+	public static final String URL_URL = "url";

+	public static final String URL_LABEL = "label";

+

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/IPluginVisitor.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/IPluginVisitor.java
new file mode 100644
index 0000000..2741aa7
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/IPluginVisitor.java
@@ -0,0 +1,12 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.IPluginDescriptor;

+

+public interface IPluginVisitor {

+public void visit(IPluginDescriptor descriptor);

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/InternalFactory.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/InternalFactory.java
new file mode 100644
index 0000000..dc17967
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/InternalFactory.java
@@ -0,0 +1,48 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import org.eclipse.core.runtime.model.*;

+import org.eclipse.core.internal.runtime.InternalPlatform;

+

+public class InternalFactory extends Factory {

+public InternalFactory(MultiStatus status) {

+	super(status);

+}

+public ConfigurationElementModel createConfigurationElement() {

+	return new ConfigurationElement();

+}

+public ConfigurationPropertyModel createConfigurationProperty() {

+	return new ConfigurationProperty();

+}

+public ExtensionModel createExtension() {

+	return new Extension();

+}

+public ExtensionPointModel createExtensionPoint() {

+	return new ExtensionPoint();

+}

+

+

+

+public LibraryModel createLibrary() {

+	return new Library();

+}

+public PluginDescriptorModel createPluginDescriptor() {

+	return new PluginDescriptor();

+}

+

+public PluginFragmentModel createPluginFragment() {

+	return new FragmentDescriptor();

+}

+

+public PluginPrerequisiteModel createPluginPrerequisite() {

+	return new PluginPrerequisite();

+}

+public PluginRegistryModel createPluginRegistry() {

+	return new PluginRegistry();

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/Library.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/Library.java
new file mode 100644
index 0000000..90e7346
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/Library.java
@@ -0,0 +1,25 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import org.eclipse.core.runtime.model.*;

+import org.eclipse.core.internal.plugins.IModel;

+

+public class Library extends LibraryModel implements ILibrary {

+  public Library()

+  {

+	super();

+  }  

+public String[] getContentFilters() {

+	if (!isExported() || isFullyExported())

+		return null;

+	return getExports();

+}

+public IPath getPath() {

+	return new Path(getName());

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginClassLoader.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginClassLoader.java
new file mode 100644
index 0000000..caac29f
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginClassLoader.java
Binary files differ
diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginDescriptor.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginDescriptor.java
new file mode 100644
index 0000000..7320ac4
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginDescriptor.java
Binary files differ
diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginParser.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginParser.java
new file mode 100644
index 0000000..7936b71
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginParser.java
@@ -0,0 +1,957 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.model.*;

+import org.eclipse.core.runtime.*;

+import org.eclipse.core.internal.runtime.Policy;

+import org.apache.xerces.parsers.SAXParser;

+import java.util.Stack;

+import java.util.Vector;

+import org.xml.sax.*;

+import org.xml.sax.helpers.*;

+

+public class PluginParser extends DefaultHandler implements IModel {

+

+	// concrete object factory

+	Factory factory;

+

+	// Current State Information

+	Stack stateStack = new Stack();

+

+	// Current object stack (used to hold the current object we are

+	// populating in this plugin descriptor

+	Stack objectStack = new Stack();

+

+	// model parser

+	private static SAXParser parser;

+	

+	static {

+		initializeParser();

+	}

+

+	// Valid States

+	private final int IGNORED_ELEMENT_STATE = 0;

+	private final int INITIAL_STATE = 1;

+	private final int PLUGIN_STATE = 2;

+	private final int PLUGIN_RUNTIME_STATE = 3;

+	private final int PLUGIN_REQUIRES_STATE = 4;

+	private final int PLUGIN_EXTENSION_POINT_STATE = 5;

+	private final int PLUGIN_EXTENSION_STATE = 6;

+	private final int RUNTIME_LIBRARY_STATE = 7;

+	private final int LIBRARY_EXPORT_STATE = 8;

+	private final int PLUGIN_REQUIRES_IMPORT_STATE = 9;

+	private final int CONFIGURATION_ELEMENT_STATE = 10;

+	private final int FRAGMENT_STATE = 11;

+	private final int CONFIGURATION_STATE = 12;

+	private final int COMPONENT_STATE = 13;

+	private final int DESCRIPTION_STATE = 14;

+	private final int URL_STATE = 15;

+

+	// Keep a group of vectors as a temporary scratch space.  These

+	// vectors will be used to populate arrays in the plugin descriptor

+	// once processing of the XML file is complete.

+	private final int EXTENSION_POINT_INDEX = 0;

+	private final int EXTENSION_INDEX = 1;

+	private final int LAST_INDEX = 1;

+	private Vector scratchVectors[] = new Vector[LAST_INDEX + 1];

+	

+public PluginParser(Factory factory) {

+	super();

+	this.factory = factory;

+	parser.setContentHandler(this);

+	parser.setDTDHandler(this);

+	parser.setEntityResolver(this);

+	parser.setErrorHandler(this);

+}

+

+private static void initializeParser() {

+	parser = new SAXParser();

+	try {

+	 	((SAXParser)parser).setFeature("http://xml.org/sax/features/string-interning", true);

+	} catch (SAXException e) {

+	}

+}

+

+public void characters(char[] ch, int start, int length) {

+	int state = ((Integer) stateStack.peek()).intValue();

+	if (state == CONFIGURATION_ELEMENT_STATE) {

+		// Accept character data within an element, is when it is

+		// part of a configuration element (i.e. an element within an EXTENSION element

+		ConfigurationElementModel currentConfigElement = (ConfigurationElementModel) objectStack.peek();

+		String value = new String(ch, start, length);

+		String newValue = value.trim();

+		if (!newValue.equals("") || newValue.length() != 0)

+			currentConfigElement.setValue(newValue);

+		return;

+	} 

+	if (state == DESCRIPTION_STATE) {

+		// Accept character data within an element, is when it is part of a component or configuration 

+		// description element (i.e. an element within a COMPONENT or CONFIGURATION element

+		InstallModel model = (InstallModel) objectStack.peek();

+		String value = new String(ch, start, length).trim();

+		if (!value.equals("") || value.length() != 0)

+			model.setDescription(value);

+		return;

+	} 		

+}

+public void endDocument() {

+}

+public void endElement(String uri, String elementName, String qName) {

+	switch (((Integer) stateStack.peek()).intValue()) {

+		case IGNORED_ELEMENT_STATE :

+			stateStack.pop();

+			break;

+		case INITIAL_STATE :

+			// shouldn't get here

+			internalError (Policy.bind("parse.internalStack", elementName));

+			break;

+		case PLUGIN_STATE :

+		case FRAGMENT_STATE :

+			if (elementName.equals(PLUGIN) || elementName.equals(FRAGMENT)) {

+				stateStack.pop();

+				PluginModel root = (PluginModel) objectStack.peek();

+

+				// Put the extension points into this plugin

+				Vector extPointVector = scratchVectors[EXTENSION_POINT_INDEX];

+				if (extPointVector.size() > 0) {

+					root.setDeclaredExtensionPoints((ExtensionPointModel[]) extPointVector.toArray(new ExtensionPointModel[extPointVector.size()]));

+					scratchVectors[EXTENSION_POINT_INDEX].removeAllElements();

+				}

+

+				// Put the extensions into this plugin too

+				Vector extVector = scratchVectors[EXTENSION_INDEX];

+				if (extVector.size() > 0) {

+					root.setDeclaredExtensions((ExtensionModel[]) extVector.toArray(new ExtensionModel[extVector.size()]));

+					scratchVectors[EXTENSION_INDEX].removeAllElements();

+				}

+			}

+			break;

+		case PLUGIN_RUNTIME_STATE :

+			if (elementName.equals(RUNTIME)) {

+				stateStack.pop();

+				// take the vector of library entries and put them into the plugin

+				// descriptor

+				Vector libVector = (Vector)objectStack.pop();

+				if (libVector.size() > 0) {

+					PluginModel model = (PluginModel) objectStack.peek();

+					model.setRuntime((LibraryModel[]) libVector.toArray(new LibraryModel[libVector.size()]));

+					}

+			}

+			break;

+		case PLUGIN_REQUIRES_STATE :

+			if (elementName.equals(PLUGIN_REQUIRES)) {

+				stateStack.pop();

+				// take the vector of prerequisites and put them into the plugin

+				// descriptor

+				Vector importVector = (Vector)objectStack.pop();

+				if (importVector.size() > 0) {

+					PluginModel parentDescriptor = (PluginModel) objectStack.peek();

+					parentDescriptor.setRequires((PluginPrerequisiteModel[]) importVector.toArray(new PluginPrerequisiteModel[importVector.size()]));

+				}

+			}

+			break;

+		case PLUGIN_EXTENSION_POINT_STATE :

+			if (elementName.equals(EXTENSION_POINT)) {

+				stateStack.pop();

+			}

+			break;

+		case PLUGIN_EXTENSION_STATE :

+			if (elementName.equals(EXTENSION)) {

+				stateStack.pop();

+				// Finish up extension object

+				ExtensionModel currentExtension = (ExtensionModel) objectStack.pop();

+				PluginModel parent = (PluginModel) objectStack.peek();

+				currentExtension.setParent(parent);

+				scratchVectors[EXTENSION_INDEX].addElement(currentExtension);

+			}

+			break;

+		case RUNTIME_LIBRARY_STATE :

+			if (elementName.equals(LIBRARY)) {

+				LibraryModel curLibrary = (LibraryModel) objectStack.pop();

+				// Clean up the exports for this library entry

+				Vector exportsVector = (Vector) objectStack.pop();

+				if (exportsVector.size() > 0) {

+					curLibrary.setExports((String[]) exportsVector.toArray(new String[exportsVector.size()]));

+				}

+

+				// Add this library element to the vector "runtime" on the stack

+				Vector libraryVector = (Vector) objectStack.peek();

+				libraryVector.addElement(curLibrary);

+				stateStack.pop();

+			}

+			break;

+		case LIBRARY_EXPORT_STATE :

+			if (elementName.equals(LIBRARY_EXPORT)) {

+				stateStack.pop();

+			}

+			break;

+		case PLUGIN_REQUIRES_IMPORT_STATE :

+			if (elementName.equals(PLUGIN_REQUIRES_IMPORT)) {

+				stateStack.pop();

+			}

+			break;

+		case CONFIGURATION_ELEMENT_STATE :

+			// We don't care what the element name was

+			stateStack.pop();

+			// Now finish up the configuration element object

+			ConfigurationElementModel currentConfigElement = (ConfigurationElementModel) objectStack.pop();

+			Object parent = objectStack.peek();

+			currentConfigElement.setParent(parent);

+			if (((Integer) stateStack.peek()).intValue() == PLUGIN_EXTENSION_STATE) {

+				// Want to add this configuration element to the subelements of an extension

+				ConfigurationElementModel[] oldValues = (ConfigurationElementModel[]) ((ExtensionModel) parent).getSubElements();

+				int size = (oldValues == null) ? 0 : oldValues.length;

+				ConfigurationElementModel[] newValues = new ConfigurationElementModel[size + 1];

+				for (int i = 0; i < size; i++) {

+					newValues[i] = oldValues[i];

+				}

+				newValues[size] = currentConfigElement;

+				((ExtensionModel) parent).setSubElements(newValues);

+			} else {

+				ConfigurationElementModel[] oldValues = (ConfigurationElementModel[]) ((ConfigurationElementModel) parent).getSubElements();

+				int size = (oldValues == null) ? 0 : oldValues.length;

+				ConfigurationElementModel[] newValues = new ConfigurationElementModel[size + 1];

+				for (int i = 0; i < size; i++) {

+					newValues[i] = oldValues[i];

+				}

+				newValues[size] = currentConfigElement;

+				((ConfigurationElementModel) parent).setSubElements(newValues);

+			}

+			break;

+		case DESCRIPTION_STATE:

+			if (elementName.equals(COMPONENT_DESCRIPTION) || elementName.equals(CONFIGURATION_DESCRIPTION))

+				stateStack.pop();

+			break;

+		case URL_STATE:

+			if (elementName.equals(COMPONENT_URL) || elementName.equals(CONFIGURATION_URL)) 

+				stateStack.pop();

+			break;

+	}

+}

+public void error(SAXParseException ex) {

+	logStatus(ex);

+}

+public void fatalError(SAXParseException ex) throws SAXException {

+	logStatus(ex);

+	throw ex;

+}

+

+public void handleComponentState(String elementName, Attributes attributes) {

+

+	if (elementName.equals(COMPONENT_DESCRIPTION)) {

+		stateStack.push(new Integer(DESCRIPTION_STATE));

+		return;

+	}

+	if (elementName.equals(COMPONENT_URL)) {

+		stateStack.push(new Integer(URL_STATE));

+		return;

+	}

+	if (elementName.equals(COMPONENT_PLUGIN)) {

+		parseComponentPluginAttributes(attributes);

+		return;

+	}

+	if (elementName.equals(COMPONENT_FRAGMENT)) {

+		parseComponentFragmentAttributes(attributes);

+		return;

+	}

+	// If we get to this point, the element name is one we don't currently accept.

+	// Set the state to indicate that this element will be ignored

+	stateStack.push(new Integer(IGNORED_ELEMENT_STATE));

+	internalError(Policy.bind("parse.unknownElement", COMPONENT, elementName));

+}

+

+public void handleConfigurationState(String elementName, Attributes attributes) {

+

+	if (elementName.equals(CONFIGURATION_DESCRIPTION)) {

+		stateStack.push(new Integer(DESCRIPTION_STATE));

+		return;

+	}

+	if (elementName.equals(CONFIGURATION_URL)) {

+		stateStack.push(new Integer(URL_STATE));

+		return;

+	}

+	if (elementName.equals(CONFIGURATION_COMPONENT)) {

+		parseComponentAttributes(attributes);

+		ComponentModel component = (ComponentModel)objectStack.pop();

+		ConfigurationModel config = (ConfigurationModel)objectStack.peek();

+		Object components = addObject(component, config.getComponents());

+		config.setComponents((ComponentModel[])components);

+		return;

+	}

+	// If we get to this point, the element name is one we don't currently accept.

+	// Set the state to indicate that this element will be ignored

+	stateStack.push(new Integer(IGNORED_ELEMENT_STATE));

+	internalError(Policy.bind("parse.unknownElement", CONFIGURATION, elementName));

+}

+

+

+public void handleDescriptionState(String elementName, Attributes attributes) {

+

+	// We ignore all elements (if there are any)

+	stateStack.push(new Integer(IGNORED_ELEMENT_STATE));

+	internalError(Policy.bind("parse.unknownElement", CONFIGURATION_DESCRIPTION, elementName));

+}

+

+public void handleExtensionPointState(String elementName, Attributes attributes) {

+

+	// We ignore all elements under extension points (if there are any)

+	stateStack.push(new Integer(IGNORED_ELEMENT_STATE));

+	internalError(Policy.bind("parse.unknownElement", EXTENSION_POINT, elementName));

+}

+public void handleExtensionState(String elementName, Attributes attributes) {

+

+	// You need to change the state here even though we will be executing the same

+	// code for ExtensionState and ConfigurationElementState.  We ignore the name

+	// of the element for ConfigurationElements.  When we are wrapping up, we will

+	// want to add each configuration element object to the subElements vector of

+	// its parent configuration element object.  However, the first configuration

+	// element object we created (the last one we pop off the stack) will need to

+	// be added to a vector in the extension object called _configuration.

+	stateStack.push(new Integer(CONFIGURATION_ELEMENT_STATE));

+

+	// create a new Configuration Element and push it onto the object stack

+	ConfigurationElementModel currentConfigurationElement = factory.createConfigurationElement();

+	objectStack.push(currentConfigurationElement);

+	currentConfigurationElement.setName(elementName);

+

+	// Processing the attributes of a configuration element involves creating

+	// a new configuration property for each attribute and populating the configuration

+	// property with the name/value pair of the attribute.  Note there will be one

+	// configuration property for each attribute

+	parseConfigurationElementAttributes(attributes);

+}

+public void handleInitialState(String elementName, Attributes attributes) {

+	if (elementName.equals(PLUGIN)) {

+		stateStack.push(new Integer(PLUGIN_STATE));

+		parsePluginAttributes(attributes);

+	} else

+		if (elementName.equals(FRAGMENT)) {

+			stateStack.push(new Integer(FRAGMENT_STATE));

+			parseFragmentAttributes(attributes);

+		} else

+			if (elementName.equals(COMPONENT)) {

+				stateStack.push(new Integer(COMPONENT_STATE));

+				parseComponentAttributes(attributes);

+			} else

+				if (elementName.equals(CONFIGURATION)) {

+					stateStack.push(new Integer(CONFIGURATION_STATE));

+					parseConfigurationAttributes(attributes);

+				} else {

+					stateStack.push(new Integer(IGNORED_ELEMENT_STATE));

+					internalError(Policy.bind("parse.unknownTopElement", elementName));

+				}

+}

+public void handleLibraryExportState(String elementName, Attributes attributes) {

+

+	// All elements ignored.

+	stateStack.push(new Integer(IGNORED_ELEMENT_STATE));

+	internalError(Policy.bind("parse.unknownElement", LIBRARY_EXPORT, elementName));

+}

+public void handleLibraryState(String elementName, Attributes attributes) {

+	// The only valid element at this stage is a export

+	if (!elementName.equals(LIBRARY_EXPORT)) {

+		stateStack.push(new Integer(IGNORED_ELEMENT_STATE));

+		internalError(Policy.bind("parse.unknownElement", LIBRARY, elementName));

+		return;

+	}

+

+	// Change State

+	stateStack.push(new Integer(LIBRARY_EXPORT_STATE));

+	// The top element on the stack much be a library element

+	LibraryModel currentLib = (LibraryModel) objectStack.peek();

+

+	if (attributes == null)

+		return;

+

+	String maskValue = null;

+

+	// Process Attributes

+	int len = attributes.getLength();

+	for (int i = 0; i < len; i++) {

+		String attrName = attributes.getLocalName(i);

+		String attrValue = attributes.getValue(i).trim();

+

+		if (attrName.equals(LIBRARY_EXPORT_MASK))

+			maskValue = attrValue;

+		else 

+			internalError(Policy.bind("parse.unknownAttribute", LIBRARY, attrName));

+	}

+

+	// set up mask tables

+	// pop off the library - already in currentLib

+	objectStack.pop();

+	Vector exportMask = (Vector)objectStack.peek();

+	// push library back on

+	objectStack.push(currentLib);

+	if ((maskValue != null) && (!exportMask.contains(maskValue)))

+		exportMask.addElement(maskValue);

+}

+public void handlePluginState(String elementName, Attributes attributes) {

+

+	if (elementName.equals(RUNTIME)) {

+		// We should only have one Runtime element in a plugin or fragment

+		Object whatIsIt = objectStack.peek();

+		if ( ( (whatIsIt instanceof PluginDescriptorModel) && (((PluginDescriptorModel)objectStack.peek()).getRuntime() != null) ) ||

+		     ( (whatIsIt instanceof PluginFragmentModel) && (((PluginFragmentModel)objectStack.peek()).getRuntime() != null) ) ) {

+			// This is at least the 2nd Runtime element we have

+			// hit.  Ignore it and give an error.

+			stateStack.push(new Integer(IGNORED_ELEMENT_STATE));

+			return;

+		}

+		stateStack.push(new Integer(PLUGIN_RUNTIME_STATE));

+		// Push a new vector to hold all the library entries

+		objectStack.push(new Vector());

+		return;

+	}

+	if (elementName.equals(PLUGIN_REQUIRES)) {

+		stateStack.push(new Integer(PLUGIN_REQUIRES_STATE));

+		// Push a new vector to hold all the prerequisites

+		objectStack.push(new Vector());

+		parseRequiresAttributes(attributes);

+		return;

+	}

+	if (elementName.equals(EXTENSION_POINT)) {

+		stateStack.push(new Integer(PLUGIN_EXTENSION_POINT_STATE));

+		parseExtensionPointAttributes(attributes);

+		return;

+	}

+	if (elementName.equals(EXTENSION)) {

+		stateStack.push(new Integer(PLUGIN_EXTENSION_STATE));

+		parseExtensionAttributes(attributes);

+		return;

+	}

+

+	// If we get to this point, the element name is one we don't currently accept.

+	// Set the state to indicate that this element will be ignored

+	stateStack.push(new Integer(IGNORED_ELEMENT_STATE));

+	internalError(Policy.bind("parse.unknownElement", PLUGIN + " / " + FRAGMENT, elementName));

+}

+public void handleRequiresImportState(String elementName, Attributes attributes) {

+

+	// All elements ignored.

+	stateStack.push(new Integer(IGNORED_ELEMENT_STATE));

+	internalError(Policy.bind("parse.unknownElement", PLUGIN_REQUIRES_IMPORT, elementName));

+}

+public void handleRequiresState(String elementName, Attributes attributes) {

+

+	if (elementName.equals(PLUGIN_REQUIRES_IMPORT)) {

+		parsePluginRequiresImport(attributes);

+		return;

+	}

+	// If we get to this point, the element name is one we don't currently accept.

+	// Set the state to indicate that this element will be ignored

+	stateStack.push(new Integer(IGNORED_ELEMENT_STATE));

+	internalError(Policy.bind("parse.unknownElement", PLUGIN_REQUIRES, elementName));

+}

+public void handleRuntimeState(String elementName, Attributes attributes) {

+

+	if (elementName.equals(LIBRARY)) {

+		// Change State

+		stateStack.push(new Integer(RUNTIME_LIBRARY_STATE));

+		// Process library attributes

+		parseLibraryAttributes(attributes);

+		return;

+	}

+	// If we get to this point, the element name is one we don't currently accept.

+	// Set the state to indicate that this element will be ignored

+	stateStack.push(new Integer(IGNORED_ELEMENT_STATE));

+	internalError(Policy.bind("parse.unknownElement", RUNTIME, elementName));

+}

+

+private Object addObject(Object newElement, Object[] container) {

+	Object[] result = new ComponentModel[container == null ? 1 : container.length + 1];

+	if (container != null) 

+		System.arraycopy(container, 0, result, 0, container.length);

+	result[result.length - 1] = newElement;

+	return result;

+}

+private URLModel[] addURLElement(URLModel newElement, URLModel[] container) {

+	URLModel[] result = new URLModel[container == null ? 1 : container.length + 1];

+	if (container != null) 

+		System.arraycopy(container, 0, result, 0, container.length);

+	result[result.length - 1] = newElement;

+	return result;

+}

+private PluginDescriptorModel[] addPluginDescriptorElement(PluginDescriptorModel newElement, PluginDescriptorModel[] container) {

+	PluginDescriptorModel[] result = new PluginDescriptorModel[container == null ? 1 : container.length + 1];

+	if (container != null) 

+		System.arraycopy(container, 0, result, 0, container.length);

+	result[result.length - 1] = newElement;

+	return result;

+}

+private PluginFragmentModel[] addPluginFragmentElement(PluginFragmentModel newElement, PluginFragmentModel[] container) {

+	PluginFragmentModel[] result = new PluginFragmentModel[container == null ? 1 : container.length + 1];

+	if (container != null) 

+		System.arraycopy(container, 0, result, 0, container.length);

+	result[result.length - 1] = newElement;

+	return result;

+}

+public void handleURLState(String elementName, Attributes attributes) {

+	URLModel url = null;

+	InstallModel model = (InstallModel)objectStack.peek();

+	if (elementName.equals(URL_UPDATE)) {

+		url = parseURLAttributes(attributes);

+		model.setUpdates((URLModel [])addURLElement(url, model.getUpdates()));

+		return; 

+	} else

+		if (elementName.equals(URL_DISCOVERY)) {

+			url = parseURLAttributes(attributes);

+			model.setDiscoveries((URLModel [])addURLElement(url, model.getDiscoveries()));

+			return; 

+		}

+	// We ignore all elements (if there are any)

+	stateStack.push(new Integer(IGNORED_ELEMENT_STATE));

+}

+public void ignoreableWhitespace(char[] ch, int start, int length) {

+}

+private void logStatus(SAXParseException ex) {

+	String name = ex.getSystemId();

+	if (name == null)

+		name = "";

+	else

+		name = name.substring(1 + name.lastIndexOf("/"));

+

+	String msg;

+	if (name.equals(""))

+		msg = Policy.bind("parse.error", ex.getMessage());

+	else

+		msg = Policy.bind("parse.errorNameLineColumn", new String[] { name, Integer.toString(ex.getLineNumber()), Integer.toString(ex.getColumnNumber()), ex.getMessage()});

+	factory.error(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, msg, ex));

+}

+synchronized public InstallModel parseInstall(InputSource in) throws Exception {

+	parser.parse(in);

+	return (InstallModel) objectStack.pop();

+}

+

+synchronized public PluginModel parsePlugin(InputSource in) throws Exception {

+	parser.parse(in);

+	return (PluginModel) objectStack.pop();

+}

+

+public void parseComponentAttributes(Attributes attributes) {

+

+	ComponentModel current = factory.createComponentModel();

+	objectStack.push(current);

+

+	// process attributes

+	int len = attributes.getLength();

+	for (int i = 0; i < len; i++) {

+		String attrName = attributes.getLocalName(i);

+		String attrValue = attributes.getValue(i).trim();

+

+		if (attrName.equals(COMPONENT_ID))

+			current.setId(attrValue);

+		else

+			if (attrName.equals(COMPONENT_LABEL))

+				current.setName(attrValue);

+			else

+				if (attrName.equals(COMPONENT_VERSION))

+					current.setVersion(attrValue);

+				else

+					if (attrName.equals(COMPONENT_PROVIDER))

+						current.setProviderName(attrValue);

+					else

+						internalError(Policy.bind("parse.unknownAttribute", COMPONENT, attrName));

+	}

+}

+

+public void parseComponentFragmentAttributes(Attributes attributes) {

+

+	PluginFragmentModel current = factory.createPluginFragment();

+

+	// process attributes

+	int len = attributes.getLength();

+	for (int i = 0; i < len; i++) {

+		String attrName = attributes.getLocalName(i);

+		String attrValue = attributes.getValue(i).trim();

+

+		if (attrName.equals(COMPONENT_FRAGMENT_ID))

+			current.setId(attrValue);

+		else

+			if (attrName.equals(COMPONENT_FRAGMENT_LABEL))

+				current.setName(attrValue);

+			else

+				if (attrName.equals(COMPONENT_FRAGMENT_VERSION))

+					current.setVersion(attrValue);

+				else

+					internalError(Policy.bind("parse.unknownAttribute", COMPONENT_FRAGMENT, attrName));

+	}

+	

+	ComponentModel componentModel = (ComponentModel)objectStack.peek();

+	PluginFragmentModel fragments[] = componentModel.getFragments();

+	fragments = (PluginFragmentModel [])addPluginFragmentElement(current,fragments);

+	componentModel.setFragments(fragments);

+}

+

+public void parseComponentPluginAttributes(Attributes attributes) {

+

+	PluginDescriptorModel current = factory.createPluginDescriptor();

+

+	// process attributes

+	int len = attributes.getLength();

+	for (int i = 0; i < len; i++) {

+		String attrName = attributes.getLocalName(i);

+		String attrValue = attributes.getValue(i).trim();

+

+		if (attrName.equals(COMPONENT_PLUGIN_ID))

+			current.setId(attrValue);

+		else

+			if (attrName.equals(COMPONENT_PLUGIN_LABEL))

+				current.setName(attrValue);

+			else

+				if (attrName.equals(COMPONENT_PLUGIN_VERSION))

+					current.setVersion(attrValue);

+				else

+					internalError(Policy.bind("parse.unknownAttribute", COMPONENT_PLUGIN, attrName));

+	}

+	

+	ComponentModel componentModel = (ComponentModel)objectStack.peek();

+	PluginDescriptorModel plugins[] = componentModel.getPlugins();

+	plugins = (PluginDescriptorModel [])addPluginDescriptorElement(current,plugins);

+	componentModel.setPlugins(plugins);

+}

+

+public void parseConfigurationAttributes(Attributes attributes) {

+

+	ConfigurationModel current = factory.createConfiguration();

+	objectStack.push(current);

+

+	// process attributes

+	int len = attributes.getLength();

+	for (int i = 0; i < len; i++) {

+		String attrName = attributes.getLocalName(i);

+		String attrValue = attributes.getValue(i).trim();

+

+		if (attrName.equals(CONFIGURATION_ID))

+			current.setId(attrValue);

+		else

+			if (attrName.equals(CONFIGURATION_LABEL))

+				current.setName(attrValue);

+			else

+				if (attrName.equals(CONFIGURATION_VERSION))

+					current.setVersion(attrValue);

+				else

+					if (attrName.equals(CONFIGURATION_PROVIDER))

+						current.setProviderName(attrValue);

+					else

+						if (attrName.equals(CONFIGURATION_APPLICATION))

+							current.setApplication(attrValue);

+					else

+						internalError(Policy.bind("parse.unknownAttribute", CONFIGURATION, attrName));

+	}

+}

+

+public void parseConfigurationElementAttributes(Attributes attributes) {

+

+	ConfigurationElementModel parentConfigurationElement = (ConfigurationElementModel) objectStack.peek();

+	Vector propVector = null;

+

+	// process attributes

+	int len = (attributes != null) ? attributes.getLength() : 0;

+	if (len == 0)

+		return;

+	propVector = new Vector();

+

+	for (int i = 0; i < len; i++) {

+		String attrName = attributes.getLocalName(i);

+		String attrValue = attributes.getValue(i);

+

+		ConfigurationPropertyModel currentConfigurationProperty = factory.createConfigurationProperty();

+		currentConfigurationProperty.setName(attrName);

+		currentConfigurationProperty.setValue(attrValue);

+		propVector.addElement(currentConfigurationProperty);

+	}

+	parentConfigurationElement.setProperties((ConfigurationPropertyModel[]) propVector.toArray(new ConfigurationPropertyModel[propVector.size()]));

+	propVector = null;

+}

+public void parseExtensionAttributes(Attributes attributes) {

+

+	PluginModel parent = (PluginModel) objectStack.peek();

+	ExtensionModel currentExtension = factory.createExtension();

+	objectStack.push(currentExtension);

+

+	// Process Attributes

+	int len = (attributes != null) ? attributes.getLength() : 0;

+	for (int i = 0; i < len; i++) {

+		String attrName = attributes.getLocalName(i);

+		String attrValue = attributes.getValue(i).trim();

+

+		if (attrName.equals(EXTENSION_NAME))

+			currentExtension.setName(attrValue);

+		else

+			if (attrName.equals(EXTENSION_ID))

+				currentExtension.setId(attrValue);

+			else

+				if (attrName.equals(EXTENSION_TARGET)) {

+					// check if point is specified as a simple or qualified name

+					String targetName;

+					if (attrValue.lastIndexOf('.') == -1) {

+						String baseId = parent instanceof PluginDescriptorModel ? parent.getId() : ((PluginFragmentModel) parent).getPlugin();

+						targetName = baseId + "." + attrValue;

+					} else

+						targetName = attrValue;

+					currentExtension.setExtensionPoint(targetName);

+				}

+				else

+					internalError(Policy.bind("parse.unknownAttribute", EXTENSION, attrName));

+	}

+}

+public void parseExtensionPointAttributes(Attributes attributes) {

+

+	ExtensionPointModel currentExtPoint = factory.createExtensionPoint();

+

+	// Process Attributes

+	int len = (attributes != null) ? attributes.getLength() : 0;

+	for (int i = 0; i < len; i++) {

+		String attrName = attributes.getLocalName(i);

+		String attrValue = attributes.getValue(i).trim();

+

+		if (attrName.equals(EXTENSION_POINT_NAME))

+			currentExtPoint.setName(attrValue);

+		else

+			if (attrName.equals(EXTENSION_POINT_ID))

+				currentExtPoint.setId(attrValue);

+			else

+				if (attrName.equals(EXTENSION_POINT_SCHEMA))

+					currentExtPoint.setSchema(attrValue);

+				else

+					internalError(Policy.bind("parse.unknownAttribute", EXTENSION_POINT, attrName));

+	}

+	// currentExtPoint contains a pointer to the parent plugin descriptor.

+	PluginModel root = (PluginModel) objectStack.peek();

+	currentExtPoint.setParent(root);

+

+	// Now populate the the vector just below us on the objectStack with this extension point

+	scratchVectors[EXTENSION_POINT_INDEX].addElement(currentExtPoint);

+}

+

+public void parseFragmentAttributes(Attributes attributes) {

+	PluginFragmentModel current = factory.createPluginFragment();

+	objectStack.push(current);

+

+	// process attributes

+	int len = attributes.getLength();

+	for (int i = 0; i < len; i++) {

+		String attrName = attributes.getLocalName(i);

+		String attrValue = attributes.getValue(i).trim();

+

+		if (attrName.equals(FRAGMENT_ID))

+			current.setId(attrValue);

+		else

+			if (attrName.equals(FRAGMENT_NAME))

+				current.setName(attrValue);

+			else

+				if (attrName.equals(FRAGMENT_VERSION))

+					current.setVersion(attrValue);

+				else

+					if (attrName.equals(FRAGMENT_PROVIDER))

+						current.setProviderName(attrValue);

+					else

+						if (attrName.equals(FRAGMENT_PLUGIN_ID))

+							current.setPlugin(attrValue);

+						else

+							if (attrName.equals(FRAGMENT_PLUGIN_VERSION))

+								current.setPluginVersion(attrValue);

+							else

+								internalError(Policy.bind("parse.unknownAttribute", FRAGMENT, attrName));

+	}

+}

+

+public void parseLibraryAttributes(Attributes attributes) {

+	// Push a vector to hold the export mask 

+	objectStack.push (new Vector());

+	LibraryModel current = factory.createLibrary();

+	objectStack.push(current);

+	

+	// Now the objectStack should contain the following:

+	//	plugin descriptor or fragment (bottom of the stack)

+	//	vector to hold all the library entries

+	//  vector to hold the export mask for this library entry

+	//  this library entry (top of the stack)

+

+	// process attributes

+	int len = (attributes != null) ? attributes.getLength() : 0;

+	for (int i = 0; i < len; i++) {

+		String attrName = attributes.getLocalName(i);

+		String attrValue = attributes.getValue(i).trim();

+

+		if (attrName.equals(LIBRARY_NAME))

+			current.setName(attrValue);

+		else

+			if (attrName.equals(LIBRARY_TYPE))

+				current.setType(attrValue.toLowerCase());

+			else

+				internalError(Policy.bind("parse.unknownAttribute", LIBRARY, attrName));

+	}

+}

+public void parsePluginAttributes(Attributes attributes) {

+

+	PluginDescriptorModel current = factory.createPluginDescriptor();

+	objectStack.push(current);

+

+	// process attributes

+	int len = attributes.getLength();

+	for (int i = 0; i < len; i++) {

+		String attrName = attributes.getLocalName(i);

+		String attrValue = attributes.getValue(i).trim();

+

+		if (attrName.equals(PLUGIN_ID))

+			current.setId(attrValue);

+		else

+			if (attrName.equals(PLUGIN_NAME))

+				current.setName(attrValue);

+			else

+				if (attrName.equals(PLUGIN_VERSION))

+					current.setVersion(attrValue);

+				else

+					if (attrName.equals(PLUGIN_VENDOR) || (attrName.equals(PLUGIN_PROVIDER)))

+						current.setProviderName(attrValue);

+					else

+						if (attrName.equals(PLUGIN_CLASS))

+							current.setPluginClass(attrValue);

+						else

+							internalError(Policy.bind("parse.unknownAttribute", PLUGIN, attrName));

+	}

+}

+

+public void parsePluginRequiresImport(Attributes attributes) {

+	PluginPrerequisiteModel current = factory.createPluginPrerequisite();

+

+	// process attributes

+	int len = (attributes != null) ? attributes.getLength() : 0;

+	for (int i = 0; i < len; i++) {

+		String attrName = attributes.getLocalName(i);

+		String attrValue = attributes.getValue(i).trim();

+

+		if (attrName.equals(PLUGIN_REQUIRES_PLUGIN))

+			current.setPlugin(attrValue);

+		else

+			if (attrName.equals(PLUGIN_REQUIRES_PLUGIN_VERSION))

+				current.setVersion(attrValue);

+			else

+				if (attrName.equals(PLUGIN_REQUIRES_OPTIONAL))

+					current.setOptional("true".equalsIgnoreCase(attrValue));

+				else

+					if (attrName.equals(PLUGIN_REQUIRES_MATCH)) {

+						if (PLUGIN_REQUIRES_MATCH_EXACT.equals(attrValue))

+							current.setMatch(true);

+						else

+							if (PLUGIN_REQUIRES_MATCH_COMPATIBLE.equals(attrValue))

+								current.setMatch(false);

+							else

+								internalError(Policy.bind("parse.validMatch", attrValue));

+					} else

+						if (attrName.equals(PLUGIN_REQUIRES_EXPORT)) {

+							if (TRUE.equals(attrValue))

+								current.setExport(true);

+							else

+								if (FALSE.equals(attrValue))

+									current.setExport(false);

+								else

+									internalError(Policy.bind("parse.validExport", attrValue));

+						} else

+							internalError(Policy.bind("parse.unknownAttribute", PLUGIN_REQUIRES_IMPORT, attrName));

+

+	}

+	// Populate the vector of prerequisites with this new element

+	((Vector)objectStack.peek()).addElement(current);

+}

+public void parseRequiresAttributes(Attributes attributes) {

+}

+

+public URLModel parseURLAttributes(Attributes attributes) {

+	URLModel current = factory.createURL();

+

+	// process attributes

+	int len = (attributes != null) ? attributes.getLength() : 0;

+	for (int i = 0; i < len; i++) {

+		String attrName = attributes.getLocalName(i);

+		String attrValue = attributes.getValue(i).trim();

+

+		if (attrName.equals(URL_URL))

+			current.setURL(attrValue);

+		else

+			if (attrName.equals(URL_LABEL))

+				current.setName(attrValue);

+	}

+	return current;

+}

+

+static String replace(String s, String from, String to) {

+	String str = s;

+	int fromLen = from.length();

+	int toLen = to.length();

+	int ix = str.indexOf(from);

+	while (ix != -1) {

+		str = str.substring(0, ix) + to + str.substring(ix + fromLen);

+		ix = str.indexOf(from, ix + toLen);

+	}

+	return str;

+}

+public void startDocument() {

+	stateStack.push(new Integer(INITIAL_STATE));

+	for (int i = 0; i <= LAST_INDEX; i++) {

+		scratchVectors[i] = new Vector();

+	}

+}

+public void startElement(String uri, String elementName, String qName, Attributes attributes) {

+	switch (((Integer) stateStack.peek()).intValue()) {

+		case INITIAL_STATE :

+			handleInitialState(elementName, attributes);

+			break;

+		case FRAGMENT_STATE :

+			handlePluginState(elementName, attributes);

+			break;

+		case PLUGIN_STATE :

+			handlePluginState(elementName, attributes);

+			break;

+		case PLUGIN_RUNTIME_STATE :

+			handleRuntimeState(elementName, attributes);

+			break;

+		case PLUGIN_REQUIRES_STATE :

+			handleRequiresState(elementName, attributes);

+			break;

+		case PLUGIN_EXTENSION_POINT_STATE :

+			handleExtensionPointState(elementName, attributes);

+			break;

+		case PLUGIN_EXTENSION_STATE :

+		case CONFIGURATION_ELEMENT_STATE :

+			handleExtensionState(elementName, attributes);

+			break;

+		case RUNTIME_LIBRARY_STATE :

+			handleLibraryState(elementName, attributes);

+			break;

+		case LIBRARY_EXPORT_STATE :

+			handleLibraryExportState(elementName, attributes);

+			break;

+		case PLUGIN_REQUIRES_IMPORT_STATE :

+			handleRequiresImportState(elementName, attributes);

+			break;

+		case COMPONENT_STATE:

+			handleComponentState(elementName, attributes);

+			break;

+		case CONFIGURATION_STATE :

+			handleConfigurationState(elementName, attributes);

+			break;

+		case DESCRIPTION_STATE :

+			handleDescriptionState(elementName, attributes);

+			break;

+		case URL_STATE :

+			handleURLState(elementName, attributes);

+			break;

+		default :

+			stateStack.push(new Integer(IGNORED_ELEMENT_STATE));

+			internalError (Policy.bind("parse.unknownTopElement", elementName));

+	}

+}

+public void warning(SAXParseException ex) {

+	logStatus(ex);

+}

+private void internalError(String message) {

+	factory.error(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, message, null));

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginPrerequisite.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginPrerequisite.java
new file mode 100644
index 0000000..9b5d01a
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginPrerequisite.java
@@ -0,0 +1,56 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import org.eclipse.core.runtime.model.*;

+

+public class PluginPrerequisite extends PluginPrerequisiteModel implements IPluginPrerequisite {

+/**

+ * @see IPluginPrerequisite

+ */

+public PluginVersionIdentifier getResolvedVersionIdentifier() {

+	String version = getResolvedVersion();

+	return version == null ? null : new PluginVersionIdentifier(version);

+}

+/**

+ * @see IPluginPrerequisite

+ */

+public String getUniqueIdentifier() {

+	return getPlugin();

+}

+/**

+ * @see IPluginPrerequisite

+ */

+public PluginVersionIdentifier getVersionIdentifier() {

+	String version = getVersion();

+	return version == null ? null : new PluginVersionIdentifier(version);

+}

+/**

+ * @see IPluginPrerequisite

+ */

+public boolean isExported() {

+	return getExport();

+}

+/**

+ * @see IPluginPrerequisite

+ */

+public boolean isMatchedAsCompatible() {

+	return !isMatchedAsExact();

+}

+/**

+ * @see IPluginPrerequisite

+ */

+public boolean isMatchedAsExact() {

+	return getMatch();

+}

+/**

+ * @see IPluginPrerequisite

+ */

+public boolean isOptional() {

+	return getOptional();

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginRegistry.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginRegistry.java
new file mode 100644
index 0000000..739cb95
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/PluginRegistry.java
@@ -0,0 +1,272 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import org.eclipse.core.runtime.model.*;

+import org.eclipse.core.internal.runtime.*;

+import java.io.*;

+import java.net.URL;

+import java.net.MalformedURLException;

+import java.util.*;

+

+public class PluginRegistry extends PluginRegistryModel implements IPluginRegistry {

+

+	private static final String URL_PROTOCOL_FILE = "file";

+	private static final String F_DEBUG_REGISTRY = ".debugregistry";

+

+	// lifecycle events

+	private static final int STARTUP = 0;

+	private static final int SHUTDOWN = 1;

+  public PluginRegistry()

+  {

+	super();

+  }  

+/**

+ * Iterate over the plug-ins in this registry.  Plug-ins are visited in dependent order.  That is, 

+ * a plug-in, A, which requires another plug-in, B, is visited before its dependents (i.e., A is 

+ * visited before B).  

+ */

+public void accept(IPluginVisitor visitor, boolean activeOnly) {

+	Map dependents = getDependentCounts(activeOnly);

+	// keep iterating until all have been visited.

+	while (!dependents.isEmpty()) {

+		// loop over the dependents list.  For each entry, if there are no dependents, visit

+		// the plugin and remove it from the list.  Make a copy of the keys so we don't end up

+		// with concurrent accesses (since we are deleting the values as we go)

+		PluginDescriptor[] keys = (PluginDescriptor[]) dependents.keySet().toArray(new PluginDescriptor[dependents.size()]);

+		for (int i = 0; i < keys.length; i++) {

+			PluginDescriptor descriptor = keys[i];

+			Integer entry = (Integer) dependents.get(descriptor);

+			if (entry != null && entry.intValue() <= 0) {

+				visitor.visit(descriptor);

+				dependents.remove(descriptor);

+				// decrement the dependent count for all of the prerequisites.

+				PluginPrerequisiteModel[] requires = descriptor.getRequires();

+				int reqSize = (requires == null) ? 0 : requires.length;

+				for (int j = 0; j < reqSize; j++) {

+					String id = ((PluginPrerequisite) requires[j]).getUniqueIdentifier();

+					PluginDescriptor prereq = (PluginDescriptor) getPlugin(id);

+					Integer count = (Integer) dependents.get(prereq);

+					if (count != null)

+						dependents.put(prereq, new Integer(count.intValue() - 1));

+				}

+			}

+		}

+	}

+}

+public IConfigurationElement[] getConfigurationElementsFor(String uniqueId) {

+	IExtensionPoint point = getExtensionPoint(uniqueId);

+	if (point == null)

+		return new IConfigurationElement[0];

+	IConfigurationElement[] result = point.getConfigurationElements();

+	return result == null ? new IConfigurationElement[0] : result;

+}

+public IConfigurationElement[] getConfigurationElementsFor(String pluginId, String pointId) {

+	IExtensionPoint point = getExtensionPoint(pluginId, pointId);

+	if (point == null)

+		return new IConfigurationElement[0];

+	IConfigurationElement[] result = point.getConfigurationElements();

+	return result == null ? new IConfigurationElement[0] : result;

+}

+public IConfigurationElement[] getConfigurationElementsFor(String pluginId, String pointId, String extensionId) {

+	IExtension extension = getExtension(pluginId, pointId, extensionId);

+	if (extension == null)

+		return new IConfigurationElement[0];

+	IConfigurationElement[] result = extension.getConfigurationElements();

+	return result == null ? new IConfigurationElement[0] : result;

+}

+/**

+ * Returns a map of the dependent counts for all plug-ins.  The map's

+ * keys are the plug-in descriptors and the values are an (<code>Integer</code>) count of

+ * descriptors which depend on that plug-in.

+ */

+private Map getDependentCounts(boolean activeOnly) {

+	IPluginDescriptor[] descriptors = getPluginDescriptors();

+	int descSize = (descriptors == null) ? 0 : descriptors.length;

+	Map dependents = new HashMap(5);

+	// build a table of all dependent counts.  The table is keyed by descriptor and

+	// the value the integer number of dependent plugins.

+	for (int i = 0; i < descSize; i++) {

+		if (activeOnly && !descriptors[i].isPluginActivated())

+			continue;

+		// ensure there is an entry for this descriptor (otherwise it will not be visited)

+		Integer entry = (Integer) dependents.get(descriptors[i]);

+		if (entry == null)

+			dependents.put(descriptors[i], new Integer(0));

+		PluginPrerequisiteModel[] requires = ((PluginDescriptor) descriptors[i]).getRequires();

+		int reqSize = (requires == null ? 0 : requires.length);

+		for (int j = 0; j < reqSize; j++) {

+			String id = ((PluginPrerequisite) requires[j]).getUniqueIdentifier();

+			PluginDescriptor prereq = (PluginDescriptor) getPlugin(id);

+			if (prereq == null || activeOnly && !prereq.isPluginActivated())

+				continue;

+			entry = (Integer) dependents.get(prereq);

+			entry = entry == null ? new Integer(1) : new Integer(entry.intValue() + 1);

+			dependents.put(prereq, entry);

+		}

+	}

+	return dependents;

+}

+public IExtension getExtension(String xptUniqueId, String extUniqueId) {

+

+	int lastdot = xptUniqueId.lastIndexOf('.');

+	if (lastdot == -1) return null;

+	return getExtension(xptUniqueId.substring(0,lastdot), xptUniqueId.substring(lastdot+1), extUniqueId); 

+	

+}

+public IExtension getExtension(String pluginId, String xptSimpleId, String extId) {

+

+	IExtensionPoint xpt = getExtensionPoint(pluginId, xptSimpleId);

+	if (xpt == null) return null;

+	return xpt.getExtension(extId);

+}

+public IExtensionPoint getExtensionPoint(String  xptUniqueId) {

+

+	int lastdot = xptUniqueId.lastIndexOf('.');

+	if (lastdot == -1) return null;

+	return getExtensionPoint(xptUniqueId.substring(0,lastdot), xptUniqueId.substring(lastdot+1)); 

+}

+public IExtensionPoint getExtensionPoint(String plugin, String xpt) {

+

+	IPluginDescriptor pd = getPluginDescriptor(plugin);

+	if (pd == null) return null;

+	return pd.getExtensionPoint(xpt);

+}

+public IExtensionPoint[] getExtensionPoints() {

+	PluginDescriptorModel[] list = getPlugins();

+	if (list == null)

+		return new IExtensionPoint[0];

+	ArrayList result = new ArrayList();

+	for (int i = 0; i < list.length; i++) {

+		ExtensionPointModel[] pointList = list[i].getDeclaredExtensionPoints();

+		if (pointList != null) {

+			for (int j = 0; j < pointList.length; j++)

+				result.add(pointList[j]);

+		}

+	}

+	return (IExtensionPoint[]) result.toArray(new IExtensionPoint[result.size()]);

+}

+public IPluginDescriptor getPluginDescriptor(String plugin) {

+	return (IPluginDescriptor) getPlugin(plugin);

+}

+public IPluginDescriptor getPluginDescriptor(String pluginId, PluginVersionIdentifier version) {

+	PluginDescriptorModel[] plugins = getPlugins(pluginId);

+	if (plugins == null || plugins.length == 0)

+		return null;

+	if (version == null)

+		// Just return the first one in the list (random)

+		return (IPluginDescriptor) plugins[0];

+	for (int i = 0; i < plugins.length; i++) {

+		IPluginDescriptor element = (IPluginDescriptor) plugins[i];

+		if (element.getVersionIdentifier().equals(version))

+			return element;

+	}

+	return null;

+}

+public IPluginDescriptor[] getPluginDescriptors() {

+	PluginDescriptorModel[] plugins = getPlugins();

+	if (plugins==null)

+		return new IPluginDescriptor[0];

+	IPluginDescriptor[] result = new IPluginDescriptor[plugins.length];

+	for (int i = 0; i < plugins.length; i++)

+		result[i] = (IPluginDescriptor) plugins[i];

+	return result;

+}

+public IPluginDescriptor[] getPluginDescriptors(String plugin) {

+	PluginDescriptorModel[] plugins = getPlugins(plugin);

+	if (plugins==null)

+		return new IPluginDescriptor[0];

+	IPluginDescriptor[] result = new IPluginDescriptor[plugins.length];

+	System.arraycopy(plugins, 0, result, 0, plugins.length);

+	return result;

+}

+void logError(IStatus status) {

+	InternalPlatform.getRuntimePlugin().getLog().log(status);

+	if (InternalPlatform.DEBUG)

+		System.out.println(status.getMessage());

+}

+public void saveRegistry() throws IOException {

+	IPath path = InternalPlatform.getMetaArea().getRegistryPath();

+	IPath tempPath = InternalPlatform.getMetaArea().getBackupFilePathFor(path);

+

+	DataOutputStream output = null;

+	try {

+		output = new DataOutputStream(new BufferedOutputStream(new SafeFileOutputStream(path.toOSString(),tempPath.toOSString())));

+	} catch (IOException ioe) {

+		String message = Policy.bind("meta.unableToCreateCache");

+		IStatus status = new Status(IStatus.ERROR, Platform.PI_RUNTIME, Platform.PLUGIN_ERROR, message, ioe);

+		logError(status);

+	}

+	try {

+		long start = System.currentTimeMillis();

+		RegistryCacheWriter cacheWriter = new RegistryCacheWriter();

+		cacheWriter.writePluginRegistry(this, output);

+		if (InternalPlatform.DEBUG)

+			System.out.println("Wrote registry: " + (System.currentTimeMillis() - start) + "ms");

+	} finally {

+		output.close();

+	}

+}

+public void flushRegistry() {

+	IPath path = InternalPlatform.getMetaArea().getRegistryPath();

+	IPath tempPath = InternalPlatform.getMetaArea().getBackupFilePathFor(path);

+	path.toFile().delete();

+	tempPath.toFile().delete();

+}

+public void debugRegistry() {

+	IPath path = InternalPlatform.getMetaArea().getLocation().append(F_DEBUG_REGISTRY);

+

+	try {

+		FileOutputStream fs = new FileOutputStream(path.toOSString());

+		PrintWriter w = new PrintWriter(fs);

+		try {

+			RegistryWriter regWriter = new RegistryWriter();

+			regWriter.writePluginRegistry(this, w, 0);

+			w.flush();

+		} finally {

+			w.close();

+		}

+	} catch (IOException ioe) {

+		String message = Policy.bind("meta.unableToCreateRegDebug");

+		IStatus status = new Status(IStatus.ERROR, Platform.PI_RUNTIME, Platform.PLUGIN_ERROR, message, ioe);

+		logError(status);

+	}

+}

+public void flushDebugRegistry() {

+	IPath path = InternalPlatform.getMetaArea().getLocation().append(F_DEBUG_REGISTRY);

+	path.toFile().delete();

+}

+public void shutdown(IProgressMonitor progress) {

+	shutdownPlugins();

+	if (progress != null)

+		progress.worked(1);

+}

+private void shutdownPlugins() {

+	IPluginVisitor visitor = new IPluginVisitor() {

+		public void visit(final IPluginDescriptor descriptor) {

+			ISafeRunnable code = new ISafeRunnable() {

+				public void run() throws Exception {

+					if (!descriptor.isPluginActivated())

+						return;

+					try {

+						Plugin plugin = descriptor.getPlugin();

+						plugin.shutdown();

+					} finally {

+						((PluginDescriptor) descriptor).doPluginDeactivation();

+					}

+				}

+				public void handleException(Throwable e) {

+					// do nothing as the exception has already been logged.

+				}

+			};

+			InternalPlatform.run(code);

+		}

+	};

+	accept(visitor, true);

+}

+public void startup(IProgressMonitor progress) {}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryCacheReader.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryCacheReader.java
new file mode 100644
index 0000000..9946daa
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryCacheReader.java
@@ -0,0 +1,971 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import org.eclipse.core.runtime.model.*;

+import org.eclipse.core.internal.plugins.*;

+import org.eclipse.core.internal.runtime.Policy;

+import org.eclipse.core.boot.BootLoader;

+import org.eclipse.core.internal.boot.LaunchInfo;

+import java.io.*;

+import java.util.ArrayList;

+

+public class RegistryCacheReader {

+

+	Factory cacheFactory;

+	// objectTable will be an array list of objects.  The objects will be things 

+	// like a plugin descriptor, extension, extension point, etc.  The integer 

+	// index value will be used in the cache to allow cross-references in the 

+	// cached registry.

+	ArrayList objectTable = null;

+

+	public MultiStatus cacheReadProblems = null;

+

+	public static final byte REGISTRY_CACHE_VERSION = 2;

+

+	public static final byte NONLABEL = 0;

+

+	public static final byte CONFIGURATION_ELEMENT_END_LABEL = 1;

+	public static final byte CONFIGURATION_ELEMENT_INDEX_LABEL = 45;

+	public static final byte CONFIGURATION_ELEMENT_LABEL = 2;

+	public static final byte CONFIGURATION_ELEMENT_PARENT_LABEL = 3;

+	public static final byte CONFIGURATION_PROPERTY_END_LABEL = 4;

+	public static final byte CONFIGURATION_PROPERTY_LABEL = 5;

+

+	public static final byte EXTENSION_END_LABEL = 6;

+	public static final byte EXTENSION_EXT_POINT_NAME_LABEL = 7;

+	public static final byte EXTENSION_INDEX_LABEL = 8;

+	public static final byte EXTENSION_PARENT_LABEL = 9;

+

+	public static final byte EXTENSION_POINT_END_LABEL = 10;

+	public static final byte EXTENSION_POINT_EXTENSIONS_LENGTH_LABEL = 11;

+	public static final byte EXTENSION_POINT_EXTENSIONS_LABEL = 12;

+	public static final byte EXTENSION_POINT_PARENT_LABEL = 13;

+	public static final byte EXTENSION_POINT_SCHEMA_LABEL = 14;

+	

+	public static final byte FRAGMENT_INDEX_LABEL = 47;

+	public static final byte FRAGMENT_LABEL = 48;

+	public static final byte FRAGMENT_END_LABEL = 49;

+	public static final byte FRAGMENT_PLUGIN_LABEL = 50;

+	public static final byte FRAGMENT_PLUGIN_VERSION_LABEL = 51;

+

+	public static final byte ID_LABEL = 15;

+	public static final byte LIBRARY_END_LABEL = 16;

+	public static final byte LIBRARY_EXPORTS_LABEL = 17;

+	public static final byte LIBRARY_EXPORTS_LENGTH_LABEL = 18;

+	public static final byte NAME_LABEL = 19;

+

+	public static final byte PLUGIN_CLASS_LABEL = 20;

+	public static final byte PLUGIN_ENABLED_LABEL = 21;

+	public static final byte PLUGIN_END_LABEL = 22;

+	public static final byte PLUGIN_EXTENSION_LABEL = 23;

+	public static final byte PLUGIN_EXTENSION_POINT_LABEL = 24;

+	public static final byte PLUGIN_INDEX_LABEL = 25;

+	public static final byte PLUGIN_LABEL = 26;

+	public static final byte PLUGIN_LOCATION_LABEL = 27;

+	public static final byte PLUGIN_LIBRARY_LABEL = 28;

+	public static final byte PLUGIN_PARENT_LABEL = 29;

+	public static final byte PLUGIN_PROVIDER_NAME_LABEL = 30;

+	public static final byte PLUGIN_REQUIRES_LABEL = 31;

+

+	public static final byte PROPERTIES_LENGTH_LABEL = 32;

+	public static final byte READONLY_LABEL = 33;

+	public static final byte REGISTRY_END_LABEL = 34;

+	public static final byte REGISTRY_INDEX_LABEL = 46;

+	public static final byte REGISTRY_LABEL = 35;

+	public static final byte REGISTRY_RESOLVED_LABEL = 36;

+	public static final byte REQUIRES_END_LABEL = 37;

+	public static final byte REQUIRES_EXPORT_LABEL = 38;

+	public static final byte REQUIRES_MATCH_LABEL = 39;

+	public static final byte REQUIRES_OPTIONAL_LABEL = 52;

+	public static final byte REQUIRES_PLUGIN_NAME_LABEL = 40;

+	public static final byte REQUIRES_RESOLVED_VERSION_LABEL = 41;

+	public static final byte SOURCE_LABEL = 53;

+	public static final byte SUBELEMENTS_LENGTH_LABEL = 42;

+	public static final byte TYPE_LABEL = 54;

+	public static final byte VALUE_LABEL = 43;

+	public static final byte VERSION_LABEL = 44;

+	

+public RegistryCacheReader(Factory factory) {

+	super();

+	cacheFactory = factory;

+	objectTable = null;

+}

+public int addToObjectTable(Object object) {

+	if (objectTable == null) {

+		objectTable = new ArrayList();

+	}

+	objectTable.add(object);

+	// return the index of the object just added (i.e. size - 1)

+	return (objectTable.size() - 1);

+

+}

+public static String decipherLabel(byte labelValue) {

+	switch (labelValue) {

+		case REGISTRY_LABEL:

+			return "<registry>";

+		case REGISTRY_RESOLVED_LABEL:

+			return "<resolved>";

+		case PLUGIN_LABEL:

+			return "<plugin>";

+		case REGISTRY_END_LABEL:

+			return "<endregistry>";

+		case READONLY_LABEL:

+			return "<readonly>";

+		case NAME_LABEL:

+			return "<name>";

+		case ID_LABEL:

+			return "<id>";

+		case PLUGIN_PROVIDER_NAME_LABEL:

+			return "<provider>";

+		case VERSION_LABEL:

+			return "<version>";

+		case PLUGIN_CLASS_LABEL:

+			return "<class>";

+		case PLUGIN_LOCATION_LABEL:

+			return "<location>";

+		case PLUGIN_ENABLED_LABEL:

+			return "<enabled>";

+		case PLUGIN_REQUIRES_LABEL:

+			return "<requires>";

+		case PLUGIN_LIBRARY_LABEL:

+			return "<library>";

+		case PLUGIN_EXTENSION_LABEL:

+			return "<extension>";

+		case PLUGIN_EXTENSION_POINT_LABEL:

+			return "<extensionPoint>";

+		case PLUGIN_END_LABEL:

+			return "<endplugin>";

+		case REQUIRES_MATCH_LABEL:

+			return "<match>";

+		case REQUIRES_EXPORT_LABEL:

+			return "<export>";

+		case REQUIRES_RESOLVED_VERSION_LABEL:

+			return "<resolved_version>";

+		case REQUIRES_PLUGIN_NAME_LABEL:

+			return "<requires_plugin_name>";

+		case REQUIRES_END_LABEL:

+			return "<endrequires>";

+		case LIBRARY_EXPORTS_LENGTH_LABEL:

+			return "<exports-length>";

+		case LIBRARY_EXPORTS_LABEL:

+			return "<exports>";

+		case LIBRARY_END_LABEL:

+			return "<endlibrary>";

+		case EXTENSION_POINT_SCHEMA_LABEL:

+			return "<schema>";

+		case EXTENSION_POINT_END_LABEL:

+			return "<endextensionPoint>";

+		case EXTENSION_EXT_POINT_NAME_LABEL:

+			return "<extension-extPt-name>";

+		case SUBELEMENTS_LENGTH_LABEL:

+			return "<subElements-length>";

+		case EXTENSION_END_LABEL:

+			return "<endextension>";

+		case CONFIGURATION_ELEMENT_LABEL:

+			return "<configuration-element>";

+		case VALUE_LABEL:

+			return "<value>";

+		case PROPERTIES_LENGTH_LABEL:

+			return "<properties-length>";

+		case CONFIGURATION_ELEMENT_END_LABEL:

+			return "<endconfiguration-element>";

+		case CONFIGURATION_PROPERTY_LABEL:

+			return "<configuration-property>";

+		case CONFIGURATION_PROPERTY_END_LABEL:

+			return "<endconfiguration-property>";

+		case PLUGIN_PARENT_LABEL:

+			return "<parentRegistry>";

+		case CONFIGURATION_ELEMENT_PARENT_LABEL:

+			return "<ConfigurationElementParent>";

+		case PLUGIN_INDEX_LABEL:

+			return "<pluginIndex>";

+		case EXTENSION_INDEX_LABEL:

+			return "<extensionIndex>";

+		case EXTENSION_POINT_PARENT_LABEL:

+			return "<ExtensionPointParent>";

+		case EXTENSION_POINT_EXTENSIONS_LENGTH_LABEL:

+			return "<extensionPointExtensionsLength>";

+		case EXTENSION_POINT_EXTENSIONS_LABEL:

+			return "<extensionPointExtensions>";

+		case EXTENSION_PARENT_LABEL:

+			return "<extensionParent>";

+		case CONFIGURATION_ELEMENT_INDEX_LABEL:

+			return "<configElementIndex>";

+		case REGISTRY_INDEX_LABEL:

+			return "<registryIndex>";

+	}

+

+	return "<unknown label>";

+}

+public boolean interpretHeaderInformation(DataInputStream in) {

+	try {

+		int version = in.readInt();

+		// install stamp

+		String installStamp = in.readUTF();

+		// OS stamp

+		String osStamp = in.readUTF();

+		// windows system stamp

+		String windowsStamp = in.readUTF();

+		// locale stamp

+		String localeStamp = in.readUTF();

+

+		return ((version == REGISTRY_CACHE_VERSION) &&

+			(installStamp.equals(LaunchInfo.getCurrent().getIdentifier())) &&

+			(osStamp.equals(BootLoader.getOS())) &&

+			(windowsStamp.equals(BootLoader.getWS())) &&

+			(localeStamp.equals(BootLoader.getNL())) );

+	} catch (IOException ioe) {

+		cacheReadProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", "HeaderInformation"), ioe));

+		return false;

+	}

+}

+public ConfigurationElementModel readConfigurationElement(DataInputStream in) {

+	ConfigurationElementModel configurationElement = cacheFactory.createConfigurationElement();

+	// Use this flag to determine if the read-only flag should be set.  You

+	// can't set it now or you won't be able to add anything more to this

+	// configuration element.

+	addToObjectTable(configurationElement);

+	boolean setReadOnlyFlag = false;

+	try {

+		byte inByte = 0;

+		boolean done = false;

+		while (!done) {

+			try {

+				inByte = in.readByte();

+			} catch (EOFException eofe) {

+				done = true;

+				break;

+			}

+			switch (inByte) {

+				case READONLY_LABEL :

+					if (in.readBoolean()) {

+						setReadOnlyFlag = true;

+					}

+					break;

+				case NAME_LABEL :

+					configurationElement.setName(in.readUTF());

+					break;

+				case VALUE_LABEL :

+					configurationElement.setValue(in.readUTF());

+					break;

+				case PROPERTIES_LENGTH_LABEL :

+					int propertiesLength = in.readInt();

+					ConfigurationPropertyModel[] properties = new ConfigurationPropertyModel[propertiesLength];

+					for (int i = 0; i < propertiesLength; i++) {

+						properties[i] = readConfigurationProperty(in);

+					}

+					configurationElement.setProperties(properties);

+					properties = null;

+					break;

+				case SUBELEMENTS_LENGTH_LABEL :

+					int subElementsLength = in.readInt();

+					ConfigurationElementModel[] subElements = new ConfigurationElementModel[subElementsLength];

+					for (int i = 0; i < subElementsLength; i++) {

+						// Do we have an index or a real configuration element?

+						switch (in.readByte()) {

+							case CONFIGURATION_ELEMENT_LABEL :

+								subElements[i] = readConfigurationElement(in);

+								break;

+							case CONFIGURATION_ELEMENT_INDEX_LABEL :

+								subElements[i] = (ConfigurationElementModel) objectTable.get(in.readInt());

+								break;

+						}

+					}

+					configurationElement.setSubElements(subElements);

+					subElements = null;

+					break;

+				case CONFIGURATION_ELEMENT_PARENT_LABEL :

+					// We know the parent already exists, just grab it.

+					configurationElement.setParent(objectTable.get(in.readInt()));

+					break;

+				case CONFIGURATION_ELEMENT_END_LABEL :

+					done = true;

+			}

+		}

+	} catch (IOException ioe) {

+		cacheReadProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", decipherLabel(CONFIGURATION_ELEMENT_LABEL)), ioe));

+		return null;

+	}

+	return configurationElement;

+}

+public ConfigurationPropertyModel readConfigurationProperty(DataInputStream in) {

+	ConfigurationPropertyModel configurationProperty = cacheFactory.createConfigurationProperty();

+	// Use this flag to determine if the read-only flag should be set.  You

+	// can't set it now or you won't be able to add anything more to this

+	// configuration property.

+	boolean setReadOnlyFlag = false;

+	try {

+		byte inByte = 0;

+		boolean done = false;

+		while (!done) {

+			try {

+				inByte = in.readByte();

+			} catch (EOFException eofe) {

+				done = true;

+				break;

+			}

+			switch (inByte) {

+				case READONLY_LABEL :

+					if (in.readBoolean()) {

+						setReadOnlyFlag = true;

+					}

+					break;

+				case NAME_LABEL :

+					configurationProperty.setName(in.readUTF());

+					break;

+				case VALUE_LABEL :

+					configurationProperty.setValue(in.readUTF());

+					break;

+				case CONFIGURATION_PROPERTY_END_LABEL :

+					done = true;

+			}

+		}

+	} catch (IOException ioe) {

+		cacheReadProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", decipherLabel(CONFIGURATION_PROPERTY_LABEL)), ioe));

+		return null;

+	}

+	return configurationProperty;

+}

+public ExtensionModel readExtension(DataInputStream in) {

+	ExtensionModel extension = cacheFactory.createExtension();

+	addToObjectTable(extension);

+	// Use this flag to determine if the read-only flag should be set.  You

+	// can't set it now or you won't be able to add anything more to this

+	// extension.

+	boolean setReadOnlyFlag = false;

+	try {

+		byte inByte = 0;

+		boolean done = false;

+		while (!done) {

+			try {

+				inByte = in.readByte();

+			} catch (EOFException eofe) {

+				done = true;

+				break;

+			}

+			switch (inByte) {

+				case READONLY_LABEL :

+					if (in.readBoolean()) {

+						setReadOnlyFlag = true;

+					}

+					break;

+				case NAME_LABEL :

+					extension.setName(in.readUTF());

+					break;

+				case ID_LABEL :

+					extension.setId(in.readUTF());

+					break;

+				case EXTENSION_EXT_POINT_NAME_LABEL :

+					extension.setExtensionPoint(in.readUTF());

+					break;

+				case SUBELEMENTS_LENGTH_LABEL :

+					int subElementsLength = in.readInt();

+					ConfigurationElementModel[] subElements = new ConfigurationElementModel[subElementsLength];

+					for (int i = 0; i < subElementsLength; i++) {

+						// Do we have a configuration element or an index into

+						// objectTable?

+						switch (in.readByte()) {

+							case CONFIGURATION_ELEMENT_LABEL :

+								subElements[i] = readConfigurationElement(in);

+								break;

+							case CONFIGURATION_ELEMENT_INDEX_LABEL :

+								subElements[i] = (ConfigurationElementModel) objectTable.get(in.readInt());

+								break;

+						}

+					}

+					extension.setSubElements(subElements);

+					subElements = null;

+					break;

+				case EXTENSION_PARENT_LABEL :

+					// Either there is a plugin or there is an index into the

+					// objectTable

+					switch (in.readByte()) {

+						case PLUGIN_LABEL :

+							extension.setParent((PluginModel)readPluginDescriptor(in));

+							break;

+						case PLUGIN_INDEX_LABEL :

+							extension.setParent((PluginModel)objectTable.get(in.readInt()));

+							break;

+						case FRAGMENT_LABEL :

+							extension.setParent((PluginModel)readPluginFragment(in));

+							break;

+						case FRAGMENT_INDEX_LABEL :

+							extension.setParent((PluginModel)objectTable.get(in.readInt()));

+							break;

+					}

+					break;

+				case EXTENSION_END_LABEL :

+					done = true;

+			}

+		}

+	} catch (IOException ioe) {

+		cacheReadProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", decipherLabel(PLUGIN_EXTENSION_LABEL)), ioe));

+		return null;

+	}

+	return extension;

+}

+public ExtensionPointModel readExtensionPoint(DataInputStream in) {

+	ExtensionPointModel extPoint = cacheFactory.createExtensionPoint();

+	addToObjectTable(extPoint);

+

+	// Use this flag to determine if the read-only flag should be set.  You

+	// can't set it now or you won't be able to add anything more to this

+	// extension point.

+	boolean setReadOnlyFlag = false;

+	int extensionLength = 0;

+	try {

+		byte inByte = 0;

+		boolean done = false;

+		while (!done) {

+			try {

+				inByte = in.readByte();

+			} catch (EOFException eofe) {

+				done = true;

+				break;

+			}

+			switch (inByte) {

+				case READONLY_LABEL :

+					if (in.readBoolean()) {

+						setReadOnlyFlag = true;

+					}

+					break;

+				case NAME_LABEL :

+					extPoint.setName(in.readUTF());

+					break;

+				case ID_LABEL :

+					extPoint.setId(in.readUTF());

+					break;

+				case EXTENSION_POINT_SCHEMA_LABEL :

+					extPoint.setSchema(in.readUTF());

+					break;

+				case EXTENSION_POINT_EXTENSIONS_LENGTH_LABEL :

+					extensionLength = in.readInt();

+					break;

+				case EXTENSION_POINT_EXTENSIONS_LABEL :

+					ExtensionModel[] extensions = new ExtensionModel[extensionLength];

+					for (int i = 0; i < extensionLength; i++) {

+						switch (in.readByte()) {

+							// Either this is an extension or an index into

+							// the objectTable

+							case PLUGIN_EXTENSION_LABEL :

+								extensions[i] = readExtension(in);

+								break;

+							case EXTENSION_INDEX_LABEL :

+								extensions[i] = (ExtensionModel) objectTable.get(in.readInt());

+								break;

+						}

+					}

+					extPoint.setDeclaredExtensions(extensions);

+					break;

+				case EXTENSION_POINT_PARENT_LABEL :

+					// We know this plugin or fragment is already in the objectTable

+					extPoint.setParent((PluginModel) objectTable.get(in.readInt()));

+					break;

+				case EXTENSION_POINT_END_LABEL :

+					done = true;

+			}

+		}

+	} catch (IOException ioe) {

+		cacheReadProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", decipherLabel(PLUGIN_EXTENSION_POINT_LABEL)), ioe));

+		return null;

+	}

+	return extPoint;

+}

+public LibraryModel readLibrary(DataInputStream in) {

+	LibraryModel library = cacheFactory.createLibrary();

+	// Use this flag to determine if the read-only flag should be set.  You

+	// can't set it now or you won't be able to add anything more to this

+	// library.

+	boolean setReadOnlyFlag = false;

+	int exportsLength = 0;

+	try {

+		byte inByte = 0;

+		boolean done = false;

+		while (!done) {

+			try {

+				inByte = in.readByte();

+			} catch (EOFException eofe) {

+				done = true;

+				break;

+			}

+			switch (inByte) {

+				case READONLY_LABEL :

+					if (in.readBoolean()) {

+						setReadOnlyFlag = true;

+					}

+					break;

+				case NAME_LABEL :

+					library.setName(in.readUTF());

+					break;

+				case LIBRARY_EXPORTS_LENGTH_LABEL :

+					exportsLength = in.readInt();

+					break;

+				case TYPE_LABEL :

+					library.setType(in.readUTF());

+					break;

+				case LIBRARY_EXPORTS_LABEL :

+					String[] exports = new String[exportsLength];

+					for (int i = 0; i < exportsLength; i++) {

+						exports[i] = in.readUTF();

+					}

+					library.setExports(exports);

+					exports = null;

+					break;

+				case LIBRARY_END_LABEL :

+					done = true;

+			}

+		}

+	} catch (IOException ioe) {

+		cacheReadProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", decipherLabel(PLUGIN_LIBRARY_LABEL)), ioe));

+		return null;

+	}

+	return library;

+}

+public PluginDescriptorModel readPluginDescriptor(DataInputStream in) {

+	PluginDescriptorModel plugin = cacheFactory.createPluginDescriptor();

+	addToObjectTable(plugin);

+	// Use this flag to determine if the read-only flag should be set.  You

+	// can't set it now or you won't be able to add anything more to this

+	// plugin.

+	boolean setReadOnlyFlag = false;

+	try {

+		byte inByte = 0;

+		boolean done = false;

+		while (!done) {

+			try {

+				inByte = in.readByte();

+			} catch (EOFException eofe) {

+				done = true;

+				break;

+			}

+			switch (inByte) {

+				case READONLY_LABEL :

+					if (in.readBoolean()) {

+						setReadOnlyFlag = true;

+					}

+					break;

+				case NAME_LABEL :

+					plugin.setName(in.readUTF());

+					break;

+				case ID_LABEL :

+					plugin.setId(in.readUTF());

+					break;

+				case PLUGIN_PROVIDER_NAME_LABEL :

+					plugin.setProviderName(in.readUTF());

+					break;

+				case VERSION_LABEL :

+					plugin.setVersion(in.readUTF());

+					break;

+				case PLUGIN_CLASS_LABEL :

+					plugin.setPluginClass(in.readUTF());

+					break;

+				case PLUGIN_LOCATION_LABEL :

+					plugin.setLocation(in.readUTF());

+					break;

+				case PLUGIN_ENABLED_LABEL :

+					plugin.setEnabled(in.readBoolean());

+					break;

+				case PLUGIN_REQUIRES_LABEL :

+					PluginPrerequisiteModel requires = readPluginPrerequisite(in);

+					// Add this prerequisite to the end of the requires list

+					PluginPrerequisiteModel[] requiresList = plugin.getRequires();

+					PluginPrerequisiteModel[] newRequiresValues = null;

+					if (requiresList == null) {

+						newRequiresValues = new PluginPrerequisiteModel[1];

+						newRequiresValues[0] = requires;

+					} else {

+						newRequiresValues = new PluginPrerequisiteModel[requiresList.length + 1];

+						System.arraycopy(requiresList, 0, newRequiresValues, 0, requiresList.length);

+						newRequiresValues[requiresList.length] = requires;

+					}

+					plugin.setRequires(newRequiresValues);

+					requires = null;

+					requiresList = newRequiresValues = null;

+					break;

+				case PLUGIN_LIBRARY_LABEL :

+					LibraryModel library = readLibrary(in);

+					// Add this library to the end of the runtime list

+					LibraryModel[] libraryList = plugin.getRuntime();

+					LibraryModel[] newLibraryValues = null;

+					if (libraryList == null) {

+						newLibraryValues = new LibraryModel[1];

+						newLibraryValues[0] = library;

+					} else {

+						newLibraryValues = new LibraryModel[libraryList.length + 1];

+						System.arraycopy(libraryList, 0, newLibraryValues, 0, libraryList.length);

+						newLibraryValues[libraryList.length] = library;

+					}

+					plugin.setRuntime(newLibraryValues);

+					library = null;

+					libraryList = newLibraryValues = null;

+					break;

+				case PLUGIN_EXTENSION_LABEL :

+					ExtensionModel extension = readExtension(in);

+					ExtensionModel[] extList = plugin.getDeclaredExtensions();

+					ExtensionModel[] newExtValues = null;

+					if (extList == null) {

+						newExtValues = new ExtensionModel[1];

+						newExtValues[0] = extension;

+					} else {

+						newExtValues = new ExtensionModel[extList.length + 1];

+						System.arraycopy(extList, 0, newExtValues, 0, extList.length);

+						newExtValues[extList.length] = extension;

+					}

+					plugin.setDeclaredExtensions(newExtValues);

+					extension = null;

+					extList = newExtValues = null;

+					break;

+				case EXTENSION_INDEX_LABEL :

+					extension = (ExtensionModel) objectTable.get(in.readInt());

+					extList = plugin.getDeclaredExtensions();

+					newExtValues = null;

+					if (extList == null) {

+						newExtValues = new ExtensionModel[1];

+						newExtValues[0] = extension;

+					} else {

+						newExtValues = new ExtensionModel[extList.length + 1];

+						System.arraycopy(extList, 0, newExtValues, 0, extList.length);

+						newExtValues[extList.length] = extension;

+					}

+					plugin.setDeclaredExtensions(newExtValues);

+					extension = null;

+					extList = newExtValues = null;

+					break;

+				case PLUGIN_EXTENSION_POINT_LABEL :

+					ExtensionPointModel extensionPoint = readExtensionPoint(in);

+					// Add this extension point to the end of the extension point list

+					ExtensionPointModel[] extPointList = plugin.getDeclaredExtensionPoints();

+					ExtensionPointModel[] newExtPointValues = null;

+					if (extPointList == null) {

+						newExtPointValues = new ExtensionPointModel[1];

+						newExtPointValues[0] = extensionPoint;

+					} else {

+						newExtPointValues = new ExtensionPointModel[extPointList.length + 1];

+						System.arraycopy(extPointList, 0, newExtPointValues, 0, extPointList.length);

+						newExtPointValues[extPointList.length] = extensionPoint;

+					}

+					plugin.setDeclaredExtensionPoints(newExtPointValues);

+					extensionPoint = null;

+					extPointList = newExtPointValues = null;

+					break;

+				case FRAGMENT_LABEL :

+					PluginFragmentModel fragment = readPluginFragment(in);

+					// Add this fragment to the end of the fragment list

+					PluginFragmentModel[] fragmentList = plugin.getFragments();

+					PluginFragmentModel[] newFragmentValues = null;

+					if (fragmentList == null) {

+						newFragmentValues = new PluginFragmentModel[1];

+						newFragmentValues[0] = fragment;

+					} else {

+						newFragmentValues = new PluginFragmentModel[fragmentList.length + 1];

+						System.arraycopy(fragmentList, 0, newFragmentValues, 0, fragmentList.length);

+						newFragmentValues[fragmentList.length] = fragment;

+					}

+					plugin.setFragments(newFragmentValues);

+					fragment = null;

+					fragmentList = newFragmentValues = null;

+					break;

+				case FRAGMENT_INDEX_LABEL :

+					fragment = (PluginFragmentModel) objectTable.get(in.readInt());

+					fragmentList = plugin.getFragments();

+					newFragmentValues = null;

+					if (fragmentList == null) {

+						newFragmentValues = new PluginFragmentModel[1];

+						newFragmentValues[0] = fragment;

+					} else {

+						newFragmentValues = new PluginFragmentModel[fragmentList.length + 1];

+						System.arraycopy(fragmentList, 0, newFragmentValues, 0, fragmentList.length);

+						newFragmentValues[fragmentList.length] = fragment;

+					}

+					plugin.setFragments(newFragmentValues);

+					fragment = null;

+					fragmentList = newFragmentValues = null;

+					break;

+				case PLUGIN_PARENT_LABEL :

+					plugin.setRegistry((PluginRegistryModel) objectTable.get(in.readInt()));

+					break;

+				case PLUGIN_END_LABEL :

+					done = true;

+			}

+		}

+	} catch (IOException ioe) {

+		cacheReadProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", decipherLabel(PLUGIN_LABEL)), ioe));

+		return null;

+	}

+	return plugin;

+}

+public PluginFragmentModel readPluginFragment(DataInputStream in) {

+	PluginFragmentModel fragment = cacheFactory.createPluginFragment();

+	addToObjectTable(fragment);

+	// Use this flag to determine if the read-only flag should be set.  You

+	// can't set it now or you won't be able to add anything more to this

+	// plugin.

+	boolean setReadOnlyFlag = false;

+	try {

+		byte inByte = 0;

+		boolean done = false;

+		while (!done) {

+			try {

+				inByte = in.readByte();

+			} catch (EOFException eofe) {

+				done = true;

+				break;

+			}

+			switch (inByte) {

+				case READONLY_LABEL :

+					if (in.readBoolean()) {

+						setReadOnlyFlag = true;

+					}

+					break;

+				case NAME_LABEL :

+					fragment.setName(in.readUTF());

+					break;

+				case ID_LABEL :

+					fragment.setId(in.readUTF());

+					break;

+				case PLUGIN_PROVIDER_NAME_LABEL :

+					fragment.setProviderName(in.readUTF());

+					break;

+				case VERSION_LABEL :

+					fragment.setVersion(in.readUTF());

+					break;

+				case PLUGIN_LOCATION_LABEL :

+					fragment.setLocation(in.readUTF());

+					break;

+				case FRAGMENT_PLUGIN_LABEL :

+					fragment.setPlugin(in.readUTF());

+					break;

+				case FRAGMENT_PLUGIN_VERSION_LABEL :

+					fragment.setPluginVersion(in.readUTF());

+					break;

+				case PLUGIN_REQUIRES_LABEL :

+					PluginPrerequisiteModel requires = readPluginPrerequisite(in);

+					// Add this prerequisite to the end of the requires list

+					PluginPrerequisiteModel[] requiresList = fragment.getRequires();

+					PluginPrerequisiteModel[] newRequiresValues = null;

+					if (requiresList == null) {

+						newRequiresValues = new PluginPrerequisiteModel[1];

+						newRequiresValues[0] = requires;

+					} else {

+						newRequiresValues = new PluginPrerequisiteModel[requiresList.length + 1];

+						System.arraycopy(requiresList, 0, newRequiresValues, 0, requiresList.length);

+						newRequiresValues[requiresList.length] = requires;

+					}

+					fragment.setRequires(newRequiresValues);

+					requires = null;

+					requiresList = newRequiresValues = null;

+					break;

+				case PLUGIN_LIBRARY_LABEL :

+					LibraryModel library = readLibrary(in);

+					// Add this library to the end of the runtime list

+					LibraryModel[] libraryList = fragment.getRuntime();

+					LibraryModel[] newLibraryValues = null;

+					if (libraryList == null) {

+						newLibraryValues = new LibraryModel[1];

+						newLibraryValues[0] = library;

+					} else {

+						newLibraryValues = new LibraryModel[libraryList.length + 1];

+						System.arraycopy(libraryList, 0, newLibraryValues, 0, libraryList.length);

+						newLibraryValues[libraryList.length] = library;

+					}

+					fragment.setRuntime(newLibraryValues);

+					library = null;

+					libraryList = newLibraryValues = null;

+					break;

+				case PLUGIN_EXTENSION_LABEL :

+					ExtensionModel extension = readExtension(in);

+					ExtensionModel[] extList = fragment.getDeclaredExtensions();

+					ExtensionModel[] newExtValues = null;

+					if (extList == null) {

+						newExtValues = new ExtensionModel[1];

+						newExtValues[0] = extension;

+					} else {

+						newExtValues = new ExtensionModel[extList.length + 1];

+						System.arraycopy(extList, 0, newExtValues, 0, extList.length);

+						newExtValues[extList.length] = extension;

+					}

+					fragment.setDeclaredExtensions(newExtValues);

+					extension = null;

+					extList = newExtValues = null;

+					break;

+				case EXTENSION_INDEX_LABEL :

+					extension = (ExtensionModel) objectTable.get(in.readInt());

+					extList = fragment.getDeclaredExtensions();

+					newExtValues = null;

+					if (extList == null) {

+						newExtValues = new ExtensionModel[1];

+						newExtValues[0] = extension;

+					} else {

+						newExtValues = new ExtensionModel[extList.length + 1];

+						System.arraycopy(extList, 0, newExtValues, 0, extList.length);

+						newExtValues[extList.length] = extension;

+					}

+					fragment.setDeclaredExtensions(newExtValues);

+					extension = null;

+					extList = newExtValues = null;

+					break;

+				case PLUGIN_EXTENSION_POINT_LABEL :

+					ExtensionPointModel extensionPoint = readExtensionPoint(in);

+					// Add this extension point to the end of the extension point list

+					ExtensionPointModel[] extPointList = fragment.getDeclaredExtensionPoints();

+					ExtensionPointModel[] newExtPointValues = null;

+					if (extPointList == null) {

+						newExtPointValues = new ExtensionPointModel[1];

+						newExtPointValues[0] = extensionPoint;

+					} else {

+						newExtPointValues = new ExtensionPointModel[extPointList.length + 1];

+						System.arraycopy(extPointList, 0, newExtPointValues, 0, extPointList.length);

+						newExtPointValues[extPointList.length] = extensionPoint;

+					}

+					fragment.setDeclaredExtensionPoints(newExtPointValues);

+					extensionPoint = null;

+					extPointList = newExtPointValues = null;

+					break;

+				case PLUGIN_PARENT_LABEL :

+					fragment.setRegistry((PluginRegistryModel) objectTable.get(in.readInt()));

+					break;

+				case FRAGMENT_END_LABEL :

+					done = true;

+			}

+		}

+	} catch (IOException ioe) {

+		cacheReadProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", decipherLabel(FRAGMENT_LABEL)), ioe));

+		return null;

+	}

+	return fragment;

+}

+public PluginPrerequisiteModel readPluginPrerequisite(DataInputStream in) {

+	PluginPrerequisiteModel requires = cacheFactory.createPluginPrerequisite();

+	// Use this flag to determine if the read-only flag should be set.  You

+	// can't set it now or you won't be able to add anything more to this

+	// prerequisite.

+	boolean setReadOnlyFlag = false;

+	try {

+		byte inByte = 0;

+		boolean done = false;

+		while (!done) {

+			try {

+				inByte = in.readByte();

+			} catch (EOFException eofe) {

+				done = true;

+				break;

+			}

+			switch (inByte) {

+				case READONLY_LABEL :

+					if (in.readBoolean()) {

+						setReadOnlyFlag = true;

+					}

+					break;

+				case NAME_LABEL :

+					requires.setName(in.readUTF());

+					break;

+				case VERSION_LABEL :

+					requires.setVersion(in.readUTF());

+					break;

+				case REQUIRES_MATCH_LABEL :

+					requires.setMatch(in.readBoolean());

+					break;

+				case REQUIRES_EXPORT_LABEL :

+					requires.setExport(in.readBoolean());

+					break;

+				case REQUIRES_OPTIONAL_LABEL :

+					requires.setOptional(in.readBoolean());

+					break;

+				case REQUIRES_RESOLVED_VERSION_LABEL :

+					requires.setResolvedVersion(in.readUTF());

+					break;

+				case REQUIRES_PLUGIN_NAME_LABEL :

+					requires.setPlugin(in.readUTF());

+					break;

+				case REQUIRES_END_LABEL :

+					done = true;

+			}

+		}

+	} catch (IOException ioe) {

+		cacheReadProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", decipherLabel(PLUGIN_REQUIRES_LABEL)), ioe));

+		return null;

+	}

+	return requires;

+}

+public PluginRegistryModel readPluginRegistry(DataInputStream in) {

+	if (cacheReadProblems == null) {

+		cacheReadProblems = new MultiStatus(Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind("meta.registryCacheReadProblems"), null);

+	}

+

+	if (!interpretHeaderInformation(in)) {

+		return null;

+	}

+	PluginRegistryModel cachedRegistry = cacheFactory.createPluginRegistry();

+	addToObjectTable(cachedRegistry);

+

+	boolean setReadOnlyFlag = false;

+	try {

+		byte inByte = 0;

+		boolean done = false;

+		while (!done) {

+			try {

+				inByte = in.readByte();

+			} catch (EOFException eofe) {

+				done = true;

+				break;

+			}

+			switch (inByte) {

+				case READONLY_LABEL :

+					if (in.readBoolean()) {

+						setReadOnlyFlag = true;

+					}

+					break;

+				case REGISTRY_RESOLVED_LABEL :

+					if (in.readBoolean()) {

+						cachedRegistry.markResolved();

+					}

+					break;

+				case PLUGIN_LABEL :

+					PluginDescriptorModel plugin = null;

+					if ((plugin = readPluginDescriptor(in)) != null) {

+						cachedRegistry.addPlugin(plugin);

+					}

+					break;

+				case PLUGIN_INDEX_LABEL :

+					plugin = (PluginDescriptorModel) objectTable.get(in.readInt());

+					cachedRegistry.addPlugin(plugin);

+					break;

+				case FRAGMENT_LABEL :

+					PluginFragmentModel fragment = null;

+					if ((fragment = readPluginFragment(in)) != null) {

+						cachedRegistry.addFragment(fragment);

+					}

+					break;

+				case FRAGMENT_INDEX_LABEL :

+					fragment = (PluginFragmentModel) objectTable.get(in.readInt());

+					cachedRegistry.addFragment(fragment);

+					break;

+				case REGISTRY_END_LABEL :

+					done = true;

+			}

+		}

+	} catch (IOException ioe) {

+		cacheReadProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", decipherLabel(REGISTRY_LABEL)), ioe));

+		return null;

+	}

+	if (setReadOnlyFlag) {

+		// If we are finished reading this registry, we don't need to worry

+		// about setting the read-only flag on other objects we might wish

+		// to write to.  So, just to be safe, mark the whole thing.

+		cachedRegistry.markReadOnly();

+	}

+	// if there are no plugins in the registry, return null instead of

+	// an empty registry?

+	PluginDescriptorModel[] pluginList = cachedRegistry.getPlugins();

+	if ((pluginList == null) || (pluginList.length == 0)) {

+		return null;

+	} else {

+		return cachedRegistry;

+	}

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryCacheWriter.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryCacheWriter.java
new file mode 100644
index 0000000..8d82062
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryCacheWriter.java
@@ -0,0 +1,609 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.boot.BootLoader;

+import org.eclipse.core.internal.boot.LaunchInfo;

+import org.eclipse.core.internal.runtime.Policy;

+import org.eclipse.core.runtime.IStatus;

+import org.eclipse.core.runtime.MultiStatus;

+import org.eclipse.core.runtime.Platform;

+import org.eclipse.core.runtime.Status;

+import org.eclipse.core.runtime.model.*;

+import java.io.DataOutputStream;

+import java.io.IOException;

+import java.util.ArrayList;

+

+public class RegistryCacheWriter {

+	// See RegistryCacheReader for constants commonly used here too.

+

+	// objectTable will be an array list of objects.  The objects will be things 

+	// like a plugin descriptor, extension, extension point, etc.  The integer 

+	// index value will be used in the cache to allow cross-references in the 

+	// cached registry.

+	ArrayList objectTable = null;

+	

+	public MultiStatus cacheWriteProblems = null;

+	

+	public static final boolean DEBUG_REGISTRY_CACHE = false;

+	

+public RegistryCacheWriter() {

+	super();

+}

+public int addToObjectTable(Object object) {

+	if (objectTable == null) {

+		objectTable = new ArrayList();

+	}

+	objectTable.add(object);

+	// return the index of the object just added (i.e. size - 1)

+	return (objectTable.size() - 1);

+

+}

+public void writeLabel(byte labelValue, DataOutputStream out) {

+	try {

+		if (DEBUG_REGISTRY_CACHE) {

+			out.writeUTF (RegistryCacheReader.decipherLabel(labelValue));

+		} else {

+			out.writeByte(labelValue);

+		}

+	} catch (IOException ioe) {

+		cacheWriteProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", RegistryCacheReader.decipherLabel(labelValue)), ioe));

+	}

+}

+public void writeConfigurationElement(ConfigurationElementModel configElement, DataOutputStream out) {

+	try {

+		// Check to see if this configuration element already exists in the

+		// objectTable.  If it is there, it has already been written to the 

+		// cache so just write out the index.

+		int configElementIndex = objectTable.indexOf(configElement);

+		if (configElementIndex != -1) {

+			// this extension is already there

+			writeLabel(RegistryCacheReader.CONFIGURATION_ELEMENT_INDEX_LABEL, out);

+			out.writeInt(configElementIndex);

+			return;

+		}

+

+		String outString;

+		// add this object to the object table first

+		addToObjectTable(configElement);

+

+		writeLabel(RegistryCacheReader.CONFIGURATION_ELEMENT_LABEL, out);

+

+		writeLabel(RegistryCacheReader.READONLY_LABEL, out);

+		out.writeBoolean(configElement.isReadOnly());

+

+		if ((outString = configElement.getName()) != null) {

+			writeLabel(RegistryCacheReader.NAME_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		if ((outString = configElement.getValue()) != null) {

+			writeLabel(RegistryCacheReader.VALUE_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		ConfigurationPropertyModel[] properties = configElement.getProperties();

+		if (properties != null) {

+			writeLabel(RegistryCacheReader.PROPERTIES_LENGTH_LABEL, out);

+			out.writeInt(properties.length);

+			for (int i = 0; i < properties.length; i++) {

+				writeConfigurationProperty(properties[i], out);

+			}

+		}

+

+		ConfigurationElementModel[] subElements = configElement.getSubElements();

+		if (subElements != null) {

+			writeLabel(RegistryCacheReader.SUBELEMENTS_LENGTH_LABEL, out);

+			out.writeInt(subElements.length);

+			for (int i = 0; i < subElements.length; i++) {

+				writeConfigurationElement(subElements[i], out);

+			}

+		}

+

+		// Write out the parent information.  We can assume that the parent has

+		// already been written out.

+		// Add the index to the registry object for this plugin

+		Object parent = configElement.getParent();

+		writeLabel(RegistryCacheReader.CONFIGURATION_ELEMENT_PARENT_LABEL, out);

+		out.writeInt(objectTable.indexOf(parent));

+

+		writeLabel(RegistryCacheReader.CONFIGURATION_ELEMENT_END_LABEL, out);

+	} catch (IOException ioe) {

+		cacheWriteProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", RegistryCacheReader.decipherLabel(RegistryCacheReader.CONFIGURATION_ELEMENT_LABEL)), ioe));

+	}

+}

+public void writeConfigurationProperty(ConfigurationPropertyModel configProperty, DataOutputStream out) {

+	try {

+		String outString;

+

+		writeLabel(RegistryCacheReader.CONFIGURATION_PROPERTY_LABEL, out);

+

+		writeLabel(RegistryCacheReader.READONLY_LABEL, out);

+		out.writeBoolean(configProperty.isReadOnly());

+

+		if ((outString = configProperty.getName()) != null) {

+			writeLabel(RegistryCacheReader.NAME_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		if ((outString = configProperty.getValue()) != null) {

+			writeLabel(RegistryCacheReader.VALUE_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		writeLabel(RegistryCacheReader.CONFIGURATION_PROPERTY_END_LABEL, out);

+	} catch (IOException ioe) {

+		cacheWriteProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", RegistryCacheReader.decipherLabel(RegistryCacheReader.CONFIGURATION_PROPERTY_LABEL)), ioe));

+	}

+}

+public void writeExtension(ExtensionModel extension, DataOutputStream out) {

+	try {

+		// Check to see if this extension already exists in the objectTable.  If it

+		// is there, it has already been written to the cache so just write out

+		// the index.

+		int extensionIndex = objectTable.indexOf(extension);

+		if (extensionIndex != -1) {

+			// this extension is already there

+			writeLabel(RegistryCacheReader.EXTENSION_INDEX_LABEL, out);

+			out.writeInt(extensionIndex);

+			return;

+		}

+		// add this object to the object table first

+		addToObjectTable(extension);

+

+		String outString;

+

+		writeLabel(RegistryCacheReader.PLUGIN_EXTENSION_LABEL, out);

+

+		writeLabel(RegistryCacheReader.READONLY_LABEL, out);

+		out.writeBoolean(extension.isReadOnly());

+

+		if ((outString = extension.getName()) != null) {

+			writeLabel(RegistryCacheReader.NAME_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		if ((outString = extension.getExtensionPoint()) != null) {

+			writeLabel(RegistryCacheReader.EXTENSION_EXT_POINT_NAME_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		if ((outString = extension.getId()) != null) {

+			writeLabel(RegistryCacheReader.ID_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		ConfigurationElementModel[] subElements = extension.getSubElements();

+		if (subElements != null) {

+			writeLabel(RegistryCacheReader.SUBELEMENTS_LENGTH_LABEL, out);

+			out.writeInt(subElements.length);

+			for (int i = 0; i < subElements.length; i++) {

+				writeConfigurationElement(subElements[i], out);

+			}

+		}

+

+		// Now worry about the parent plugin descriptor or plugin fragment

+		PluginModel parent = extension.getParent();

+		int parentIndex = objectTable.indexOf(parent);

+		writeLabel(RegistryCacheReader.EXTENSION_PARENT_LABEL, out);

+		if (parentIndex != -1) {

+			// We have already written this plugin or fragment.  Just use the index.

+			if (parent instanceof PluginDescriptorModel) {

+				writeLabel(RegistryCacheReader.PLUGIN_INDEX_LABEL, out);

+			} else /* must be a fragment */ {

+				writeLabel(RegistryCacheReader.FRAGMENT_INDEX_LABEL, out);

+			}

+			out.writeInt(parentIndex);

+		} else {

+			// We haven't visited this plugin or fragment yet, so write it explicitly

+			if (parent instanceof PluginDescriptorModel) {

+				writePluginDescriptor((PluginDescriptorModel)parent, out);

+			} else /* must be a fragment */ {

+				writePluginFragment((PluginFragmentModel)parent, out);

+			}

+		}

+

+		writeLabel(RegistryCacheReader.EXTENSION_END_LABEL, out);

+	} catch (IOException ioe) {

+		cacheWriteProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", RegistryCacheReader.decipherLabel(RegistryCacheReader.PLUGIN_EXTENSION_LABEL)), ioe));

+	}

+}

+public void writeExtensionPoint(ExtensionPointModel extPoint, DataOutputStream out) {

+	// add this object to the object table first

+	addToObjectTable(extPoint);

+	try {

+		String outString;

+

+		writeLabel(RegistryCacheReader.PLUGIN_EXTENSION_POINT_LABEL, out);

+

+		writeLabel(RegistryCacheReader.READONLY_LABEL, out);

+		out.writeBoolean(extPoint.isReadOnly());

+

+		if ((outString = extPoint.getName()) != null) {

+			writeLabel(RegistryCacheReader.NAME_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		if ((outString = extPoint.getId()) != null) {

+			writeLabel(RegistryCacheReader.ID_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		if ((outString = extPoint.getSchema()) != null) {

+			writeLabel(RegistryCacheReader.EXTENSION_POINT_SCHEMA_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		// Write out the parent's index.  We know we have

+		// already written this plugin or fragment to the cache

+		PluginModel parent = extPoint.getParent();

+		if (parent != null) {

+			int parentIndex = objectTable.indexOf(parent);

+			if (parentIndex != -1) {

+				writeLabel(RegistryCacheReader.EXTENSION_POINT_PARENT_LABEL, out);

+				out.writeInt(parentIndex);

+			}

+		}

+

+		// Now do the extensions.

+		ExtensionModel[] extensions = extPoint.getDeclaredExtensions();

+		int extLength = extensions == null ? 0 : extensions.length;

+		if (extLength != 0) {

+			writeLabel(RegistryCacheReader.EXTENSION_POINT_EXTENSIONS_LENGTH_LABEL, out);

+			out.writeInt(extLength);

+			writeLabel(RegistryCacheReader.EXTENSION_POINT_EXTENSIONS_LABEL, out);

+			for (int i = 0; i < extLength; i++) {

+				// Check to see if the extension exists in the objectTable first

+				int extensionIndex = objectTable.indexOf(extensions[i]);

+				if (extensionIndex != -1) {

+					// Already in the objectTable and written to the cache

+					writeLabel(RegistryCacheReader.EXTENSION_INDEX_LABEL, out);

+					out.writeInt(extensionIndex);

+				} else {

+					writeExtension(extensions[i], out);

+				}

+			}

+		}

+

+		writeLabel(RegistryCacheReader.EXTENSION_POINT_END_LABEL, out);

+	} catch (IOException ioe) {

+		cacheWriteProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", RegistryCacheReader.decipherLabel(RegistryCacheReader.PLUGIN_EXTENSION_POINT_LABEL)), ioe));

+	}

+}

+public void writeHeaderInformation(DataOutputStream out) {

+	try {

+		out.writeInt(RegistryCacheReader.REGISTRY_CACHE_VERSION);

+		// install stamp

+		out.writeUTF(LaunchInfo.getCurrent().getIdentifier());

+		// OS stamp

+		out.writeUTF(BootLoader.getOS());

+		// windows system stamp

+		out.writeUTF(BootLoader.getWS());

+		// locale stamp

+		out.writeUTF(BootLoader.getNL());

+	} catch (IOException ioe) {

+		cacheWriteProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", "HeaderInformation"), ioe));

+	}

+}

+public void writeLibrary(LibraryModel library, DataOutputStream out) {

+	try {

+		String outString;

+

+		writeLabel(RegistryCacheReader.PLUGIN_LIBRARY_LABEL, out);

+

+		writeLabel(RegistryCacheReader.READONLY_LABEL, out);

+		out.writeBoolean(library.isReadOnly());

+

+		if ((outString = library.getName()) != null) {

+			writeLabel(RegistryCacheReader.NAME_LABEL, out);

+			out.writeUTF(outString);

+		}

+		if ((outString = library.getType()) != null) {

+			writeLabel(RegistryCacheReader.TYPE_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		String[] exports = null;

+		if ((exports = library.getExports()) != null) {

+			writeLabel(RegistryCacheReader.LIBRARY_EXPORTS_LENGTH_LABEL, out);

+			out.writeInt(exports.length);

+			writeLabel(RegistryCacheReader.LIBRARY_EXPORTS_LABEL, out);

+			for (int i = 0; i < exports.length; i++) {

+				out.writeUTF(exports[i]);

+			}

+		}

+

+		// Don't bother caching 'isExported' and 'isFullyExported'.  There

+		// is no way of explicitly setting these fields.  They are computed

+		// from the values in the 'exports' list.

+		writeLabel(RegistryCacheReader.LIBRARY_END_LABEL, out);

+	} catch (IOException ioe) {

+		cacheWriteProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", RegistryCacheReader.decipherLabel(RegistryCacheReader.PLUGIN_LIBRARY_LABEL)), ioe));

+	}

+}

+public void writePluginDescriptor(PluginDescriptorModel plugin, DataOutputStream out) {

+

+	try {

+		// Check to see if this plugin already exists in the objectTable.  If it is there,

+		// it has already been written to the cache so just write out the index.

+		int pluginIndex = objectTable.indexOf(plugin);

+		if (pluginIndex != -1) {

+			// this plugin is already there

+			writeLabel(RegistryCacheReader.PLUGIN_INDEX_LABEL, out);

+			out.writeInt(pluginIndex);

+			return;

+		}

+

+		// add this object to the object table first

+		addToObjectTable(plugin);

+		String outString;

+

+		writeLabel(RegistryCacheReader.PLUGIN_LABEL, out);

+		writeLabel(RegistryCacheReader.READONLY_LABEL, out);

+		out.writeBoolean(plugin.isReadOnly());

+		if ((outString = plugin.getName()) != null) {

+			writeLabel(RegistryCacheReader.NAME_LABEL, out);

+			out.writeUTF(outString);

+		}

+		if ((outString = plugin.getId()) != null) {

+			writeLabel(RegistryCacheReader.ID_LABEL, out);

+			out.writeUTF(outString);

+		}

+		if ((outString = plugin.getProviderName()) != null) {

+			writeLabel(RegistryCacheReader.PLUGIN_PROVIDER_NAME_LABEL, out);

+			out.writeUTF(outString);

+		}

+		if ((outString = plugin.getVersion()) != null) {

+			writeLabel(RegistryCacheReader.VERSION_LABEL, out);

+			out.writeUTF(outString);

+		}

+		if ((outString = plugin.getPluginClass()) != null) {

+			writeLabel(RegistryCacheReader.PLUGIN_CLASS_LABEL, out);

+			out.writeUTF(outString);

+		}

+		if ((outString = plugin.getLocation()) != null) {

+			writeLabel(RegistryCacheReader.PLUGIN_LOCATION_LABEL, out);

+			out.writeUTF(outString);

+		}

+		writeLabel(RegistryCacheReader.PLUGIN_ENABLED_LABEL, out);

+		out.writeBoolean(plugin.getEnabled());

+

+		// write out prerequisites

+		PluginPrerequisiteModel[] requires = plugin.getRequires();

+		int reqSize = (requires == null) ? 0 : requires.length;

+		if (reqSize != 0) {

+			for (int i = 0; i < reqSize; i++)

+				writePluginPrerequisite(requires[i], out);

+		}

+

+		// write out library entries

+		LibraryModel[] runtime = plugin.getRuntime();

+		int runtimeSize = (runtime == null) ? 0 : runtime.length;

+		if (runtimeSize != 0) {

+			for (int i = 0; i < runtimeSize; i++) {

+				writeLibrary(runtime[i], out);

+			}

+		}

+

+		// need to worry about cross links here

+		// now do extension points

+		ExtensionPointModel[] extensionPoints = plugin.getDeclaredExtensionPoints();

+		int extPointsSize = (extensionPoints == null) ? 0 : extensionPoints.length;

+		if (extPointsSize != 0) {

+			for (int i = 0; i < extPointsSize; i++)

+				writeExtensionPoint(extensionPoints[i], out);

+		}

+

+		// and then extensions

+		ExtensionModel[] extensions = plugin.getDeclaredExtensions();

+		int extSize = (extensions == null) ? 0 : extensions.length;

+		if (extSize != 0) {

+			for (int i = 0; i < extSize; i++) {

+				writeExtension(extensions[i], out);

+			}

+		}

+

+		// and then fragments

+		PluginFragmentModel[] fragments = plugin.getFragments();

+		int fragmentSize = (fragments == null) ? 0 : fragments.length;

+		if (fragmentSize != 0) {

+			for (int i = 0; i < fragmentSize; i++) {

+				writePluginFragment(fragments[i], out);

+			}

+		}

+

+		// Add the index to the registry object for this plugin

+		PluginRegistryModel parentRegistry = plugin.getRegistry();

+		writeLabel(RegistryCacheReader.PLUGIN_PARENT_LABEL, out);

+		// We can assume that the parent registry is already written out.

+		out.writeInt(objectTable.indexOf(parentRegistry));

+

+		writeLabel(RegistryCacheReader.PLUGIN_END_LABEL, out);

+	} catch (IOException ioe) {

+		cacheWriteProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", RegistryCacheReader.decipherLabel(RegistryCacheReader.PLUGIN_LABEL)), ioe));

+	}

+}

+public void writePluginFragment(PluginFragmentModel fragment, DataOutputStream out) {

+

+	try {

+		// Check to see if this fragment already exists in the objectTable.  If it is there,

+		// it has already been written to the cache so just write out the index.

+		int fragmentIndex = objectTable.indexOf(fragment);

+		if (fragmentIndex != -1) {

+			// this fragment is already there

+			writeLabel(RegistryCacheReader.FRAGMENT_INDEX_LABEL, out);

+			out.writeInt(fragmentIndex);

+			return;

+		}

+

+		// add this object to the object table first

+		addToObjectTable(fragment);

+		String outString;

+

+		writeLabel(RegistryCacheReader.FRAGMENT_LABEL, out);

+		writeLabel(RegistryCacheReader.READONLY_LABEL, out);

+		out.writeBoolean(fragment.isReadOnly());

+		if ((outString = fragment.getName()) != null) {

+			writeLabel(RegistryCacheReader.NAME_LABEL, out);

+			out.writeUTF(outString);

+		}

+		if ((outString = fragment.getId()) != null) {

+			writeLabel(RegistryCacheReader.ID_LABEL, out);

+			out.writeUTF(outString);

+		}

+		if ((outString = fragment.getProviderName()) != null) {

+			writeLabel(RegistryCacheReader.PLUGIN_PROVIDER_NAME_LABEL, out);

+			out.writeUTF(outString);

+		}

+		if ((outString = fragment.getVersion()) != null) {

+			writeLabel(RegistryCacheReader.VERSION_LABEL, out);

+			out.writeUTF(outString);

+		}

+		if ((outString = fragment.getLocation()) != null) {

+			writeLabel(RegistryCacheReader.PLUGIN_LOCATION_LABEL, out);

+			out.writeUTF(outString);

+		}

+		if ((outString = fragment.getPlugin()) != null) {

+			writeLabel(RegistryCacheReader.FRAGMENT_PLUGIN_LABEL, out);

+			out.writeUTF(outString);

+		}

+		if ((outString = fragment.getPluginVersion()) != null) {

+			writeLabel(RegistryCacheReader.FRAGMENT_PLUGIN_VERSION_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		// write out prerequisites

+		PluginPrerequisiteModel[] requires = fragment.getRequires();

+		int reqSize = (requires == null) ? 0 : requires.length;

+		if (reqSize != 0) {

+			for (int i = 0; i < reqSize; i++)

+				writePluginPrerequisite(requires[i], out);

+		}

+

+		// write out library entries

+		LibraryModel[] runtime = fragment.getRuntime();

+		int runtimeSize = (runtime == null) ? 0 : runtime.length;

+		if (runtimeSize != 0) {

+			for (int i = 0; i < runtimeSize; i++) {

+				writeLibrary(runtime[i], out);

+			}

+		}

+

+		// need to worry about cross links here

+		// now do extension points

+		ExtensionPointModel[] extensionPoints = fragment.getDeclaredExtensionPoints();

+		int extPointsSize = (extensionPoints == null) ? 0 : extensionPoints.length;

+		if (extPointsSize != 0) {

+			for (int i = 0; i < extPointsSize; i++)

+				writeExtensionPoint(extensionPoints[i], out);

+		}

+

+		// and then extensions

+		ExtensionModel[] extensions = fragment.getDeclaredExtensions();

+		int extSize = (extensions == null) ? 0 : extensions.length;

+		if (extSize != 0) {

+			for (int i = 0; i < extSize; i++) {

+				writeExtension(extensions[i], out);

+			}

+		}

+

+		// Add the index to the registry object for this plugin

+		PluginRegistryModel parentRegistry = fragment.getRegistry();

+		writeLabel(RegistryCacheReader.PLUGIN_PARENT_LABEL, out);

+		// We can assume that the parent registry is already written out.

+		out.writeInt(objectTable.indexOf(parentRegistry));

+

+		writeLabel(RegistryCacheReader.FRAGMENT_END_LABEL, out);

+	} catch (IOException ioe) {

+		cacheWriteProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", RegistryCacheReader.decipherLabel(RegistryCacheReader.FRAGMENT_LABEL)), ioe));

+	}

+}

+public void writePluginPrerequisite(PluginPrerequisiteModel requires, DataOutputStream out) {

+	try {

+		String outString = null;

+

+		writeLabel(RegistryCacheReader.PLUGIN_REQUIRES_LABEL, out);

+

+		writeLabel(RegistryCacheReader.READONLY_LABEL, out);

+		out.writeBoolean(requires.isReadOnly());

+

+		if ((outString = requires.getName()) != null) {

+			writeLabel(RegistryCacheReader.NAME_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		if ((outString = requires.getVersion()) != null) {

+			writeLabel(RegistryCacheReader.VERSION_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		writeLabel(RegistryCacheReader.REQUIRES_MATCH_LABEL, out);

+		out.writeBoolean(requires.getMatch());

+

+		writeLabel(RegistryCacheReader.REQUIRES_EXPORT_LABEL, out);

+		out.writeBoolean(requires.getExport());

+

+		writeLabel(RegistryCacheReader.REQUIRES_OPTIONAL_LABEL, out);

+		out.writeBoolean(requires.getOptional());

+

+		if ((outString = requires.getResolvedVersion()) != null) {

+			writeLabel(RegistryCacheReader.REQUIRES_RESOLVED_VERSION_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		if ((outString = requires.getPlugin()) != null) {

+			writeLabel(RegistryCacheReader.REQUIRES_PLUGIN_NAME_LABEL, out);

+			out.writeUTF(outString);

+		}

+

+		writeLabel(RegistryCacheReader.REQUIRES_END_LABEL, out);

+	} catch (IOException ioe) {

+		cacheWriteProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", RegistryCacheReader.decipherLabel(RegistryCacheReader.PLUGIN_REQUIRES_LABEL)), ioe));

+	}

+}

+public void writePluginRegistry(PluginRegistryModel registry, DataOutputStream out) {

+	if (cacheWriteProblems == null) {

+		cacheWriteProblems = new MultiStatus(Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind("meta.registryCacheWriteProblems"), null);

+	}

+

+	try {

+		// Check to see if this registry already exists in the objectTable.  If it is there,

+		// it has already been written to the cache so just write out the index.

+		if (objectTable != null) {

+			int registryIndex = objectTable.indexOf(registry);

+			if (registryIndex != -1) {

+				// this plugin is already there

+				writeLabel(RegistryCacheReader.REGISTRY_INDEX_LABEL, out);

+				out.writeInt(registryIndex);

+				return;

+			}

+		}

+

+		// add this object to the object table first

+		addToObjectTable(registry);

+		writeHeaderInformation(out);

+		String outString = null;

+

+		writeLabel(RegistryCacheReader.REGISTRY_LABEL, out);

+

+		writeLabel(RegistryCacheReader.READONLY_LABEL, out);

+		out.writeBoolean(registry.isReadOnly());

+

+		writeLabel(RegistryCacheReader.REGISTRY_RESOLVED_LABEL, out);

+		out.writeBoolean(registry.isResolved());

+		PluginDescriptorModel[] pluginList = registry.getPlugins();

+		for (int i = 0; i < pluginList.length; i++)

+			writePluginDescriptor(pluginList[i], out);

+		PluginFragmentModel[] fragmentList = registry.getFragments();

+		int fragmentLength = (fragmentList == null) ? 0 : fragmentList.length;

+		for (int i = 0; i < fragmentLength; i++)

+			writePluginFragment(fragmentList[i], out);

+		writeLabel(RegistryCacheReader.REGISTRY_END_LABEL, out);

+	} catch (IOException ioe) {

+		cacheWriteProblems.add(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind ("meta.regCacheIOException", RegistryCacheReader.decipherLabel(RegistryCacheReader.REGISTRY_LABEL)), ioe));

+	}

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryLoader.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryLoader.java
new file mode 100644
index 0000000..37469b2
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryLoader.java
@@ -0,0 +1,129 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import org.eclipse.core.runtime.model.*;

+import org.eclipse.core.internal.runtime.InternalPlatform;

+import org.eclipse.core.internal.runtime.Policy;

+import java.io.*;

+import java.net.URL;

+import java.net.MalformedURLException;

+import org.xml.sax.InputSource;

+import org.xml.sax.SAXParseException;

+

+public class RegistryLoader {

+	private Factory factory;

+

+	// debug support

+	private boolean debug = false;

+	private long startTick = (new java.util.Date()).getTime(); // used for performance timings

+	private long lastTick = startTick;

+private RegistryLoader(Factory factory, boolean debug) {

+	super();

+	this.debug = debug;

+	this.factory = factory;

+}

+private void debug(String msg) {

+	long thisTick = System.currentTimeMillis();

+	System.out.println("RegistryLoader: " + msg + " [+"+ (thisTick - lastTick) + "ms]");

+	lastTick = thisTick;

+}

+private String[] getPathMembers(URL path) {

+	String[] list = null;

+	String protocol = path.getProtocol();

+	if (protocol.equals("file") || (InternalPlatform.inVAJ() && protocol.equals("valoader"))) {

+		list = (new File(path.getFile())).list();

+	} else {

+		// XXX: attempt to read URL and see if we got html dir page

+	}

+	return list == null ? new String[0] : list;

+}

+private PluginRegistryModel parseRegistry(URL[] pluginPath) {

+	long startTick = System.currentTimeMillis();

+	PluginRegistryModel result = processManifestFiles(pluginPath);

+	if (InternalPlatform.DEBUG) {

+		long endTick = System.currentTimeMillis();

+		debug("Parsed Registry: " + (endTick - startTick) + "ms");

+	}

+	return result;

+}

+public static PluginRegistryModel parseRegistry(URL[] pluginPath, Factory factory, boolean debug) {

+	return new RegistryLoader(factory, debug).parseRegistry(pluginPath);

+}

+private PluginModel processManifestFile(URL manifest) {

+	InputStream is = null;

+	try {

+		is = manifest.openStream();

+	} catch (IOException e) {

+		if (debug)

+			debug("No plugin found for: " + manifest);

+		return null;

+	}

+	PluginModel result = null;

+	try {

+		try {

+			result = new PluginParser((Factory) factory).parsePlugin(new InputSource(is));

+		} finally {

+			is.close();

+		}

+	} catch (SAXParseException se) {

+		/* exception details logged by parser */

+		factory.error(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind("parse.errorProcessing", manifest.toString()), null));

+	} catch (Exception e) {

+		factory.error(new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind("parse.errorProcessing", manifest.toString()), null));

+	}

+	return result;

+}

+private PluginRegistryModel processManifestFiles(URL[] pluginPath) {

+	PluginRegistryModel result = factory.createPluginRegistry();

+	for (int i = 0; i < pluginPath.length; i++)

+		processPluginPathEntry(result, pluginPath[i]);

+	return result;

+}

+private void processPluginPathEntry(PluginRegistryModel registry, URL location) {

+	if (debug)

+		debug("Path - " + location);

+	if (location.getFile().endsWith("/")) {

+		// directory entry - search for plugins

+		String[] members = getPathMembers(location);

+		for (int j = 0; j < members.length; j++) {

+			try {

+				boolean found = processPluginPathFile(registry, new URL(location, members[j] + "/plugin.xml"));

+				if (!found)

+					found = processPluginPathFile(registry, new URL(location, members[j] + "/fragment.xml"));

+			} catch (MalformedURLException e) {

+			}

+			if (debug)

+				debug("Processed - " + members[j]);

+		}

+	} else {

+		// specific file entry - load the given file

+		boolean found = processPluginPathFile(registry, location);

+		if (debug)

+			debug("Processed - " + location);

+	}

+}

+private boolean processPluginPathFile(PluginRegistryModel registry, URL location) {

+	PluginModel entry = processManifestFile(location);

+	if (entry == null)

+		return false;

+

+	String url = location.toString();

+	url = url.substring(0, 1 + url.lastIndexOf('/'));

+	if (entry instanceof PluginDescriptorModel)

+		registry.addPlugin((PluginDescriptorModel) entry);

+	else

+		if (entry instanceof PluginFragmentModel)

+			registry.addFragment((PluginFragmentModel) entry);

+		else

+			// XXX log some kind of error or throw an exception here

+			return false;

+	entry.setRegistry(registry);

+	entry.setLocation(url);

+	return true;

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryResolver.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryResolver.java
new file mode 100644
index 0000000..22a97fd
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryResolver.java
@@ -0,0 +1,1063 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import java.util.*;

+import org.eclipse.core.runtime.*;

+import org.eclipse.core.runtime.model.*;

+import org.eclipse.core.runtime.PluginVersionIdentifier;

+import org.eclipse.core.internal.runtime.InternalPlatform;

+import org.eclipse.core.internal.runtime.Policy;

+

+public class RegistryResolver {

+

+	private Map idmap;

+	private PluginRegistryModel reg;

+	private MultiStatus status;

+	private boolean trimPlugins = true;

+	private boolean crossLink = true;

+

+	public static final int MATCH_EXACT = 0;

+	public static final int MATCH_COMPATIBLE = 1;

+	public static final int MATCH_LATEST = 2;

+

+	private boolean DEBUG_RESOLVE = false;

+	private static final String OPTION_DEBUG_RESOLVE = "org.eclipse.core.runtime/registry/debug/resolve";

+

+	// constraint entry

+	private class Constraint {

+		private PluginDescriptorModel parent;

+		private PluginPrerequisiteModel prq;

+		private PluginVersionIdentifier ver;

+		private int type = MATCH_LATEST;

+		private ConstraintsEntry cEntry = null;

+

+		private Constraint(PluginDescriptorModel parent, PluginPrerequisiteModel prq) {

+			this.parent = parent;

+			this.prq = prq;

+			if (prq != null) {

+				ver = RegistryResolver.this.getVersionIdentifier(prq);

+				if (ver == null)

+					type = MATCH_LATEST;

+				else

+					if (prq.getMatch())

+						type = MATCH_EXACT;

+					else

+						type = MATCH_COMPATIBLE;

+			}

+		}

+

+		private int getMatchType() {

+			return type;

+		}

+

+		private ConstraintsEntry getConstraintsEntry() {

+			return cEntry;

+		}

+

+		private void setConstraintsEntry(ConstraintsEntry entry) {

+			cEntry = entry;

+		}

+

+		private PluginDescriptorModel getParent() {

+			return parent;

+		}

+

+		private PluginPrerequisiteModel getPrerequisite() {

+			return prq;

+		}

+

+		private PluginVersionIdentifier getVersionIdentifier() {

+			return ver;

+		}

+

+		public String toString() {

+			if (prq == null)

+				return "(null)";

+			String s = parent.toString() + "->" + prq.getPlugin();

+			String v = prq.getVersion();

+			s += v == null ? "(any)" : (prq.getMatch() ? "(" + v + ",exact)" : "(" + v + ",compatible)");

+			return s;

+		}

+	}

+

+	// constraint index structure

+	private class ConstraintsEntry {

+		private IndexEntry parent;

+		private List constraintList = new LinkedList();

+		private PluginDescriptorModel lastResolved = null;

+		private boolean isResolved = false;

+		private PluginDescriptorModel bestMatch = null;

+		private boolean bestMatchEnabled = false;

+

+		private ConstraintsEntry(IndexEntry parent) {

+			this.parent = parent;

+		}

+

+		private int constraintCount() {

+			return constraintList.size();

+		}

+

+		private PluginDescriptorModel addConstraint(Constraint c) {

+			constraintList.add(c);

+			c.setConstraintsEntry(this);

+			List constrained = getMatchingDescriptors();

+			if (constrained.size() <= 0) {

+				constraintList.remove(c);

+				c.setConstraintsEntry(null);

+				return null;

+			} else {

+				PluginDescriptorModel match = (PluginDescriptorModel) constrained.get(0);

+				if (!match.equals(lastResolved)) {

+					lastResolved = match;

+					isResolved = false;

+				}

+				return match;

+			}

+		}

+

+		private void removeConstraint(Constraint c) {

+			if (DEBUG_RESOLVE)

+				debug("removing constraint " + c.toString());

+			constraintList.remove(c);

+			c.setConstraintsEntry(null);

+			lastResolved = null;

+			isResolved = false;

+		}

+

+		private void removeConstraintFor(PluginPrerequisiteModel prereq) {

+			List remove = new ArrayList();

+			for (Iterator list = constraintList.iterator(); list.hasNext();) {

+				Constraint c = (Constraint) list.next();

+				if (c.getPrerequisite() == prereq)

+					remove.add(c);

+			}

+			for (Iterator list = remove.iterator(); list.hasNext();)

+				removeConstraint((Constraint) list.next());

+		}

+

+		private PluginDescriptorModel getMatchingDescriptor() {

+			List constrained = getMatchingDescriptors();

+			if (constrained.size() <= 0)

+				return null;

+			else

+				return (PluginDescriptorModel) constrained.get(0);

+		}

+

+		private List getMatchingDescriptors() {

+			List constrained = new LinkedList();

+

+			for (Iterator list = parent.versions().iterator(); list.hasNext();) {

+				PluginDescriptorModel pd = (PluginDescriptorModel) list.next();

+				if (pd.getEnabled())

+					constrained.add(pd);

+			}

+

+			for (Iterator list = constraintList.iterator(); list.hasNext();) {

+				Constraint c = (Constraint) list.next();

+				if (c.getMatchType() == MATCH_LATEST)

+					continue;

+				for (Iterator list2 = parent.versions().iterator(); list2.hasNext();) {

+					PluginDescriptorModel pd = (PluginDescriptorModel) list2.next();

+					if (!pd.getEnabled())

+						continue;

+					if (c.getMatchType() == MATCH_EXACT) {

+						if (!getVersionIdentifier(pd).isEquivalentTo(c.getVersionIdentifier()))

+							constrained.remove(pd);

+					} else {

+						if (!getVersionIdentifier(pd).isCompatibleWith(c.getVersionIdentifier()))

+							constrained.remove(pd);

+					}

+				}

+			}

+

+			return constrained;

+		}

+

+		private void preresolve(List roots) {

+

+			if (constraintList.size() <= 0) {

+				if (roots.contains(parent.getId())) {

+					bestMatch = (PluginDescriptorModel) parent.versions().get(0);

+					if (bestMatch == null) {

+						if (DEBUG_RESOLVE)

+							debug("*ERROR* no resolved descriptor for " + parent.getId());

+					} else

+						bestMatchEnabled = bestMatch.getEnabled();

+				}

+			} else {

+				bestMatch = getMatchingDescriptor();

+				if (bestMatch == null) {

+					if (DEBUG_RESOLVE)

+						debug("*ERROR* no resolved descriptor for " + parent.getId());

+				} else

+					bestMatchEnabled = true;

+			}

+		}

+

+		private void resolve() {

+			if (bestMatch != null) {

+				bestMatch.setEnabled(bestMatchEnabled);

+				if (bestMatchEnabled) {

+					if (DEBUG_RESOLVE)

+						debug("configured " + bestMatch.toString());

+					if (constraintList.size() > 0) {

+						for (int i = 0; i < constraintList.size(); i++) {

+							PluginPrerequisiteModel prq = (PluginPrerequisiteModel) ((Constraint) constraintList.get(i)).getPrerequisite();

+							prq.setResolvedVersion(getVersionIdentifier(bestMatch).toString());

+						}

+					}

+				}

+			}

+		}

+

+		private boolean isResolved() {

+			return this.isResolved;

+		}

+		private void isResolved(boolean isResolved) {

+			this.isResolved = isResolved;

+		}

+	}

+

+	// plugin descriptor index structure

+	private class IndexEntry {

+		private String id;

+		private List verList = new LinkedList();

+		private List concurrentList = new ArrayList();

+

+		private IndexEntry(String id) {

+			this.id = id;

+			concurrentList.add(new ConstraintsEntry(this));

+		}

+

+		private String getId() {

+			return id;

+		}

+

+		private ConstraintsEntry getConstraintsEntryFor(Constraint c) {

+			ConstraintsEntry ce = c.getConstraintsEntry();

+			if (ce != null)

+				return ce;

+			ce = (ConstraintsEntry) concurrentList.get(0);

+			if (c.getPrerequisite() == null)

+				c.setConstraintsEntry(ce);

+			return ce;

+		}

+

+		private PluginDescriptorModel addConstraint(Constraint c) {

+			int concurrentCount = concurrentList.size();

+

+			// try to find constraits entry that can accommodate new constraint

+			for (Iterator list = concurrentList.iterator(); list.hasNext();) {

+				ConstraintsEntry cie = (ConstraintsEntry) list.next();

+				PluginDescriptorModel pd = cie.addConstraint(c);

+				if (pd != null) {

+

+					// constraint added OK and no concurrency

+					if (concurrentCount <= 1)

+						return pd;

+

+					// constraint added OK but have concurrency

+					if (allowConcurrencyFor(pd))

+						return pd;

+					else {

+						cie.removeConstraint(c); // cannot be concurrent

+						return null;

+					}

+				}

+			}

+

+			// attempt to create new constraints entry

+			ConstraintsEntry cie;

+			PluginDescriptorModel pd;

+

+			if (concurrentList.size() == 1) {

+				// ensure base entry allows concurrency

+				cie = (ConstraintsEntry) concurrentList.get(0);

+				pd = cie.getMatchingDescriptor();

+				if (!allowConcurrencyFor(pd))

+					return null;

+			}

+

+			cie = new ConstraintsEntry(this);

+			pd = cie.addConstraint(c);

+			if (pd == null) {

+				cie.removeConstraint(c); // no matching target

+				return null;

+			}

+			if (!allowConcurrencyFor(pd)) {

+				cie.removeConstraint(c); // cannot be concurrent

+				return null;

+			}

+			if (DEBUG_RESOLVE)

+				debug("creating new constraints list in " + id + " for " + c.toString());

+			concurrentList.add(cie);

+			return pd;

+		}

+

+		private boolean allowConcurrencyFor(PluginDescriptorModel pd) {

+			if (pd == null)

+				return false;

+			if (pd.getDeclaredExtensions() != null && pd.getDeclaredExtensions().length > 0)

+				return false;

+			if (pd.getDeclaredExtensionPoints() != null && pd.getDeclaredExtensionPoints().length > 0)

+				return false;

+			return true;

+		}

+

+		private void removeConstraint(Constraint c) {

+			ConstraintsEntry cie = getConstraintsEntryFor(c);

+			cie.removeConstraint(c);

+			if (concurrentList.get(0) != cie && cie.constraintCount() == 0)

+				concurrentList.remove(cie);

+		}

+

+		private void removeConstraintFor(PluginPrerequisiteModel prereq) {

+			for (Iterator list = concurrentList.iterator(); list.hasNext();)

+				 ((ConstraintsEntry) list.next()).removeConstraintFor(prereq);

+		}

+

+		private PluginDescriptorModel getMatchingDescriptorFor(Constraint c) {

+			ConstraintsEntry cie = getConstraintsEntryFor(c);

+			return cie.getMatchingDescriptor();

+		}

+

+		private void disableAllDescriptors() {

+			for (Iterator list = verList.iterator(); list.hasNext();) {

+				PluginDescriptorModel pd = (PluginDescriptorModel) list.next();

+				pd.setEnabled(false);

+			}

+		}

+

+		private void resolveDependencies(List roots) {

+			for (Iterator list = concurrentList.iterator(); list.hasNext();)

+				 ((ConstraintsEntry) list.next()).preresolve(roots);

+			disableAllDescriptors();

+			for (Iterator list = concurrentList.iterator(); list.hasNext();)

+				 ((ConstraintsEntry) list.next()).resolve();

+		}

+

+		private List versions() {

+			return verList;

+		}

+

+		private boolean isResolvedFor(Constraint c) {

+			ConstraintsEntry cie = getConstraintsEntryFor(c);

+			return cie.isResolved();

+		}

+

+		private void isResolvedFor(Constraint c, boolean value) {

+			ConstraintsEntry cie = getConstraintsEntryFor(c);

+			cie.isResolved(value);

+		}

+

+	}

+

+	// subtree resolution "cookie" (composite change list)

+	private class Cookie {

+		private boolean ok = true;

+		private List changes = new ArrayList();

+

+		private Cookie() {

+		}

+

+		private boolean addChange(Constraint c) {

+			PluginPrerequisiteModel prereq = c.getPrerequisite();

+			for (Iterator list = changes.iterator(); list.hasNext();)

+				if (prereq == ((Constraint)list.next()).getPrerequisite())

+					return false; // prereq loop

+			changes.add(c);

+			return true;

+		}

+

+		private List getChanges() {

+			return changes;

+		}

+

+		private void clearChanges() {

+			if (changes.size() >= 0)

+				changes = new ArrayList();

+		}

+

+		private boolean isOk() {

+			return ok;

+		}

+

+		private void isOk(boolean value) {

+			ok = value;

+		}

+	}

+public RegistryResolver() {	

+	String debug = Platform.getDebugOption(OPTION_DEBUG_RESOLVE);

+	DEBUG_RESOLVE = debug==null ? false : ( debug.equalsIgnoreCase("true") ? true : false );

+}

+private void add(PluginDescriptorModel pd) {

+

+	String key = pd.getId();

+	List verList;

+	IndexEntry ix = (IndexEntry) idmap.get(key);

+

+	// create new index entry if one does not exist for plugin

+	if (ix == null) {

+		ix = new IndexEntry(key);

+		idmap.put(key, ix);

+	}

+

+	// insert plugin into list maintaining version order

+	verList = ix.versions();

+	int i = 0;

+	for (i = 0; i < verList.size(); i++) {

+		PluginDescriptorModel element = (PluginDescriptorModel) verList.get(i);

+		if (getVersionIdentifier(pd).equals(getVersionIdentifier(element)))

+			return; // ignore duplicates

+		if (getVersionIdentifier(pd).isGreaterThan(getVersionIdentifier(element)))

+			break;

+	}

+	verList.add(i, pd);

+}

+private void addAll(Collection c) {

+	for (Iterator list = c.iterator(); list.hasNext();)

+		add((PluginDescriptorModel) list.next());

+}

+private void addExtensions(ExtensionModel[] extensions, PluginDescriptorModel plugin) {

+	int extLength = extensions.length;

+	for (int i = 0; i < extLength; i++) {

+		extensions[i].setParentPluginDescriptor (plugin);

+	}

+	ExtensionModel[] list = plugin.getDeclaredExtensions();

+	int listLength = (list == null ? 0 : list.length);

+	ExtensionModel[] result = null;

+	if (list == null)

+		result = new ExtensionModel[extLength];

+	else {

+		result = new ExtensionModel[list.length + extLength];

+		System.arraycopy(list, 0, result, 0, list.length);

+	}

+	System.arraycopy(extensions, 0, result, listLength, extLength); 

+	plugin.setDeclaredExtensions(result);

+}

+private void addExtensionPoints(ExtensionPointModel[] extensionPoints, PluginDescriptorModel plugin) {

+	int extPtLength = extensionPoints.length;

+	for (int i = 0; i < extPtLength; i++) {

+		extensionPoints[i].setParentPluginDescriptor (plugin);

+	}

+	ExtensionPointModel[] list = plugin.getDeclaredExtensionPoints();

+	int listLength = (list == null ? 0 : list.length);

+	ExtensionPointModel[] result = null;

+	if (list == null)

+		result = new ExtensionPointModel[extPtLength];

+	else {

+		result = new ExtensionPointModel[list.length + extPtLength];

+		System.arraycopy(list, 0, result, 0, list.length);

+	}

+	System.arraycopy(extensionPoints, 0, result, listLength, extPtLength); 

+	plugin.setDeclaredExtensionPoints(result);

+}

+private void addLibraries(LibraryModel[] libraries, PluginDescriptorModel plugin) {

+	int libLength = libraries.length;

+	LibraryModel[] list = plugin.getRuntime();

+	LibraryModel[] result = null;

+	int listLength = (list == null ? 0 : list.length);

+	if (list == null)

+		result = new LibraryModel[libLength];

+	else {

+		result = new LibraryModel[list.length + libLength];

+		System.arraycopy(list, 0, result, 0, list.length);

+	}

+	System.arraycopy(libraries, 0, result, listLength, libLength); 

+	plugin.setRuntime(result);

+}

+private void addPrerequisites(PluginPrerequisiteModel[] prerequisites, PluginDescriptorModel plugin) {

+	int reqLength = prerequisites.length;

+	PluginPrerequisiteModel[] list = plugin.getRequires();

+	PluginPrerequisiteModel[] result = null;

+	int listLength = (list == null ? 0 : list.length);

+	if (list == null)

+		result = new PluginPrerequisiteModel[reqLength];

+	else {

+		result = new PluginPrerequisiteModel[list.length + reqLength];

+		System.arraycopy(list, 0, result, 0, list.length);

+	}

+	System.arraycopy(prerequisites, 0, result, listLength, reqLength); 

+	plugin.setRequires(result);

+}

+private void debug(String s) {

+	System.out.println("Registry Resolve: "+s);

+}

+private void error(String message) {

+	Status error = new Status(IStatus.WARNING, Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, message, null);

+	status.add(error);

+	if (InternalPlatform.DEBUG && DEBUG_RESOLVE)

+		System.out.println(error.toString());

+}

+public IExtensionPoint getExtensionPoint(PluginDescriptorModel plugin, String extensionPointId) {

+	if (extensionPointId == null)

+		return null;

+	ExtensionPointModel[] list = plugin.getDeclaredExtensionPoints();

+	if (list == null)

+		return null;

+	for (int i = 0; i < list.length; i++) {

+		if (extensionPointId.equals(list[i].getId()))

+			return (IExtensionPoint) list[i];

+	}

+	return null;

+}

+private PluginVersionIdentifier getVersionIdentifier(PluginDescriptorModel descriptor) {

+	String version = descriptor.getVersion();

+	if (version == null)

+		return new PluginVersionIdentifier("1.0.0");

+	try {

+		return new PluginVersionIdentifier(version);

+	} catch (Throwable e) {

+		return new PluginVersionIdentifier("1.0.0");

+	}

+}

+private PluginVersionIdentifier getVersionIdentifier(PluginPrerequisiteModel prereq) {

+	String version = prereq.getVersion();

+	return version == null ? null : new PluginVersionIdentifier(version);

+}

+private void linkFragments() {

+	/* For each fragment, find out which plugin descriptor it belongs

+	 * to and add it to the list of fragments in this plugin.

+	 */

+	PluginFragmentModel[] fragments = reg.getFragments();

+	HashSet seen = new HashSet(5);

+	for (int i = 0; i < fragments.length; i++) {

+		PluginFragmentModel fragment = fragments[i];

+		if (!requiredFragment(fragment)) {

+			// There is a required field missing on this fragment, so 

+			// ignore it.

+			String id, name;

+			if ((id = fragment.getId()) != null)

+				error (Policy.bind("parse.fragmentMissingAttr", id));

+			else if ((name = fragment.getName()) != null)

+				error (Policy.bind("parse.fragmentMissingAttr", name));

+			else

+				error (Policy.bind("parse.fragmentMissingIdName"));

+			continue;

+		}

+		if (seen.contains(fragment.getId()))

+			continue;

+		seen.add(fragment.getId());

+		PluginDescriptorModel plugin = reg.getPlugin(fragment.getPluginId(), fragment.getPluginVersion());

+		if (plugin == null) {

+			// We couldn't find this fragment's plugin

+			error (Policy.bind("parse.missingFragmentPd", fragment.getPluginId(), fragment.getId()));

+			continue;

+		}

+		// Soft prereq's ???

+		// PluginFragmentModel[] list = reg.getFragments(fragment.getId());

+		// resolvePluginFragments(list, plugin);

+		

+		// Add this fragment to the list of fragments for this plugin descriptor

+		PluginFragmentModel[] list = plugin.getFragments();

+		PluginFragmentModel[] newList;

+		if (list == null) {

+			newList = new PluginFragmentModel[1];

+			newList[0] = fragment;

+		} else {

+			newList = new PluginFragmentModel[list.length + 1];

+			System.arraycopy(list, 0, newList, 0, list.length);

+			newList[list.length] = fragment;

+		}

+		plugin.setFragments(newList);

+	}

+}

+private void removeConstraintFor(PluginPrerequisiteModel prereq) {

+

+	String id = prereq.getPlugin();

+	IndexEntry ix = (IndexEntry) idmap.get(id);

+	if (ix == null) {

+		if (DEBUG_RESOLVE)

+			debug("unable to locate index entry for " + id);

+		return;

+	}

+	ix.removeConstraintFor(prereq);

+}

+private void resolve() {

+

+	// Add all the fragments to their associated plugin

+	linkFragments();

+	PluginDescriptorModel[] pluginList = reg.getPlugins();

+	for (int i = 0; i < pluginList.length; i++) {

+		if (pluginList[i].getFragments() != null) {

+			// Take all the information in each fragment and

+			// embed it in the plugin descriptor

+			resolvePluginFragments(pluginList[i]);

+		}

+	}

+	

+	// Walk through the registry and ensure that all structures

+	// have all their 'required' fields.  Do this now as

+	// the resolve assumes required field exist.  

+	resolveRequiredComponents();

+

+	// resolve root descriptors

+	List rd = resolveRootDescriptors();

+	if (rd.size() == 0) {

+		// no roots ... quit

+		idmap = null;

+		reg = null;

+		error(Policy.bind("plugin.unableToResolve"));

+		return;

+	}

+

+	// sort roots

+	Object[] a = rd.toArray();

+	Arrays.sort(a);

+	ArrayList roots = new ArrayList(Arrays.asList(a));

+	

+	// walk the dependencies and setup constraints

+	ArrayList orphans = new ArrayList();

+	for (int i = 0; i < roots.size(); i++)

+		resolveNode((String) roots.get(i), null, null, null, orphans);

+	for (int i = 0; i < orphans.size(); i++) {

+		if (!roots.contains(orphans.get(i))) {

+			roots.add(orphans.get(i));

+			if (DEBUG_RESOLVE)

+				debug("orphan " + orphans.get(i));

+		}

+	}

+

+	// resolve dependencies

+	Iterator plugins = idmap.entrySet().iterator();

+	while (plugins.hasNext()) {

+		IndexEntry ix = (IndexEntry) ((Map.Entry) plugins.next()).getValue();

+		ix.resolveDependencies(roots);

+	}

+

+	// walk down the registry structure and resolve links

+	resolvePluginRegistry();

+	

+	// unhook registry and index

+	idmap = null;

+	reg = null;

+}

+public IStatus resolve(PluginRegistryModel registry) {

+	status = new MultiStatus(Platform.PI_RUNTIME, IStatus.OK, "", null);

+	if (registry.isResolved())

+		return status;

+	reg = registry;

+	idmap = new HashMap();

+	// Need to pick up the fragments before calling

+	// addAll.  Currently we do this in resolve().

+	addAll(Arrays.asList(reg.getPlugins()));

+	resolve();

+	registry.markResolved();

+	return status;

+}

+private void resolveExtension(ExtensionModel ext) {

+

+	String target = ext.getExtensionPoint();

+	int ix = target.lastIndexOf(".");

+	String pluginId = target.substring(0, ix);

+	String extPtId = target.substring(ix + 1);

+	String message;

+

+	PluginDescriptorModel plugin = (PluginDescriptorModel) reg.getPlugin(pluginId);

+	if (plugin == null) {

+		message = Policy.bind("parse.extPointUnknown", target, ext.getParentPluginDescriptor().getId());

+		error(message);

+		return;

+	}

+	if (!plugin.getEnabled()) {

+		message = Policy.bind("parse.extPointDisabled", target, ext.getParentPluginDescriptor().getId());

+		error(message);

+		return;

+	}

+

+	ExtensionPointModel extPt = (ExtensionPointModel) getExtensionPoint(plugin, extPtId);

+	if (extPt == null) {

+		message = Policy.bind("parse.extPointUnknown", target, ext.getParentPluginDescriptor().getId());

+		error(message);

+		return;

+	}

+

+	ExtensionModel[] oldValues = extPt.getDeclaredExtensions();

+	ExtensionModel[] newValues = null;

+	if (oldValues == null)

+		newValues = new ExtensionModel[1];

+	else {

+		newValues = new ExtensionModel[oldValues.length + 1];

+		System.arraycopy(oldValues, 0, newValues, 0, oldValues.length);

+	}

+	newValues[newValues.length - 1] = ext;

+	extPt.setDeclaredExtensions(newValues);

+}

+private void resolveFragments() {

+	PluginFragmentModel[] fragments = reg.getFragments();

+	HashSet seen = new HashSet(5);

+	for (int i = 0; i < fragments.length; i++) {

+		PluginFragmentModel fragment = fragments[i];

+		if (!requiredFragment(fragment))

+			continue;

+		if (seen.contains(fragment.getId()))

+			continue;

+		seen.add(fragment.getId());

+		PluginDescriptorModel plugin = reg.getPlugin(fragment.getPluginId(), fragment.getPluginVersion());

+		if (plugin == null)

+			// XXX log something here?

+			continue;

+		PluginFragmentModel[] list = reg.getFragments(fragment.getId());

+		resolvePluginFragments(plugin);

+	}

+}

+private Cookie resolveNode(String child, PluginDescriptorModel parent, PluginPrerequisiteModel prq, Cookie cookie, List orphans) {

+	// This method is called recursively to setup dependency constraints.

+	// Top invocation is passed null parent and null prerequisite.

+

+	if (DEBUG_RESOLVE)

+		debug("PUSH> " + child);

+

+	if (cookie == null)

+		cookie = new Cookie();

+

+	// lookup child entry

+	IndexEntry ix = (IndexEntry) idmap.get(child);

+	if (ix == null) {

+		if (parent != null)

+			error(Policy.bind("parse.prereqDisabled", new String[] { parent.getId(), child }));

+		if (DEBUG_RESOLVE)

+			debug("<POP  " + child + " not found");

+		cookie.isOk(false);

+		return cookie;

+	}

+

+	// try to add new dependency constraint

+	Constraint currentConstraint = new Constraint(parent, prq);

+	PluginDescriptorModel childPd = null;

+	if (parent != null) {

+		childPd = ix.addConstraint(currentConstraint);

+		if (childPd == null) {

+			String message = Policy.bind("parse.unsatisfiedPrereq", parent.getId(), child);

+			error(message);

+			if (DEBUG_RESOLVE)

+				debug("<POP  " + child + " unable to satisfy constraint");

+			cookie.isOk(false);

+			return cookie;

+		} else

+			if (!cookie.addChange(currentConstraint)) {

+				String message = Policy.bind("parse.prereqLoop", parent.getId(), child);

+				error(message);

+				if (DEBUG_RESOLVE)

+					debug("<POP  " + child + " prerequisite loop");

+				cookie.isOk(false);

+				return cookie;

+			}

+	} else {

+		childPd = ix.getMatchingDescriptorFor(currentConstraint);

+		if (childPd == null) {

+			if (DEBUG_RESOLVE)

+				debug("<POP  " + child + " not found (missing descriptor entry)");

+			cookie.isOk(false);

+			return cookie;

+		}

+	}

+

+	// check to see if subtree is already resolved

+	if (ix.isResolvedFor(currentConstraint)) {

+		if (DEBUG_RESOLVE)

+			debug("<POP  " + child + " already resolved");

+		return cookie;

+	}

+

+	// select the subtree to resolve

+	PluginPrerequisiteModel[] prereqs = childPd.getRequires();

+	PluginPrerequisiteModel prereq;

+	prereqs = prereqs == null ? new PluginPrerequisiteModel[0] : prereqs;

+	for (int i = 0; cookie.isOk() && i < prereqs.length; i++) {

+		prereq = (PluginPrerequisiteModel) prereqs[i];

+		cookie = resolveNode(prereq.getPlugin(), childPd, prereq, cookie, orphans);

+	}

+

+	// if we failed, remove any constraints we added

+	if (!cookie.isOk()) {

+		Constraint cookieConstraint;

+		for (Iterator change = cookie.getChanges().iterator(); change.hasNext();) {

+			cookieConstraint = (Constraint) change.next();

+			if (childPd == cookieConstraint.getParent()) {

+				prereq = cookieConstraint.getPrerequisite();

+				removeConstraintFor(prereq);

+				if (!orphans.contains(prereq.getPlugin())) // keep track of orphaned subtrees

+					orphans.add(prereq.getPlugin());

+			}

+		}

+		if (parent != null)

+			error(Policy.bind("parse.prereqDisabled", parent.getId(), child));

+		childPd.setEnabled(false);

+		if (DEBUG_RESOLVE)

+			debug("<POP  " + child + " failed to resolve subtree");

+		return cookie;

+	} else {

+		// we're done

+		ix.isResolvedFor(currentConstraint, true);

+		if (DEBUG_RESOLVE)

+			debug("<POP  " + child + " " + getVersionIdentifier(childPd));

+		return cookie;

+	}

+}

+private void resolvePluginDescriptor(PluginDescriptorModel pd) {

+	ExtensionModel[] list = pd.getDeclaredExtensions();

+	if (list == null || list.length == 0 || !pd.getEnabled())

+		// Can be disabled if all required attributes not present

+		return;

+	for (int i = 0; i < list.length; i++)

+		resolveExtension((ExtensionModel) list[i]);

+}

+private void resolvePluginFragment(PluginFragmentModel fragment, PluginDescriptorModel plugin) {

+	ExtensionModel[] extensions = fragment.getDeclaredExtensions();

+	if (extensions != null)

+		// Add all the fragment extensions to the plugin

+		addExtensions(extensions, plugin);

+

+	ExtensionPointModel[] points = fragment.getDeclaredExtensionPoints();

+	if (points != null)

+		// Add all the fragment extension points to the plugin

+		addExtensionPoints(points, plugin);

+

+	LibraryModel[] libraries = fragment.getRuntime();

+	if (libraries != null)

+		// Add all the fragment library entries to the plugin

+		addLibraries(libraries, plugin);

+			

+	PluginPrerequisiteModel[] prerequisites = fragment.getRequires();

+	if (prerequisites != null)

+		// Add all the fragment prerequisites to the plugin

+		addPrerequisites(prerequisites, plugin);

+}

+private void resolvePluginFragments(PluginDescriptorModel plugin) {

+	/* For each fragment contained in the fragment list of this plugin, 

+	 * apply all the fragment bits to the plugin (e.g. all of the fragment's

+	 * extensions are added to the list of extensions in the plugin).  Be

+	 * sure to use only the latest version of any given fragment (in case

+	 * there are multiple versions of a given fragment id).  So note that,

+	 * if there are multiple versions of a given fragment id, all but the

+	 * latest version will be discarded.

+	 */

+	PluginFragmentModel[] fragmentList = plugin.getFragments();

+	while (fragmentList != null) {

+		ArrayList fragmentsWithId = new ArrayList();

+		ArrayList fragmentsToProcessLater = new ArrayList();

+		String currentFragmentId = fragmentList[0].getId();

+		for (int i = 0; i < fragmentList.length; i++) {

+			// Find all the fragments with a given id.

+			if (currentFragmentId.equals(fragmentList[i].getId())) {

+				fragmentsWithId.add(fragmentList[i]);

+			} else {

+				fragmentsToProcessLater.add(fragmentList[i]);

+			}

+		}

+		

+		PluginFragmentModel[] fragments;

+		if (fragmentsWithId.isEmpty())

+			fragments = null;

+		else

+			fragments = (PluginFragmentModel[]) fragmentsWithId.toArray(new PluginFragmentModel[fragmentsWithId.size()]);

+		

+		if (fragmentsToProcessLater.isEmpty())

+			fragmentList = null;

+		else

+			fragmentList = (PluginFragmentModel[]) fragmentsToProcessLater.toArray(new PluginFragmentModel[fragmentsToProcessLater.size()]);

+			

+		if (fragments != null) {

+			// Now find the latest version of the fragment with the chosen id

+			PluginFragmentModel latestFragment = null;

+			PluginVersionIdentifier latestVersion = null;

+			PluginVersionIdentifier targetVersion = new PluginVersionIdentifier(plugin.getVersion());

+			for (int i = 0; i < fragments.length; i++) {

+				PluginFragmentModel fragment = fragments[i];

+				PluginVersionIdentifier fragmentVersion = new PluginVersionIdentifier(fragment.getVersion());

+				PluginVersionIdentifier pluginVersion = new PluginVersionIdentifier(fragment.getPluginVersion());

+				if (pluginVersion.getMajorComponent() == targetVersion.getMajorComponent() && pluginVersion.getMinorComponent() == targetVersion.getMinorComponent())

+					if (latestFragment == null || fragmentVersion.isGreaterThan(latestVersion)) {

+						latestFragment = fragment;

+						latestVersion = fragmentVersion;

+					}

+			}

+			if (latestFragment != null) {

+				// For the latest version of this fragment id only, apply

+				// all the fragment bits to the plugin.  

+				resolvePluginFragment(latestFragment, plugin);

+			}

+		}

+	}

+}

+private void resolvePluginRegistry() {

+	// filter out disabled plugins from "live" registry

+	if (trimPlugins)

+		trimRegistry();

+

+	// resolve relationships

+	if (crossLink) {

+		// cross link all of the extensions and extension points.

+		PluginDescriptorModel[] plugins = reg.getPlugins();

+		for (int i = 0; i < plugins.length; i++)

+			resolvePluginDescriptor(plugins[i]);

+	}

+}

+private void resolveRequiredComponents() {

+	PluginDescriptorModel[] pluginList = reg.getPlugins();

+	// Only worry about the enabled plugins as we are going

+	// to disable any plugins that don't have all the 

+	// required bits.

+	for (int i = 0; i < pluginList.length; i++) {

+		if (pluginList[i].getEnabled()) {

+			if (!requiredPluginDescriptor(pluginList[i])) {

+				pluginList[i].setEnabled(false);

+				String id, name;

+				if ((id = pluginList[i].getId()) != null)

+					error (Policy.bind("parse.pluginMissingAttr", id));

+				else if ((name = pluginList[i].getName()) != null)

+					error (Policy.bind("parse.pluginMissingAttr", name));

+				else

+					error (Policy.bind("parse.pluginMissingIdName"));

+			}

+		}

+	}

+	// Don't worry about the fragments.  They were done already.

+}

+private boolean requiredPluginDescriptor(PluginDescriptorModel plugin) {

+	boolean retValue = true;

+	retValue = plugin.getName() != null &&

+		plugin.getId() != null &&

+		plugin.getVersion() != null;

+	if (!retValue) 

+		return retValue;

+		

+	PluginPrerequisiteModel[] requiresList = plugin.getRequires();

+	ExtensionModel[] extensions = plugin.getDeclaredExtensions();

+	ExtensionPointModel[] extensionPoints = plugin.getDeclaredExtensionPoints();

+	LibraryModel[] libraryList = plugin.getRuntime();

+	PluginFragmentModel[] fragments = plugin.getFragments();

+	

+	if (requiresList != null) {

+		for (int i = 0; i < requiresList.length && retValue; i++) {

+			retValue = retValue && requiredPrerequisite(requiresList[i]);

+		}

+	}

+	if (extensions != null) {

+		for (int i = 0; i < extensions.length && retValue; i++) {

+			retValue = retValue && requiredExtension(extensions[i]);

+		}

+	}

+	if (extensionPoints != null) {

+		for (int i = 0; i < extensionPoints.length && retValue; i++) {

+			retValue = retValue && requiredExtensionPoint(extensionPoints[i]);

+		}

+	}

+	if (libraryList != null) {

+		for (int i = 0; i < libraryList.length && retValue; i++) {

+			retValue = retValue && requiredLibrary(libraryList[i]);

+		}

+	}

+	if (fragments != null) {

+		for (int i = 0; i < fragments.length && retValue; i++) {

+			retValue = retValue && requiredFragment(fragments[i]);

+		}

+	}

+	

+	return retValue;

+}

+private boolean requiredPrerequisite (PluginPrerequisiteModel prerequisite) {

+	return ((prerequisite.getPlugin() != null));

+}

+private boolean requiredExtension (ExtensionModel extension) {

+	return (extension.getExtensionPoint() != null);

+}

+private boolean requiredExtensionPoint (ExtensionPointModel extensionPoint) {

+	return ((extensionPoint.getName() != null) &&

+		(extensionPoint.getId() != null));

+}

+private boolean requiredLibrary (LibraryModel library) {

+	return (library.getName() != null);

+}

+private boolean requiredFragment (PluginFragmentModel fragment) {

+	return ((fragment.getName() != null) &&

+		(fragment.getId() != null) &&

+		(fragment.getPlugin() != null) &&

+		(fragment.getPluginVersion() != null) &&

+		(fragment.getVersion() != null));

+}

+private List resolveRootDescriptors() {

+

+	// Determine the roots of the dependency tree. Disable all

+	// but one versions of the root descriptors.

+

+	// get list of all plugin identifiers in the registry

+	List ids = new ArrayList();

+	ids.addAll(idmap.keySet());

+

+	// iterate over the list eliminating targets of <requires> entries

+	Iterator p = idmap.entrySet().iterator();

+	while (p.hasNext()) {

+		IndexEntry ix = (IndexEntry) ((Map.Entry) p.next()).getValue();

+		if (ix != null) {

+			List list = ix.versions();

+			if (list.size() > 0) {

+				PluginDescriptorModel pd = (PluginDescriptorModel) list.get(0);

+				PluginPrerequisiteModel[] prereqs = pd.getRequires();

+				for (int i = 0; prereqs != null && i < prereqs.length; i++) {

+					ids.remove(prereqs[i].getPlugin());

+				}

+			}

+		}

+	}

+

+	if (ids.size() > 0) {

+		// disable all but the most recent version of root descriptors

+		String id;

+		p = ids.iterator();

+		while (p.hasNext()) {

+			id = (String) p.next();

+			IndexEntry ix = (IndexEntry) idmap.get(id);

+			if (ix != null) {

+				List list = ix.versions();

+				for (int i = 0; i < list.size(); i++) {

+					PluginDescriptorModel pd = (PluginDescriptorModel) list.get(i);

+					if (i == 0) {

+						if (DEBUG_RESOLVE)

+							debug("root " + pd);

+					} else {

+						if (DEBUG_RESOLVE)

+							debug("     " + pd + " disabled");

+						pd.setEnabled(false);

+					}

+				}

+			}

+		}

+	} else {

+		if (DEBUG_RESOLVE)

+			debug("NO ROOTS");

+	}

+

+	return ids;

+}

+/**

+ * Specifies whether extensions and extension points should be cross 

+ * linked during the resolve process.

+ */

+public void setCrossLink(boolean value) {

+	crossLink = value;

+}

+/**

+ * Specified whether disabled plugins should to be removed when the resolve

+ * is completed.

+ */

+public void setTrimPlugins(boolean value) {

+	trimPlugins = value;

+}

+private void trimRegistry() {

+	PluginDescriptorModel[] list = reg.getPlugins();

+	for (int i = 0; i < list.length; i++) {

+		PluginDescriptorModel pd = (PluginDescriptorModel) list[i];

+		if (!pd.getEnabled()) {

+			if (DEBUG_RESOLVE)

+				debug("removing " + pd.toString());

+			reg.removePlugin(pd.getId(), pd.getVersion());

+		}

+	}

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryWriter.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryWriter.java
new file mode 100644
index 0000000..cd1d220
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/plugins/RegistryWriter.java
@@ -0,0 +1,324 @@
+package org.eclipse.core.internal.plugins;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.model.*;

+import java.io.PrintWriter;

+

+public class RegistryWriter {

+public RegistryWriter() {

+	super();

+}

+public void writeConfigurationElement(ConfigurationElementModel configElement, PrintWriter w, int indent) {

+	String element = configElement.getName();

+	if (element == null)

+		return;

+

+	String gap1 = "";

+	for (int i = 0; i < indent; i++)

+		gap1 += " ";

+	String gap2 = gap1;

+	for (int i = 0; i < IModel.INDENT; i++)

+		gap2 += " ";

+

+	w.print(gap1 + "<" + element);

+	ConfigurationPropertyModel[] propList = configElement.getProperties();

+	int propSize = (propList == null) ? 0 : propList.length;

+	for (int i = 0; i < propSize; i++) 

+		writeConfigurationProperty(propList[i], w, indent + IModel.INDENT);

+

+	ConfigurationElementModel[] subElementList = configElement.getSubElements();

+	int subElementSize = (subElementList == null) ? 0 : subElementList.length;

+	if (configElement.getValue() == null && subElementSize == 0) {

+		w.println("/>");

+		return;

+	}

+	w.println(">");

+

+	if (configElement.getValue() != null)

+		w.println(gap2 + xmlSafe(configElement.getValue()));

+	for (int i = 0; i < subElementSize; i++) 

+		writeConfigurationElement(subElementList[i], w, indent + IModel.INDENT);

+

+	w.println(gap1 + "</" + element + ">");

+}

+public void writeConfigurationProperty(ConfigurationPropertyModel configProp, PrintWriter w, int indent) {

+	if (configProp.getName() == null)

+		return;

+	w.print(" " + xmlSafe(configProp.getName()) + "=\"");

+	if (configProp.getValue() != null)

+		w.print(xmlSafe(configProp.getValue()));

+	w.print("\"");

+}

+public void writeExtension(ExtensionModel extension, PrintWriter w, int indent) {

+	String gap1 = "";

+	for (int i = 0; i < indent; i++)

+		gap1 += " ";

+

+	w.print(gap1 + "<" + IModel.EXTENSION);

+	if (extension.getExtensionPoint() != null)

+		w.print(" " + IModel.EXTENSION_TARGET + "=\"" + xmlSafe(extension.getExtensionPoint()) + "\"");

+	if (extension.getId() != null)

+		w.print(" " + IModel.EXTENSION_ID + "=\"" + xmlSafe(extension.getId()) + "\"");

+	if (extension.getName() != null)

+		w.print(" " + IModel.EXTENSION_NAME + "=\"" + xmlSafe(extension.getName()) + "\"");

+

+	ConfigurationElementModel[] subElements = extension.getSubElements();

+	int size = (subElements == null) ? 0 : subElements.length;

+	if (size == 0) {

+		w.println("/>");

+		return;

+	}

+	w.println(">");

+

+	for (int i = 0; i < size; i++) 

+		writeConfigurationElement(subElements[i], w, indent + IModel.INDENT);

+

+	w.println(gap1 + "</" + IModel.EXTENSION + ">");

+}

+public void writeExtensionPoint(ExtensionPointModel extPt, PrintWriter w, int indent) {

+	String gap1 = "";

+	for (int i = 0; i < indent; i++)

+		gap1 += " ";

+

+	w.print(gap1 + "<" + IModel.EXTENSION_POINT);

+	if (extPt.getId() != null)

+		w.print(" " + IModel.EXTENSION_POINT_ID + "=\"" + xmlSafe(extPt.getId()) + "\"");

+	if (extPt.getName() != null)

+		w.print(" " + IModel.EXTENSION_POINT_NAME + "=\"" + xmlSafe(extPt.getName()) + "\"");

+	if (extPt.getSchema() != null)

+		w.print(" " + IModel.EXTENSION_POINT_SCHEMA + "=\"" + xmlSafe(extPt.getSchema()) + "\"");

+	w.println("/>");

+}

+public void writeLibrary(LibraryModel library, PrintWriter w, int indent) {

+	String gap1 = "";

+	for (int i = 0; i < indent; i++)

+		gap1 += " ";

+	String gap2 = gap1;

+	for (int i = 0; i < IModel.INDENT; i++)

+		gap2 += " ";

+

+	w.print(gap1 + "<" + IModel.LIBRARY);

+	if (library.getName() != null)

+		w.print(" " + IModel.LIBRARY_NAME + "=\"" + xmlSafe(library.getName()) + "\"");

+	if (library.getType() != null)

+		w.print(" " + IModel.LIBRARY_TYPE + "=\"" + xmlSafe(library.getType()) + "\"");

+	if (!library.isExported())

+		w.println("/>");

+	else {

+		w.println(">");

+		String[] exports = library.getExports();

+		int size = (exports == null) ? 0 : exports.length;

+		for (int i = 0; i < size; i++)

+			w.println(gap2 + "<" + IModel.LIBRARY_EXPORT + " " + IModel.LIBRARY_EXPORT_MASK + "=\"" + xmlSafe(exports[i]) + "\"/>");

+		w.println(gap1 + "</" + IModel.LIBRARY + ">");

+	}

+}

+public void writePluginDescriptor(PluginDescriptorModel plugin, PrintWriter w, int indent) {

+

+	String gap1 = "";

+	for (int i = 0; i < indent; i++)

+		gap1 += " ";

+	String gap2 = gap1;

+	for (int i = 0; i < IModel.INDENT; i++)

+		gap2 += " ";

+

+	w.println("");

+	w.print(gap1 + "<" + IModel.PLUGIN);

+	if (plugin.getId() != null)

+		w.print(" " + IModel.PLUGIN_ID + "=\"" + xmlSafe(plugin.getId()) + "\"");

+	if (plugin.getName() != null)

+		w.print(" " + IModel.PLUGIN_NAME + "=\"" + xmlSafe(plugin.getName()) + "\"");

+	if (plugin.getProviderName() != null)

+		w.print(" " + IModel.PLUGIN_PROVIDER + "=\"" + xmlSafe(plugin.getProviderName()) + "\"");

+	if (plugin.getVersion() != null)

+		w.print(" " + IModel.PLUGIN_VERSION + "=\"" + xmlSafe(plugin.getVersion()) + "\"");

+	if (plugin.getPluginClass() != null)

+		w.print(" " + IModel.PLUGIN_CLASS + "=\"" + xmlSafe(plugin.getPluginClass()) + "\"");

+	w.println(">");

+

+	PluginPrerequisiteModel[] requires = plugin.getRequires();

+	int reqSize = (requires == null) ? 0 : requires.length;

+	if (reqSize != 0) {

+		w.print(gap2 + "<" + IModel.PLUGIN_REQUIRES);

+		w.println(">");

+		for (int i = 0; i < reqSize; i++) 

+			writePluginPrerequisite(requires[i], w, indent + 2 * IModel.INDENT);

+		w.println(gap2 + "</" + IModel.PLUGIN_REQUIRES + ">");

+	}

+

+	LibraryModel[] runtime = plugin.getRuntime();

+	int runtimeSize = (runtime == null) ? 0 : runtime.length;

+	if (runtimeSize != 0) {

+		w.println(gap2 + "<" + IModel.RUNTIME + ">");

+		for (int i = 0; i < runtimeSize; i++) {

+			writeLibrary(runtime[i], w, indent + 2 * IModel.INDENT);

+		}

+		w.println(gap2 + "</" + IModel.RUNTIME + ">");

+	}

+

+	ExtensionPointModel[] extensionPoints = plugin.getDeclaredExtensionPoints();

+	int extPointsSize = (extensionPoints == null) ? 0 : extensionPoints.length;

+	if (extPointsSize != 0) {

+		w.println("");

+		for (int i = 0; i < extPointsSize; i++)

+			writeExtensionPoint(extensionPoints[i], w, indent + IModel.INDENT);

+	}

+

+	ExtensionModel[] extensions = plugin.getDeclaredExtensions();

+	int extSize = (extensions == null) ? 0 : extensions.length;

+	if (extSize != 0) {

+		for (int i = 0; i < extSize; i++) {

+			w.println("");

+			writeExtension(extensions[i], w, indent + IModel.INDENT);

+		}

+	}

+	

+	// Don't write fragments here.  If we do, XML won't be

+	// able to parse what we write out.  Fragments must be

+	// entities separate from plugins.

+	w.println(gap1 + "</" + IModel.PLUGIN + ">");

+}

+public void writePluginFragment(PluginFragmentModel fragment, PrintWriter w, int indent) {

+

+	String gap1 = "";

+	for (int i = 0; i < indent; i++)

+		gap1 += " ";

+	String gap2 = gap1;

+	for (int i = 0; i < IModel.INDENT; i++)

+		gap2 += " ";

+

+	w.println("");

+	w.print(gap1 + "<" + IModel.FRAGMENT);

+	if (fragment.getId() != null)

+		w.print(" " + IModel.FRAGMENT_ID + "=\"" + xmlSafe(fragment.getId()) + "\"");

+	if (fragment.getName() != null)

+		w.print(" " + IModel.FRAGMENT_NAME + "=\"" + xmlSafe(fragment.getName()) + "\"");

+	if (fragment.getProviderName() != null)

+		w.print(" " + IModel.FRAGMENT_PROVIDER + "=\"" + xmlSafe(fragment.getProviderName()) + "\"");

+	if (fragment.getVersion() != null)

+		w.print(" " + IModel.FRAGMENT_VERSION + "=\"" + xmlSafe(fragment.getVersion()) + "\"");

+	if (fragment.getPluginId() != null)

+		w.print(" " + IModel.FRAGMENT_PLUGIN_ID + "=\"" + xmlSafe(fragment.getPluginId()) + "\"");

+	if (fragment.getPluginVersion() != null)

+		w.print(" " + IModel.FRAGMENT_PLUGIN_VERSION + "=\"" + xmlSafe(fragment.getPluginVersion()) + "\"");

+	w.println(">");

+

+	PluginPrerequisiteModel[] requires = fragment.getRequires();

+	int reqSize = (requires == null) ? 0 : requires.length;

+	if (reqSize != 0) {

+		w.print(gap2 + "<" + IModel.PLUGIN_REQUIRES);

+		w.println(">");

+		for (int i = 0; i < reqSize; i++) 

+			writePluginPrerequisite(requires[i], w, indent + 2 * IModel.INDENT);

+		w.println(gap2 + "</" + IModel.PLUGIN_REQUIRES + ">");

+	}

+

+	LibraryModel[] runtime = fragment.getRuntime();

+	int runtimeSize = (runtime == null) ? 0 : runtime.length;

+	if (runtimeSize != 0) {

+		w.println(gap2 + "<" + IModel.RUNTIME + ">");

+		for (int i = 0; i < runtimeSize; i++) {

+			writeLibrary(runtime[i], w, indent + 2 * IModel.INDENT);

+		}

+		w.println(gap2 + "</" + IModel.RUNTIME + ">");

+	}

+

+	ExtensionPointModel[] extensionPoints = fragment.getDeclaredExtensionPoints();

+	int extPointsSize = (extensionPoints == null) ? 0 : extensionPoints.length;

+	if (extPointsSize != 0) {

+		w.println("");

+		for (int i = 0; i < extPointsSize; i++)

+			writeExtensionPoint(extensionPoints[i], w, indent + IModel.INDENT);

+	}

+

+	ExtensionModel[] extensions = fragment.getDeclaredExtensions();

+	int extSize = (extensions == null) ? 0 : extensions.length;

+	if (extSize != 0) {

+		for (int i = 0; i < extSize; i++) {

+			w.println("");

+			writeExtension(extensions[i], w, indent + IModel.INDENT);

+		}

+	}

+

+	w.println(gap1 + "</" + IModel.FRAGMENT + ">");

+}

+public void writePluginPrerequisite(PluginPrerequisiteModel req, PrintWriter w, int indent) {

+	String gap1 = "";

+	for (int i = 0; i < indent; i++)

+		gap1 += " ";

+

+	w.print(gap1 + "<" + IModel.PLUGIN_REQUIRES_IMPORT);

+	if (req.getPlugin() != null)

+		w.print(" " + IModel.PLUGIN_REQUIRES_PLUGIN + "=\"" + xmlSafe(req.getPlugin()) + "\"");

+	if (req.getVersion() != null)

+		w.print(" " + IModel.PLUGIN_REQUIRES_PLUGIN_VERSION + "=\"" + xmlSafe(req.getVersion()) + "\"");

+	if (req.getExport())

+		w.print(" " + IModel.PLUGIN_REQUIRES_EXPORT + "=\"" + IModel.TRUE + "\"");

+	if (req.getOptional())

+		w.print(" " + IModel.PLUGIN_REQUIRES_OPTIONAL + "=\"" + IModel.TRUE + "\"");

+	if (req.getMatch())

+		w.print(" " + IModel.PLUGIN_REQUIRES_MATCH + "=\"" + IModel.PLUGIN_REQUIRES_MATCH_EXACT + "\"");

+	else

+		w.print(" " + IModel.PLUGIN_REQUIRES_MATCH + "=\"" + IModel.PLUGIN_REQUIRES_MATCH_COMPATIBLE + "\"");

+	w.println("/>");

+}

+public void writePluginRegistry(PluginRegistryModel registry, PrintWriter w, int indent) {

+	String gap1 = "";

+	for (int i = 0; i < indent; i++)

+		gap1 += " ";

+	w.println(gap1 + "<" + IModel.REGISTRY + ">");

+	PluginDescriptorModel[] pluginList = registry.getPlugins();

+	for (int i = 0; i < pluginList.length; i++)

+		writePluginDescriptor(pluginList[i], w, indent + IModel.INDENT);

+	

+	PluginFragmentModel[] fragmentList = registry.getFragments();

+	for (int i = 0; i < fragmentList.length; i++)

+		writePluginFragment(fragmentList[i], w, indent + IModel.INDENT);

+

+	w.println(gap1 + "</" + IModel.REGISTRY + ">");

+

+}

+private static void appendEscapedChar(StringBuffer buffer, char c) {

+	String replacement = getReplacement(c);

+	if (replacement != null) {

+		buffer.append('&');

+		buffer.append(replacement);

+		buffer.append(';');

+	} else {

+		if ((c >= ' ' && c <= 0x7E) || c == '\n' || c == '\r' || c == '\t') {

+			buffer.append(c);

+		} else {

+			buffer.append("&#");

+			buffer.append(Integer.toString(c));

+			buffer.append(';');

+		}

+	}

+}

+public static String xmlSafe(String s) {

+	StringBuffer result = new StringBuffer(s.length() + 10);

+	for (int i = 0; i < s.length(); ++i)

+		appendEscapedChar(result, s.charAt(i));

+	return result.toString();

+}

+private static String getReplacement(char c) {

+	// Encode special XML characters into the equivalent character references.

+	// These five are defined by default for all XML documents.

+	switch (c) {

+		case '<' :

+			return "lt";

+		case '>' :

+			return "gt";

+		case '"' :

+			return "quot";

+		case '\'' :

+			return "apos";

+		case '&' :

+			return "amp";

+	}

+	return null;

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/AdapterManager.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/AdapterManager.java
new file mode 100644
index 0000000..9d01cda
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/AdapterManager.java
@@ -0,0 +1,211 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import java.util.*;

+import org.eclipse.core.runtime.IAdaptable;

+import org.eclipse.core.runtime.IAdapterManager;

+import org.eclipse.core.runtime.IAdapterFactory;

+

+/**

+ * This class is a default implementation of <code>IExtenderManager</code>.

+ * It provides fast lookup of property values with the following semantics:

+ * <ul>

+ * <li> At most one extender will be invoked per property lookup

+ * <li> If multiple installed extenders provide the same property, only 

+ *		the first found in the search order is said to <i>define</i> the property 

+ *		as it is the only extender which will be invoked..

+ * <li> The search order from a class with the definition<br>

+ *			<code>class X extends Y implements A, B</code><br>

+ *		is as follows:

+ * 		<il>

+ *			<li>the target's class: X

+ *			<li>X's superclasses in order to <code>Object</code>

+ *			<li>a depth-first traversal of the target class's interaces in the order 

+ *				returned by <code>getInterfaces</code> (in the example, A and 

+ *				its superinterfaces then B and its superinterfaces)

+ *		</il>

+ * </ul>

+ *

+ * @see IAdapter

+ * @see IAdapterManager

+ */

+public final class AdapterManager implements IAdapterManager {

+

+	/** Table of factories, keyed by <code>Class</code>. */

+	protected Hashtable factories;

+

+	/** Cache of adapter search paths; <code>null</code> if none. */

+	protected Hashtable lookup;

+/** Constructs a new extender manager.

+ */

+public AdapterManager() {

+	factories = new Hashtable(5);

+	lookup = null;

+}

+/**

+ * Given a list of types, add all of the property entries for the installed

+ * extenders into the lookupTable.  Each entry will be keyed by the property

+ * identifier (supplied in IExtender.getPropertyList) and the extender

+ * supplying that property.

+ */

+private void addFactoriesFor(Vector types, Hashtable lookupTable) {

+	for (Enumeration classes = types.elements(); classes.hasMoreElements();) {

+		Class clazz = (Class) classes.nextElement();

+		Vector factoryList = (Vector) factories.get(clazz);

+		if (factoryList == null)

+			continue;

+		for (Enumeration list = factoryList.elements(); list.hasMoreElements();) {

+			IAdapterFactory factory = (IAdapterFactory) list.nextElement();

+			Object[] adapters = factory.getAdapterList();

+			for (int i = 0; i < adapters.length; i++) {

+				Object adapter = adapters[i];

+				if (lookupTable.get(adapter) == null)

+					lookupTable.put(adapter, factory);

+			}

+		}

+	}

+}

+/**

+ * Returns the class search order starting with <code>extensibleClass</code>.

+ * The search order is defined in this class' comment.

+ */

+private Vector computeClassOrder(Class extensibleClass) {

+	Vector result = new Vector(4);

+	Class clazz = extensibleClass;

+	while (clazz != null) {

+		result.addElement(clazz);

+		clazz = clazz.getSuperclass();

+	}

+	return result;

+}

+/**

+ * Returns the interface search order for the class hierarchy described

+ * by <code>classList</code>.

+ * The search order is defined in this class' comment.

+ */

+private Vector computeInterfaceOrder(Vector classList) {

+	Vector result = new Vector(4);

+	Hashtable seen = new Hashtable(4);

+	for (Enumeration list = classList.elements(); list.hasMoreElements();) {

+		Class[] interfaces = ((Class) list.nextElement()).getInterfaces();

+		internalComputeInterfaceOrder(interfaces, result, seen);

+	}

+	return result;

+}

+/**

+ * Flushes the cache of extender search paths.  This is generally required

+ * whenever an extender is added or removed.  

+ * <p>

+ * It is likely easier to just toss the whole cache rather than trying to be

+ * smart and remove only those entries affected.

+ * </p>

+ */

+public void flushLookup() {

+	lookup = null;

+}

+/*

+ * @see IAdapterManager#getAdapter

+ */

+public Object getAdapter(Object object, Class target) {

+	IAdapterFactory factory = getFactory(object.getClass(), target);

+	Object result = null;

+	if (factory != null)

+		result = factory.getAdapter(object, target);

+	if (result == null && target.isInstance(object))

+		return object;

+	return result;

+}

+/**

+ * Gets the extender installed for objects of class <code>extensibleClass</code>

+ * which defines the property identified by <code>key</code>.  If no such

+ * extender exists, returns null.

+ */

+private IAdapterFactory getFactory(Class extensibleClass, Class adapter) {

+	Hashtable table;

+	// check the cache first.

+	if (lookup != null) {

+		table = (Hashtable) lookup.get(extensibleClass);

+		if (table != null)

+			return (IAdapterFactory) table.get(adapter);

+	}

+	// Its not in the cache so we have to build the extender table for this class.

+	// The table is keyed by property identifier.  The 

+	// value is the <b>sole<b> extender which defines that property.  Note that if

+	// if multiple extenders technically define the same property, only the first found

+	// in the search order is considered.

+	table = new Hashtable(4);

+	// get the list of all superclasses and add the extenders installed for each 

+	// of those classes to the table.  

+	Vector classList = computeClassOrder(extensibleClass);

+	addFactoriesFor(classList, table);

+	// get the ordered set of all interfaces for the extensible class and its 

+	// superclasses and add the extenders installed for each 

+	// of those interfaces to the table.  

+	classList = computeInterfaceOrder(classList);

+	addFactoriesFor(classList, table);

+	// If there is still nothing, give up

+	if (table.isEmpty())

+		return null;

+	// otherwise, cache the table and do the lookup again.

+	if (lookup == null)

+		lookup = new Hashtable(5);

+	lookup.put(extensibleClass, table);

+	return (IAdapterFactory) table.get(adapter);

+}

+private void internalComputeInterfaceOrder(Class[] interfaces, Vector result, Hashtable seen) {

+	Vector newInterfaces = new Vector(seen.size());

+	for (int i = 0; i < interfaces.length; i++) {

+		Class interfac = interfaces[i];

+		if (seen.get(interfac) == null) {

+			result.addElement(interfac);

+			seen.put(interfac, interfac);

+			newInterfaces.addElement(interfac);

+		}

+	}

+	for (Enumeration newList = newInterfaces.elements(); newList.hasMoreElements();)

+		internalComputeInterfaceOrder(((Class) newList.nextElement()).getInterfaces(), result, seen);

+}

+/*

+ * @see IAdapterManager#registerAdapters

+ */

+public void registerAdapters(IAdapterFactory factory, Class extensibleType) {

+	Vector list = (Vector) factories.get(extensibleType);

+	if (list == null) {

+		list = new Vector(5);

+		factories.put(extensibleType, list);

+	}

+	list.addElement(factory);

+	flushLookup();

+}

+/*

+ * @see IAdapterManager#unregisterAdapters

+ */

+public void unregisterAdapters(IAdapterFactory factory) {

+	for (Enumeration enum = factories.elements(); enum.hasMoreElements();) {

+		Vector list = (Vector) enum.nextElement();

+		list.removeElement(factory);

+	}

+	flushLookup();

+}

+/*

+ * @see IAdapterManager#unregisterAdapters

+ */

+public void unregisterAdapters(IAdapterFactory factory, Class extensibleType) {

+	Vector factoryList = (Vector) factories.get(extensibleType);

+	if (factoryList == null)

+		return;

+	factoryList.removeElement(factory);

+	flushLookup();

+}

+/*

+ * @see IAdapterManager#unregisterAllAdapters

+ */

+public void unregisterAllAdapters() {

+	factories = new Hashtable(5);

+	flushLookup();

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Assert.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Assert.java
new file mode 100644
index 0000000..38b14f7
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Assert.java
@@ -0,0 +1,98 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * <code>Assert</code> is useful for for embedding runtime sanity checks

+ * in code.

+ * The predicate methods all test a condition and throw some

+ * type of unchecked exception if the condition does not hold.

+ * <p>

+ * Assertion failure exceptions, like most runtime exceptions, are

+ * thrown when something is misbehaving. Assertion failures are invariably

+ * unspecified behavior; consequently, clients should never rely on

+ * these being thrown (and certainly should not being catching them

+ * specifically).

+ * </p>

+ */

+public final class Assert {

+/* This class is not intended to be instantiated. */

+private Assert() {

+}

+/** Asserts that an argument is legal. If the given boolean is

+ * not <code>true</code>, an <code>IllegalArgumentException</code>

+ * is thrown.

+ *

+ * @param expression the outcode of the check

+ * @return <code>true</code> if the check passes (does not return

+ *    if the check fails)

+ * @exception IllegalArgumentException if the legality test failed

+ */

+public static boolean isLegal(boolean expression) {

+	return isLegal(expression, "");

+}

+/** Asserts that an argument is legal. If the given boolean is

+ * not <code>true</code>, an <code>IllegalArgumentException</code>

+ * is thrown.

+ * The given message is included in that exception, to aid debugging.

+ *

+ * @param expression the outcode of the check

+ * @param message the message to include in the exception

+ * @return <code>true</code> if the check passes (does not return

+ *    if the check fails)

+ * @exception IllegalArgumentException if the legality test failed

+ */

+public static boolean isLegal(boolean expression, String message) {

+	if (!expression)

+		throw new IllegalArgumentException(message);

+	return expression;

+}

+/** Asserts that the given object is not <code>null</code>. If this

+ * is not the case, some kind of unchecked exception is thrown.

+ * 

+ * @param object the value to test

+ * @exception IllegalArgumentException if the object is <code>null</code>

+ */

+public static void isNotNull(Object object) {

+	isNotNull(object, "");

+}

+/** Asserts that the given object is not <code>null</code>. If this

+ * is not the case, some kind of unchecked exception is thrown.

+ * The given message is included in that exception, to aid debugging.

+ *

+ * @param object the value to test

+ * @param message the message to include in the exception

+ * @exception IllegalArgumentException if the object is <code>null</code>

+ */

+public static void isNotNull(Object object, String message) {

+	if (object == null)

+		throw new AssertionFailedException("null argument:" + message);

+}

+/** Asserts that the given boolean is <code>true</code>. If this

+ * is not the case, some kind of unchecked exception is thrown.

+ *

+ * @param expression the outcode of the check

+ * @return <code>true</code> if the check passes (does not return

+ *    if the check fails)

+ */

+public static boolean isTrue(boolean expression) {

+	return isTrue(expression, "");

+}

+/** Asserts that the given boolean is <code>true</code>. If this

+ * is not the case, some kind of unchecked exception is thrown.

+ * The given message is included in that exception, to aid debugging.

+ *

+ * @param expression the outcode of the check

+ * @param message the message to include in the exception

+ * @return <code>true</code> if the check passes (does not return

+ *    if the check fails)

+ */

+public static boolean isTrue(boolean expression, String message) {

+	if (!expression)

+		throw new AssertionFailedException("assertion failed: "+message);

+	return expression;

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/AssertionFailedException.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/AssertionFailedException.java
new file mode 100644
index 0000000..325bb51
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/AssertionFailedException.java
@@ -0,0 +1,28 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * <code>AssertionFailedException</code> is a runtime exception thrown

+ * by some of the methods in <code>Assert</code>.

+ * <p>

+ * This class is not declared public to prevent some misuses; programs that catch 

+ * or otherwise depend on assertion failures are susceptible to unexpected

+ * breakage when assertions in the code are added or removed.

+ * </p>

+ */

+/* package */

+class AssertionFailedException extends RuntimeException {

+/** Constructs a new exception.

+ */

+public AssertionFailedException() {

+}

+/** Constructs a new exception with the given message.

+ */

+public AssertionFailedException(String detail) {

+	super(detail);

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/AuthorizationDatabase.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/AuthorizationDatabase.java
new file mode 100644
index 0000000..d99ddda
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/AuthorizationDatabase.java
@@ -0,0 +1,292 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import java.io.*;

+import java.net.*;

+import java.util.*;

+

+/**

+ * A database that remembers information, such as usernames and

+ * passwords.  The information is stored in memory and can be saved

+ * to disk in an encrypted format.  While the API is phrased in terms of

+ * URLs, realms and authentication schemes, not all of these must have

+ * significant values.  For example, if "realm" is not relevant to a

+ * particular application, it can be left blank (though not

+ * <code>null</code>).

+ */

+public class AuthorizationDatabase {

+	/**

+	 * A nested hashtable that stores authorization information. The

+	 * table maps server URLs to realms to authentication schemes to

+	 * authorization information.

+	 */

+	private Hashtable authorizationInfo = new Hashtable(5);

+

+	/**

+	 * A hashtable mapping resource URLs to realms.

+	 */

+	private Hashtable protectionSpace = new Hashtable(5);

+

+	private File file = null;

+	private String password = null;

+	private boolean needsSaving = true;

+/**

+ * Creates a new authorization database whose data cannot be saved to

+ * disk.

+ */

+public AuthorizationDatabase() {

+}

+/**

+ * Creates a new authorization database, or opens an existing one, whose

+ * data is, or can be, saved to a file with the given filename. A

+ * password must be given to create a new database and an existing

+ * database is opened by supplying the password that was given to create

+ * it.

+ *

+ * @param filename the location of the database on disk. For example,

+ *		"c:/temp/database"

+ * @param password the password to access the database. For example,

+ *		"secret"

+ * @exception Exception if there are problems creating the database.

+ *		Reasons include:

+ * <ul>

+ * <li>The database could not be opened because the wrong password was given.

+ * <li>The database could not be opened because the specified file is corrupt.

+ * </ul>

+ */

+public AuthorizationDatabase(String filename, String password) throws CoreException {

+	Assert.isNotNull(filename);

+	Assert.isNotNull(password);

+	this.password = password;

+	file = new File(filename);

+	load();

+}

+/**

+ * Adds the given authorization information to the database. The

+ * information is relevant for the specified protection space and the

+ * given authorization scheme. The protection space is defined by the

+ * combination of the given server URL and realm. The authorization 

+ * scheme determines what the authorization information contains and how 

+ * it should be used. The authorization information is a <code>Map</code> 

+ * of <code>String</code> to <code>String</code> and typically

+ * contain information such as usernames and passwords.

+ *

+ * @param serverUrl the URL identifying the server for this authorization

+ *		information. For example, "http://www.hostname.com/".

+ * @param realm the subsection of the given server to which this

+ *		authorization information applies.  For example,

+ *		"realm1@hostname.com" or "" for no realm.

+ * @param authScheme the scheme for which this authorization information

+ *		applies. For example, "Basic" or "" for no authorization scheme

+ * @param info a <code>Map</code> containing authorization information 

+ *		such as usernames and passwords

+ */

+public void addAuthorizationInfo(URL serverUrl, String realm, String authScheme, Map info){

+	Assert.isNotNull(serverUrl);

+	Assert.isNotNull(realm);

+	Assert.isNotNull(authScheme);

+	Assert.isNotNull(info);

+

+	String url = serverUrl.toString();

+	Hashtable realmToAuthScheme = (Hashtable)authorizationInfo.get(url);

+	if(realmToAuthScheme == null){

+		realmToAuthScheme = new Hashtable(5);

+		authorizationInfo.put(url, realmToAuthScheme);

+	}

+

+	Hashtable authSchemeToInfo = (Hashtable)realmToAuthScheme.get(realm);

+	if(authSchemeToInfo == null){

+		authSchemeToInfo = new Hashtable(5);

+		realmToAuthScheme.put(realm, authSchemeToInfo);

+	}

+

+	authSchemeToInfo.put(authScheme.toLowerCase(), info);

+	needsSaving = true;

+}

+/**

+ * Adds the specified resource to the protection space specified by the

+ * given realm. All resources at or deeper than the depth of the last

+ * symbolic element in the path of the given resource URL are assumed to

+ * be in the same protection space.

+ *

+ * @param resourceUrl the URL identifying the resources to be added to

+ *		the specified protection space. For example,

+ *		"http://www.hostname.com/folder/".

+ * @param realm the name of the protection space. For example,

+ *		"realm1@hostname.com"

+ */

+public void addProtectionSpace(URL resourceUrl, String realm){

+	Assert.isNotNull(resourceUrl);

+	Assert.isNotNull(realm);

+

+	String file = resourceUrl.getFile();

+	if(!file.endsWith("/")){

+		resourceUrl = URLTool.getParent(resourceUrl);

+	}

+

+	String oldRealm = getProtectionSpace(resourceUrl);

+	if(oldRealm != null && oldRealm.equals(realm)){

+		return;

+	}

+

+	String url1 = resourceUrl.toString();

+	Enumeration urls = protectionSpace.keys();

+	while(urls.hasMoreElements()){

+		String url2 = (String)urls.nextElement();

+		if(url1.startsWith(url2) || url2.startsWith(url1)){

+			protectionSpace.remove(url2);

+			break;

+		}

+	}

+

+	protectionSpace.put(url1, realm);

+	needsSaving = true;

+}

+/**

+ * Removes the authorization information for the specified protection

+ * space and given authorization scheme. The protection space is defined

+ * by the given server URL and realm.

+ *

+ * @param serverUrl the URL identifying the server to remove the

+ *		authorization information for. For example,

+ *		"http://www.hostname.com/".

+ * @param realm the subsection of the given server to remove the

+ *		authorization information for. For example,

+ *		"realm1@hostname.com" or "" for no realm.

+ * @param authScheme the scheme for which the authorization information

+ *		to remove applies. For example, "Basic" or "" for no

+ *		authorization scheme.

+ */

+public void flushAuthorizationInfo(URL serverUrl, String realm, String authScheme) {

+	Hashtable realmToAuthScheme = (Hashtable)authorizationInfo.get(serverUrl.toString());

+

+	if(realmToAuthScheme == null){

+		return;

+	}

+

+	Hashtable authSchemeToInfo = (Hashtable)realmToAuthScheme.get(realm);

+

+	if(authSchemeToInfo == null){

+		return;

+	}

+

+	authSchemeToInfo.remove(authScheme.toLowerCase());

+

+	needsSaving = true;

+}

+/**

+ * Returns the authorization information for the specified protection

+ * space and given authorization scheme. The protection space is defined

+ * by the given server URL and realm. Returns <code>null</code> if no

+ * such information exists.

+ *

+ * @param serverUrl the URL identifying the server for the authorization

+ *		information. For example, "http://www.hostname.com/".

+ * @param realm the subsection of the given server to which the

+ *		authorization information applies.  For example,

+ *		"realm1@hostname.com" or "" for no realm.

+ * @param authScheme the scheme for which the authorization information

+ *		applies. For example, "Basic" or "" for no authorization scheme

+ * @return the authorization information for the specified protection

+ *		space and given authorization scheme, or <code>null</code> if no

+ *		such information exists

+ */

+public Map getAuthorizationInfo(URL serverUrl, String realm, String authScheme){

+	Hashtable realmToAuthScheme = (Hashtable)authorizationInfo.get(serverUrl.toString());

+	if(realmToAuthScheme == null){

+		return null;

+	}

+

+	Hashtable authSchemeToInfo = (Hashtable)realmToAuthScheme.get(realm);

+	if(authSchemeToInfo == null){

+		return null;

+	}

+

+	return (Map)authSchemeToInfo.get(authScheme.toLowerCase());

+}

+/**

+ * Returns the protection space (realm) for the specified resource, or

+ * <code>null</code> if the realm is unknown.

+ *

+ * @param resourceUrl the URL of the resource whose protection space is

+ *		returned. For example, "http://www.hostname.com/folder/".

+ * @return the protection space (realm) for the specified resource, or

+ *		<code>null</code> if the realm is unknown

+ */

+public String getProtectionSpace(URL resourceUrl){

+	while(resourceUrl != null){

+		String realm = (String)protectionSpace.get(resourceUrl.toString());

+		if(realm != null){

+			return realm;

+		}

+		resourceUrl = URLTool.getParent(resourceUrl);

+	}

+

+	return null;

+}

+private void load() throws CoreException {

+	if (file == null)

+		return;

+	if (!file.exists()) {

+		save();

+		return;

+	}

+	try {

+		InputStream input = new FileInputStream(file);

+		try {

+			load(input);

+		} finally {

+			input.close();

+		}

+	} catch (IOException e) {

+		throw new CoreException(new Status(IStatus.ERROR,Platform.PI_RUNTIME,13,Policy.bind("meta.unableToReadAuthorization",file.toString()),e));

+	} catch (ClassNotFoundException e) {

+		throw new CoreException(new Status(IStatus.ERROR,Platform.PI_RUNTIME,13,Policy.bind("meta.unableToReadAuthorization",file.toString()),e));

+	}

+}

+private void load(InputStream is) throws IOException, ClassNotFoundException {

+	CipherInputStream cis = new CipherInputStream(is, password);

+	ObjectInputStream ois = new ObjectInputStream(cis);

+	authorizationInfo = (Hashtable) ois.readObject();

+	protectionSpace = (Hashtable) ois.readObject();

+	ois.close();

+}

+/**

+ * Saves the authorization database to disk.

+ */

+public void save() throws CoreException {

+	if (!needsSaving || file == null)

+		return;

+	try {

+		file.delete();

+		file.createNewFile();

+		save(new FileOutputStream(file));

+	} catch (IOException e) {

+		throw new CoreException(new Status(IStatus.ERROR,Platform.PI_RUNTIME,13,Policy.bind("meta.unableToWriteAuthorization",file.toString()),e));

+	}

+	needsSaving = false;

+}

+private void save(OutputStream os) throws IOException {

+	CipherOutputStream cos = new CipherOutputStream(os, password);

+	ObjectOutputStream oos = new ObjectOutputStream(cos);

+	oos.writeObject(authorizationInfo);

+	oos.writeObject(protectionSpace);

+	oos.close();

+}

+/**

+ * Sets the password to use for accessing this database.  If the database

+ * is subsequently saved, this new password is used.

+ */

+public boolean setPassword(String oldValue, String newValue) {

+	if (!oldValue.equals(password))

+		return false;

+	password = newValue;

+	needsSaving = true;

+	return true;

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Cipher.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Cipher.java
new file mode 100644
index 0000000..5ad3974
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Cipher.java
@@ -0,0 +1,106 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import java.security.MessageDigest;

+import java.security.SecureRandom;

+

+/**

+ * <P>Encrypts or decrypts a sequence of bytes. The bytes are decrypted

+ * by supplying the same password that was given when the bytes were

+ * encrypted.

+ * <P>Here is an example showing how to encrypt and then decrypt the

+ * string "Hello, world!" using the password "music":

+ * <pre>

+ *     String password = "music";

+ *     byte[] data = "Hello, world!".getBytes("UTF8");

+ *

+ *     // Encrypt

+ *     Cipher cipher = new Cipher(ENCRYPT_MODE, password);

+ *     byte[] encrypted = cipher.update(data);

+ *

+ *     // Decrypt

+ *     cipher = new Cipher(DECRYPT_MODE, password);

+ *     byte[] decrypted = cipher.update(encrypted);

+ * </pre>

+ */

+public class Cipher {

+	public static final int DECRYPT_MODE = -1;

+	public static final int ENCRYPT_MODE = 1;

+

+	private int mode = 0;

+	private String password = null;

+	private SecureRandom secureRandom = null;

+/**

+ * Initializes the cipher with the given mode and password. This method

+ * must be called first (before any encryption of decryption takes

+ * place) to specify whether the cipher should be in encrypt or decrypt

+ * mode and to set the password.

+ *

+ * @param mode

+ * @param password

+ */

+public Cipher (int mode, String password){

+	this.mode = mode;

+	this.password = password;

+	this.secureRandom = null;

+}

+/**

+ * Encrypts or decrypts (depending on which mode the cipher is in) the

+ * given data and returns the result.

+ *

+ * @param data

+ * @return     the result of encrypting or decrypting the given data

+ */

+public byte[] cipher(byte[] data) throws Exception {

+	return transform(data, 0, data.length, mode);

+}

+/**

+ * Encrypts or decrypts (depending on which mode the cipher is in) the

+ * given data and returns the result.

+ *

+ * @param data the byte array containg the given data

+ * @param off  the index of the first byte in the given byte array

+ *             to be transformed

+ * @param len  the index after the last byte in the given byte array

+ *             to be transformed

+ * @return     the result of encrypting or decrypting the given data

+ */

+public byte[] cipher(byte[] data, int off, int len) throws Exception {

+	return transform(data, off, len, mode);

+}

+/**

+ * Encrypts or decrypts (depending on which mode the cipher is in) the

+ * given byte and returns the result.

+ *

+ * @param datum the given byte

+ * @return      the result of encrypting or decrypting the given byte

+ */

+public byte cipher(byte datum) throws Exception {

+	byte[] data = { datum };

+	return cipher(data)[0];

+}

+private byte[] getSeed() throws Exception {

+	MessageDigest messageDigest = MessageDigest.getInstance("SHA");

+	return messageDigest.digest(password.getBytes("UTF8"));

+}

+private byte[] nextRandom(int length) throws Exception {

+	if (secureRandom == null) {

+		secureRandom = SecureRandom.getInstance("SHA1PRNG");

+		secureRandom.setSeed(getSeed());

+	}

+	byte[] nextRandom = new byte[length];

+	secureRandom.nextBytes(nextRandom);

+	return nextRandom;

+}

+private byte[] transform(byte[] data, int off, int len, int mode) throws Exception {

+	byte[] result = nextRandom(len);

+	for (int i = 0; i < len; ++i) {

+		result[i] = (byte) (data[i + off] + mode * result[i]);

+	}

+	return result;

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/CipherInputStream.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/CipherInputStream.java
new file mode 100644
index 0000000..505f31a
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/CipherInputStream.java
@@ -0,0 +1,86 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import java.io.*;

+

+/**

+ * Decrypts a stream of data that was encrypted using the

+ * <code>Cipher</code> or <code>CipherOutputStream</code>.

+ *

+ * @see Cipher

+ * @see CipherOutputStream

+ */

+public class CipherInputStream extends FilterInputStream {

+	private static final int SKIP_BUFFER_SIZE = 2048;

+	private Cipher cipher;

+/**

+ * Constructs a new <code>CipherInputStream</code> that decrypts the

+ * data in the given <code>InputStream</code>.  The data can only be

+ * decrypted if the given password is the same as that which was used

+ * to encrypt it.

+ *

+ * @param is

+ * @param password

+ */

+public CipherInputStream(InputStream is, String password) {

+	super(is);

+	cipher = new Cipher(Cipher.DECRYPT_MODE, password);

+}

+/**

+ * @see InputStream#markSupported

+ */

+public boolean markSupported() {

+	return false;

+}

+/**

+ * @see InputStream#read

+ */

+public int read() throws IOException {

+	int b = super.read();

+	if (b == -1)

+		return -1;

+	try {

+		return ((int) cipher.cipher((byte) b)) & 0x00ff;

+	} catch (Exception e) {

+		throw new IOException(e.getMessage());

+	}

+}

+/**

+ * @see InputStream#read(byte, int, int)

+ */

+public int read(byte b[], int off, int len) throws IOException {

+	int bytesRead = in.read(b, off, len);

+	if (bytesRead == -1)

+		return -1;

+	try {

+		byte[] result = cipher.cipher(b, off, bytesRead);

+		for (int i = 0; i < result.length; ++i)

+			b[i + off] = result[i];

+		return bytesRead;

+	} catch (Exception e) {

+		throw new IOException(e.getMessage());

+	}

+}

+/**

+ * @see InputStream#skip(long)

+ */

+public long skip(long n) throws IOException {

+	byte[] buffer = new byte[SKIP_BUFFER_SIZE];

+

+	int bytesRead = 0;

+	long bytesRemaining = n;

+

+	while(bytesRead != -1 && bytesRemaining > 0){

+		bytesRead = read(buffer, 0, (int)Math.min(SKIP_BUFFER_SIZE, bytesRemaining));

+		if(bytesRead > 0){

+			bytesRemaining -= bytesRead;

+		}

+	}

+

+	return n - bytesRemaining;

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/CipherOutputStream.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/CipherOutputStream.java
new file mode 100644
index 0000000..c48c0fb
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/CipherOutputStream.java
@@ -0,0 +1,43 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import java.io.*;

+

+/**

+ * Encrypts a stream of data that can be decrypted using the

+ * <code>Cipher</code> or <code>CipherInputStream</code>.

+ *

+ * @see Cipher

+ * @see CipherInputStream

+ */

+public class CipherOutputStream extends FilterOutputStream {

+	private Cipher cipher;

+/**

+ * Constructs a new <code>CipherOutputStream</code> that encrypts the

+ * data in the given <code>OutputStream</code>.  Once the data is

+ * encrypted it can be decrypted by suppying the encrupted data and

+ * given password to a <code>Cipher</code> or

+ * <code>CipherInputStream</code>.

+ *

+ * @param os

+ * @param password

+ */

+public CipherOutputStream(OutputStream os, String password) {

+	super(os);

+	cipher = new Cipher(Cipher.ENCRYPT_MODE, password);

+}

+/**

+ * @see OutputStream#write(int)

+ */

+public void write(int b) throws IOException {

+	try {

+		out.write(cipher.cipher((byte) b));

+	} catch (Exception e) {

+		throw new IOException(e.getMessage());

+	}

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/InternalPlatform.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/InternalPlatform.java
new file mode 100644
index 0000000..14b0091
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/InternalPlatform.java
@@ -0,0 +1,795 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.boot.BootLoader;

+import org.eclipse.core.boot.IPlatformRunnable;

+import org.eclipse.core.internal.boot.*;

+import org.eclipse.core.runtime.model.*;

+import org.eclipse.core.runtime.*;

+import org.eclipse.core.internal.runtime.*;

+import org.eclipse.core.internal.plugins.*;

+import java.io.*;

+import java.net.*;

+import java.util.*;

+

+/**

+ * Bootstrap class for the platform. It is responsible for setting up the

+ * platform class loader and passing control to the actual application class

+ */

+public final class InternalPlatform {

+	private static IAdapterManager adapterManager;

+	private static PluginRegistry registry;

+	private static Set logListeners = new HashSet(5);

+	private static Map logs = new HashMap(5);

+	private static PlatformLogListener platformLog = null;

+	private static PlatformMetaArea metaArea;

+	private static boolean initialized;

+	private static IPath location;

+	private static PluginClassLoader xmlClassLoader = null;

+

+	private static boolean debugEnabled = false;

+	private static boolean consoleLogEnabled = false;

+	private static ILogListener consoleLog = null;

+	private static Properties options = null;

+	private static AuthorizationDatabase keyring = null;

+	private static String keyringFile = null;

+	private static String password = "";

+	private static boolean inDevelopmentMode = false;

+	private static boolean splashDown = false;

+	private static boolean cacheRegistry = false;

+

+	// default plugin data

+	private static final String PI_XML = "org.apache.xerces";

+	private static final String PLUGINSDIR = "plugins/";

+	private static final String XML_VERSION = "1.2.1";

+	private static final String XML_JAR = "xerces.jar";

+	private static final String XML_LOCATION = "plugins/" + PI_XML + "/";

+

+	// execution options

+	private static final String OPTION_DEBUG = Platform.PI_RUNTIME + "/debug";

+	private static final String OPTION_DEBUG_PLUGINS = Platform.PI_RUNTIME + "/registry/debug";

+

+	// command line options

+	private static final String LOG = "-consolelog";

+	private static final String KEYRING = "-keyring";

+	private static final String PASSWORD = "-password";

+	private static final String DEV = "-dev";

+	private static final String ENDSPLASH = "-endsplash";

+	private static final String REGISTRYCACHE = "-registrycache";

+

+	// debug support:  set in loadOptions()

+	public static boolean DEBUG = false;

+	public static boolean DEBUG_PLUGINS = false;

+

+	private static boolean inVAJ;

+	static {

+		try {

+			Class.forName("com.ibm.uvm.lang.ProjectClassLoader");

+			inVAJ = true;

+		} catch (Exception e) {

+			inVAJ = false;

+		}

+	}

+	private static boolean inVAME;

+	static {

+		try {

+			Class.forName("com.ibm.eclipse.core.VAME");

+			inVAME = true;

+		} catch (Exception e) {

+			inVAME = false;

+		}

+	}

+/**

+ * Private constructor to block instance creation.

+ */

+private InternalPlatform() {

+}

+/**

+ * The runtime plug-in is not totally real due to bootstrapping problems.

+ * This method builds the required constructs to activate and install

+ * the runtime plug-in.

+ */

+private static void activateDefaultPlugins() throws CoreException {

+	// for now, simply do the default activation.  This does not do the right thing

+	// wrt the plugin class loader.

+	PluginDescriptor descriptor = (PluginDescriptor) registry.getPluginDescriptor(Platform.PI_RUNTIME);

+	descriptor.setPluginClassLoader(PlatformClassLoader.getDefault());

+	descriptor.getPlugin();

+

+	descriptor = (PluginDescriptor) registry.getPluginDescriptor(PI_XML);

+	descriptor.setPluginClassLoader(xmlClassLoader);

+	xmlClassLoader.setPluginDescriptor(descriptor);

+	descriptor.getPlugin();

+}

+/**

+ * @see Platform

+ */

+public static void addAuthorizationInfo(URL serverUrl, String realm, String authScheme, Map info) throws CoreException {

+	keyring.addAuthorizationInfo(serverUrl, realm, authScheme, new HashMap(info));

+	keyring.save();

+}

+/**

+ * @see Platform#addLogListener

+ */

+public static void addLogListener(ILogListener listener) {

+	assertInitialized();

+	synchronized (logListeners) {

+		logListeners.add(listener);

+	}

+}

+/**

+ * @see Platform

+ */

+public static void addProtectionSpace(URL resourceUrl, String realm) throws CoreException {

+	keyring.addProtectionSpace(resourceUrl, realm);

+	keyring.save();

+}

+/**

+ * @see Platform

+ */

+public static URL asLocalURL(URL url) throws IOException {

+	URLConnection connection = url.openConnection();

+	if (!(connection instanceof PlatformURLConnection))

+		return url;

+	String file = connection.getURL().getFile();

+	if (file.endsWith("/") && !file.endsWith(PlatformURLHandler.JAR_SEPARATOR))

+		throw new IOException();

+	return ((PlatformURLConnection) connection).getURLAsLocal();

+}

+private static void assertInitialized() {

+	Assert.isTrue(initialized, "meta.appNotInit");

+}

+private static String findPlugin(LaunchInfo.VersionedIdentifier[] list, String name, String version) {

+	LaunchInfo.VersionedIdentifier result = null;

+	for (int i = 0; i < list.length; i++) {

+		if (list[i].getIdentifier().equals(name)) {

+			if (version != null)

+				// we are looking for a particular version, compare.  If the current element 

+				// has no version, save it for later in case we don't fine what we are looking for.

+				if (list[i].getVersion().equals(version))

+					return list[i].toString();

+				else

+					if (result == null && list[i].getVersion().length() == 0)

+						result = list[i];

+			else 

+				// remember the element with the latest version number.

+				if (result == null)

+					result = list[i];

+				else 

+					if (result.getVersion().compareTo(list[i].getVersion()) == -1)

+						result = list[i];

+		}

+	}

+	return result == null ? null : result.toString();

+}

+

+/**

+ * Creates and remembers a spoofed up class loader which loads the

+ * classes from a predefined XML plugin.

+ */

+private static void createXMLClassLoader() {

+	// create a plugin descriptor which is sufficient to be able to create

+	// the class loader through the normal channels.

+	Factory factory = new InternalFactory(null);

+	PluginDescriptor descriptor = (PluginDescriptor) factory.createPluginDescriptor();

+	descriptor.setEnabled(true);

+	descriptor.setId(PI_XML);

+	descriptor.setVersion(XML_VERSION);

+

+	try {

+		LaunchInfo launch = LaunchInfo.getCurrent();

+		String plugin = findPlugin(launch.getPlugins(), PI_XML, XML_VERSION);

+		URL url = null;

+		if (plugin == null)

+			url = new URL(BootLoader.getInstallURL(), XML_LOCATION);

+		else

+			url = new URL(BootLoader.getInstallURL(), PLUGINSDIR + plugin + "/");

+		descriptor.setLocation(url.toExternalForm());

+	} catch (MalformedURLException e) {

+		// ISSUE: What to do when this fails.  It's pretty serious

+	}

+

+	LibraryModel lib = factory.createLibrary();

+	lib.setName(XML_JAR);

+	lib.setExports(new String[] { "*" });

+	descriptor.setRuntime(new LibraryModel[] { lib });

+

+	// use the fake plugin descriptor to create the desired class loader.

+	// Since this class loader will be used before the plugin registry is installed,

+	// ensure that the URLs on its class path are raw as opposed to eclipse:

+	xmlClassLoader = (PluginClassLoader) descriptor.getPluginClassLoader(false);

+}

+/**

+ * @see Platform

+ */

+public static void endSplash() {

+	if (DEBUG) {

+		String startString = Platform.getDebugOption(Platform.OPTION_STARTTIME);

+		if (startString != null) 

+			try {

+				long start = Long.parseLong(startString);

+				long end = System.currentTimeMillis();

+				System.out.println("Startup complete: " + (end - start) + "ms");

+			} catch (NumberFormatException e) {

+			}

+	}	

+	if (splashDown) 

+		return;

+	String[] args = BootLoader.getCommandLineArgs();

+	String splash = null;

+	for (int i = 0; i < args.length; i++)

+        if (args[i].equalsIgnoreCase(ENDSPLASH) && (i + 1) < args.length)

+            splash = args[i + 1];

+	if (splash != null)

+	try {

+		splashDown = true;

+		Runtime.getRuntime().exec(splash);

+	} catch (Exception e) {

+	}

+}

+

+/**

+ * @see Platform

+ */

+public static void flushAuthorizationInfo(URL serverUrl, String realm, String authScheme) throws CoreException {

+	keyring.flushAuthorizationInfo(serverUrl, realm, authScheme);

+	keyring.save();

+}

+/**

+ * @see Platform#getAdapterManager

+ */

+public static IAdapterManager getAdapterManager() {

+	assertInitialized();

+	return adapterManager;

+}

+

+/**

+ * Augments the plugin path with extra entries.

+ */

+private static URL[] getAugmentedPluginPath(URL[] pluginPath) {

+	

+	// ISSUE: this code needs to be reworked so that the platform

+	//        does not have logical reference to plug-in-specific

+	//        function

+		

+	IPath result = metaArea.getLocation().append(PlatformMetaArea.F_PLUGIN_DATA).append("org.eclipse.scripting").append("plugin.xml");

+	String userScriptName = result.toString();

+	URL userScriptUrl = null;

+	try {

+		userScriptUrl = new URL("file",null,0,userScriptName);

+	} catch(MalformedURLException e) {

+		return pluginPath;

+	}

+		

+	URL[] newPath = new URL[pluginPath.length+1];

+	System.arraycopy(pluginPath,0,newPath,0, pluginPath.length);

+	newPath[newPath.length-1] = userScriptUrl;	

+	return newPath;

+}

+/**

+ * @see Platform

+ */

+public static Map getAuthorizationInfo(URL serverUrl, String realm, String authScheme) {

+	Map info = keyring.getAuthorizationInfo(serverUrl, realm, authScheme);

+	return info == null ? null : new HashMap(info);

+}

+public static boolean getBooleanOption(String option, boolean defaultValue) {

+	String optionValue = options.getProperty(option);

+	return (optionValue != null && optionValue.equalsIgnoreCase("true"))  || defaultValue;

+}

+/**

+ * @see Platform

+ */

+public static String getDebugOption(String option) {

+	return debugEnabled ? options.getProperty(option) : null;

+}

+public static int getIntegerOption(String option, int defaultValue) {

+	String value = getDebugOption(option);

+	try {

+		return value == null ? defaultValue : Integer.parseInt(value);

+	} catch (NumberFormatException e) {

+		return defaultValue;

+	}

+}

+/**

+ * @see Platform#getLocation

+ */

+public static IPath getLocation() {

+	assertInitialized();

+	return location;

+}

+/**

+ * Returns a log for the given plugin or <code>null</code> if none exists.

+ */

+public static ILog getLog(Plugin plugin) {

+	ILog result = (ILog) logs.get(plugin);

+	if (result != null)

+		return result;

+	result = new Log(plugin);

+	logs.put(plugin, result);

+	return result;

+}

+/**

+ * Returns the object which defines the location and organization

+ * of the platform's meta area.

+ */

+public static PlatformMetaArea getMetaArea() {

+	return metaArea;

+}

+/**

+ * @see Platform#getPlugin

+ */

+public static Plugin getPlugin(String id) {

+	assertInitialized();

+	IPluginDescriptor descriptor = getPluginRegistry().getPluginDescriptor(id);

+	if (descriptor == null)

+		return null;

+	try {

+		return descriptor.getPlugin();

+	} catch (CoreException e) {

+		return null;

+	}

+}

+/**

+ * @see Platform#getPluginRegistry

+ */

+public static IPluginRegistry getPluginRegistry() {

+	assertInitialized();

+	return registry;

+}

+/**

+ * @see Platform#getPluginStateLocation

+ */

+public static IPath getPluginStateLocation(Plugin plugin) {

+	assertInitialized();

+	IPath result = metaArea.getPluginStateLocation(plugin);

+	result.toFile().mkdirs();

+	return result;

+}

+/**

+ * @see Platform

+ */

+public static String getProtectionSpace(URL resourceUrl) {

+	return keyring.getProtectionSpace(resourceUrl);

+}

+public static Plugin getRuntimePlugin() {

+	try {

+		return getPluginRegistry().getPluginDescriptor(Platform.PI_RUNTIME).getPlugin();

+	} catch (CoreException e) {

+		return null;

+	}

+}

+private static void handleException(ISafeRunnable code, Throwable e) {

+	if (!(e instanceof OperationCanceledException)) {

+		// try to figure out which plugin caused the problem.  Derive this from the class

+		// of the code arg.  Attribute to the Runtime plugin if we can't figure it out.

+		Plugin plugin = getRuntimePlugin();

+		try {

+			plugin = ((PluginClassLoader)code.getClass().getClassLoader()).getPluginDescriptor().getPlugin();

+		} catch (ClassCastException e1) {

+		} catch (CoreException e1) {

+		}

+		String pluginId =  plugin.getDescriptor().getUniqueIdentifier();

+		String message = Policy.bind("meta.pluginProblems", pluginId);

+		IStatus status = new Status(Status.WARNING, pluginId, Platform.PLUGIN_ERROR, message, e);

+		plugin.getLog().log(status);

+	}

+	code.handleException(e);

+}

+/**

+ * Returns true if the platform is currently running in Development Mode.  If it is, there are 

+ * special procedures that should be taken when defining plug-in class paths.

+ */

+public static boolean inDevelopmentMode() {

+	return inDevelopmentMode || inVAJ() || inVAME();

+}

+/**

+ * Returns true if the platform is currently running in  VA/Java.  If it is, there are 

+ * typically some special procedures

+ * that should be taken when dealing with plug-in activation and class loading.

+ */

+public static boolean inVAJ() {

+	return inVAJ;

+}

+/**

+ * Returns true if the platform is currently running in  VA/ME.  If it is, there are 

+ * typically some special procedures

+ * that should be taken when dealing with plug-in activation and class loading.

+ */

+public static boolean inVAME() {

+	return inVAME;

+}

+/**

+ * Internal method for finding and returning a runnable instance of the 

+ * given class as defined in the specified plug-in.

+ * The returned object is initialized with the supplied arguments.

+ * <p>

+ * This method is used by the platform boot loader; is must

+ * not be called directly by client code.

+ * </p>

+ * @see BootLoader

+ */

+public static IPlatformRunnable loaderGetRunnable(String applicationName) {

+	assertInitialized();

+	IExtension extension = registry.getExtension(Platform.PI_RUNTIME, Platform.PT_APPLICATIONS, applicationName);

+	if (extension == null)

+		return null;

+	IConfigurationElement[] configs = extension.getConfigurationElements();

+	if (configs.length == 0)

+		return null;

+	try {

+		IConfigurationElement config = configs[0];

+		return (IPlatformRunnable) config.createExecutableExtension("run");

+	} catch (CoreException e) {

+		if (DEBUG)

+			getRuntimePlugin().getLog().log(e.getStatus());

+		return null;

+	}

+}

+/**

+ * Internal method for finding and returning a runnable instance of the 

+ * given class as defined in the specified plug-in.

+ * The returned object is initialized with the supplied arguments.

+ * <p>

+ * This method is used by the platform boot loader; is must

+ * not be called directly by client code.

+ * </p>

+ * @see BootLoader

+ */

+public static IPlatformRunnable loaderGetRunnable(String pluginId, String className, Object args) {

+	assertInitialized();

+	PluginDescriptor descriptor = (PluginDescriptor) registry.getPluginDescriptor(pluginId);

+	try {

+		return (IPlatformRunnable) descriptor.createExecutableExtension(className, args, null, null);

+	} catch (CoreException e) {

+		if (DEBUG)

+			getRuntimePlugin().getLog().log(e.getStatus());

+		return null;

+	}

+}

+/**

+ * Internal method for shutting down the platform.  All active plug-ins 

+ * are notified of the impending shutdown. 

+ * The exact order of notification is unspecified;

+ * however, each plug-in is assured that it will be told to shut down

+ * before any of its prerequisites.  Plug-ins are expected to free any

+ * shared resources they manage.  Plug-ins should not store state at

+ * this time; a separate <b>save</b> lifecycle event preceding the

+ * shutdown notice tells plug-ins the right time to be saving their state.

+ * <p>

+ * On exit, the platform will no longer be initialized and any objects derived from

+ * or based on the running platform are invalidated.

+ * </p>

+ * <p>

+ * This method is used by the platform boot loader; is must

+ * not be called directly by client code.

+ * </p>

+ * @see BootLoader

+ */

+public static void loaderShutdown() {

+	assertInitialized();

+	registry.shutdown(null);

+	if (DEBUG_PLUGINS) {

+		// We are debugging so output the registry in XML

+		// format.

+		registry.debugRegistry();

+	} else {

+		// get rid of the debug file if it exists

+		registry.flushDebugRegistry();

+	}

+	

+	if (cacheRegistry) {

+		// Write the registry in cache format

+		try {

+			registry.saveRegistry();

+		} catch (IOException e) {

+			String message = Policy.bind("meta.unableToWriteRegistry");

+			IStatus status = new Status(IStatus.ERROR, Platform.PI_RUNTIME, Platform.PLUGIN_ERROR, message, e);

+			getRuntimePlugin().getLog().log(status);

+			if (DEBUG)

+				System.out.println(status.getMessage());

+		}

+	} else {

+		// get rid of the cache file if it exists

+		registry.flushRegistry();

+	}

+	if (platformLog != null)

+		platformLog.shutdown();

+	initialized = false;

+}

+/**

+ * Internal method for starting up the platform.  The platform is started at the 

+ * given location.  The plug-ins found at the supplied 

+ * collection of plug-in locations are loaded into the newly started platform.

+ * <p>

+ * This method is used by the platform boot loader; is must

+ * not be called directly by client code.

+ * </p>

+ * @param pluginPath the list of places to look for plug-in specifications.  This may

+ *		identify individual plug-in files or directories containing directories which contain

+ *		plug-in files.

+ * @param location the local filesystem location at which the newly started platform

+ *		should be started.  If the location does not contain the saved state of a platform,

+ *		the appropriate structures are created on disk (if required).

+ * @param bootOptions the debug options loaded by the boot loader.  If the argument

+ *		is <code>null</code> then debugging enablement was not requested by the

+ *		person starting the platform.

+ * @see BootLoader

+ */

+public static void loaderStartup(URL[] pluginPath, String locationString, Properties bootOptions, String[] args) throws CoreException {

+	processCommandLine(args);

+	setupMetaArea(locationString);

+	adapterManager = new AdapterManager();

+	loadOptions(bootOptions);

+	createXMLClassLoader();

+	MultiStatus problems = loadRegistry(pluginPath);

+	initialized = true;

+	// can't register url handlers until after the plugin registry is loaded

+	PlatformURLPluginHandlerFactory.startup();

+	activateDefaultPlugins();

+	// can't install the log or log problems until after the platform has been initialized.

+	platformLog = new PlatformLogListener();

+	addLogListener(platformLog);

+	if (consoleLogEnabled) {

+		consoleLog = new PlatformLogListener(System.out);

+		addLogListener(consoleLog);

+	}

+	if (!problems.isOK())

+		getRuntimePlugin().getLog().log(problems);

+	loadKeyring();

+}

+/**

+ * Opens the password database (if any) initally provided to the platform at startup.

+ */

+private static void loadKeyring() {

+	if (keyringFile != null)

+		try {

+			keyring = new AuthorizationDatabase(keyringFile, password);

+		} catch (CoreException e) {

+			log(e.getStatus());

+		}

+	if (keyring == null)

+		keyring = new AuthorizationDatabase();

+}

+static void loadOptions(Properties bootOptions) {

+	// If the boot loader passed <code>null</code> for the boot options, the user

+	// did not specify debug options so no debugging should be enabled.

+	if (bootOptions == null) {

+		debugEnabled = false;

+		return;

+	}

+	debugEnabled = true;

+	options = new Properties(bootOptions);

+	try {

+		InputStream input = new FileInputStream(InternalPlatform.getMetaArea().getOptionsLocation().toFile());

+		try {

+			options.load(input);

+		} finally {

+			input.close();

+		}

+	} catch (FileNotFoundException e) {

+		//	Its not an error to not find the options file

+	} catch (IOException e) {

+		//	Platform.RuntimePlugin.getLog().log();

+	}

+		// trim off all the blanks since properties files don't do that.

+	for (Iterator i = options.keySet().iterator(); i.hasNext();) {

+		Object key = i.next();

+		options.put(key, ((String) options.get(key)).trim());

+	}

+	DEBUG = getBooleanOption(OPTION_DEBUG, false);

+	DEBUG_PLUGINS = getBooleanOption(OPTION_DEBUG_PLUGINS, false);

+	InternalBootLoader.setupOptions();

+}

+/**

+ * Parses, resolves and rememberhs the plugin registry.  The multistatus returned

+ * details any problems/issues encountered during this process.

+ */

+private static MultiStatus loadRegistry(URL[] pluginPath) {

+	MultiStatus problems = new MultiStatus(Platform.PI_RUNTIME, Platform.PARSE_PROBLEM, Policy.bind("parse.registryProblems"), null);

+	InternalFactory factory = new InternalFactory(problems);

+

+	IPath path = getMetaArea().getRegistryPath();

+	IPath tempPath = getMetaArea().getBackupFilePathFor(path);

+	DataInputStream input = null;

+	registry = null;

+	if (cacheRegistry) {

+		try {

+			input = new DataInputStream(new BufferedInputStream(new SafeFileInputStream(path.toOSString(), tempPath.toOSString())));

+			try {

+				long start = System.currentTimeMillis();

+				RegistryCacheReader cacheReader = new RegistryCacheReader(factory);

+				registry = (PluginRegistry)cacheReader.readPluginRegistry(input);

+				if (DEBUG)

+					System.out.println("Read registry cache: " + (System.currentTimeMillis() - start) + "ms");

+			} finally {

+				input.close();

+			}

+		} catch (IOException ioe) {

+			IStatus status = new Status(IStatus.ERROR, Platform.PI_RUNTIME, Platform.PLUGIN_ERROR, Policy.bind("meta.unableToReadCache"), ioe);

+			problems.merge(status);

+		}

+	}

+	if (registry == null) {

+		URL[] augmentedPluginPath = getAugmentedPluginPath(pluginPath);	// augment the plugin path with any additional platform entries	(eg. user scripts)

+		registry = (PluginRegistry) parsePlugins(augmentedPluginPath, factory, DEBUG && DEBUG_PLUGINS);

+		IStatus resolveStatus = registry.resolve(true, true);

+		problems.merge(resolveStatus);

+		registry.markReadOnly();

+	}

+	registry.startup(null);

+	return problems;

+}

+/**

+ * @see Platform#log

+ */

+public static void log(final IStatus status) {

+	assertInitialized();

+	// create array to avoid concurrent access

+	ILogListener[] listeners;

+	synchronized (logListeners) {

+		listeners = (ILogListener[]) logListeners.toArray(new ILogListener[logListeners.size()]);

+	}

+	for (int i = 0; i < listeners.length; i++) {

+		try {

+			listeners[i].logging(status, Platform.PI_RUNTIME);

+		} catch (Exception e) {

+		} // no chance of exceptions for log listeners

+	}

+}

+/**

+ * @see Platform#parsePlugins

+ */

+public static PluginRegistryModel parsePlugins(URL[] pluginPath, Factory factory) {

+	return parsePlugins(pluginPath, factory, false);

+}

+/**

+ * @see Platform#parsePlugins

+ */

+public synchronized static PluginRegistryModel parsePlugins(URL[] pluginPath, Factory factory, boolean debug) {

+	// If the platform is not running then simply parse the registry.  We don't need to play

+	// any funny class loader games as we assume the XML classes are on the class path

+	// This happens when we are running this code as part of a utility (as opposed to starting

+	// or inside the platform).

+	if (!(InternalBootLoader.isRunning() || InternalBootLoader.isStarting()))

+		return RegistryLoader.parseRegistry(pluginPath, factory, debug);

+

+	// If we are running the platform, we want to conserve class loaders.  

+	// Temporarily install the xml class loader as a prerequisite of the platform class loader

+	// This allows us to find the xml classes.  Be sure to reset the prerequisites after loading.

+	PlatformClassLoader.getDefault().setImports(new DelegatingURLClassLoader[] { xmlClassLoader });

+	try {

+		return RegistryLoader.parseRegistry(pluginPath, factory, debug);

+	} finally {

+		PlatformClassLoader.getDefault().setImports(null);

+	}

+}

+private static String[] processCommandLine(String[] args) {

+	int[] configArgs = new int[100];

+	configArgs[0] = -1; // need to initialize the first element to something that could not be an index.

+	int configArgIndex = 0;

+	for (int i = 0; i < args.length; i++) {

+		boolean found = false;

+		// check for args without parameters (i.e., a flag arg)

+

+		// look for the log flag

+		if (args[i].equalsIgnoreCase(LOG)) {

+			consoleLogEnabled = true;

+			found = true;

+		}

+

+		// look for the development mode flag

+		if (args[i].equalsIgnoreCase(DEV)) {

+			inDevelopmentMode = true;

+			found = true;

+		}

+

+		// look for the registry cache flag

+		if (args[i].equalsIgnoreCase(REGISTRYCACHE)) {

+			cacheRegistry = true;

+			found = true;

+		}

+

+		// done checking for args.  Remember where an arg was found 

+		if (found) {

+			configArgs[configArgIndex++] = i;

+			continue;

+		}

+		// check for args with parameters

+		if (i == args.length - 1 || args[i + 1].startsWith("-")) 

+			continue;

+		String arg = args[++i];

+

+		// look for the keyring file

+		if (args[i - 1].equalsIgnoreCase(KEYRING)) {

+			keyringFile = arg;

+			found = true;

+		}

+

+		// look for the user password.  

+		if (args[i - 1].equalsIgnoreCase(PASSWORD)) {

+			password = arg;

+			found = true;

+		}

+

+		// done checking for args.  Remember where an arg was found 

+		if (found) {

+			configArgs[configArgIndex++] = i - 1;

+			configArgs[configArgIndex++] = i;

+		}

+	}

+	// remove all the arguments consumed by this argument parsing

+	if (configArgIndex == 0)

+		return args;

+	String[] passThruArgs = new String[args.length - configArgIndex];

+	configArgIndex = 0;

+	int j = 0;

+	for (int i = 0; i < args.length; i++) {

+		if (i == configArgs[configArgIndex])

+			configArgIndex++;

+		else

+			passThruArgs[j++] = args[i];

+	}

+	return passThruArgs;

+}

+/**

+ * @see Platform#removeLogListener

+ */

+public static void removeLogListener(ILogListener listener) {

+	assertInitialized();

+	synchronized (logListeners) {

+		logListeners.remove(listener);

+	}

+}

+/**

+ * @see Platform

+ */

+public static URL resolve(URL url) throws IOException {

+	URLConnection connection = url.openConnection();

+	if (connection instanceof PlatformURLConnection)

+		return ((PlatformURLConnection) connection).getResolvedURL();

+	else

+		return url;

+}

+public static void run(ISafeRunnable code) {

+	Assert.isNotNull(code);

+	try {

+		code.run();

+	} catch (Exception e) {

+		handleException(code, e);

+	} catch (LinkageError e) {

+		handleException(code, e);

+	}

+}

+public static void setDebugOption(String option, String value) {

+	if (debugEnabled)

+		options.setProperty(option, value);

+}

+/**

+ * Sets the plug-in registry for the platform to the given value.

+ * This method should only be called by the registry loader

+ */

+public static void setPluginRegistry(IPluginRegistry value) {

+	registry = (PluginRegistry) value;

+}

+private static void setupMetaArea(String locationString) throws CoreException {

+	location = new Path(locationString);

+	if (!location.isAbsolute())

+		location = new Path(System.getProperty("user.dir")).append(location);

+	// must create the meta area first as it defines all the other locations.

+	if (location.toFile().exists()) {

+		if (!location.toFile().isDirectory()) {

+			String message = Policy.bind("meta.notDir", location.toString());

+			throw new CoreException(new Status(IStatus.ERROR, Platform.PI_RUNTIME, 13, message, null));

+		}

+	}

+	metaArea = new PlatformMetaArea(location);

+	metaArea.createLocation();

+	if (keyringFile == null)

+		keyringFile = metaArea.getLocation().append(PlatformMetaArea.F_KEYRING).toOSString();

+}

+}
\ No newline at end of file
diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Log.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Log.java
new file mode 100644
index 0000000..bffaa91
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Log.java
@@ -0,0 +1,73 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import java.util.*;

+

+/**

+ * 

+ */

+public class Log implements ILog{

+	Plugin plugin;

+	Set logListeners = new HashSet(5);

+Log(Plugin plugin) {

+	this.plugin = plugin;

+}

+/**

+ * Adds the given log listener to this log.  Subsequently the log listener will

+ * receive notification of all log events passing through this log.

+ *

+ * @see Platform#addLogListener

+ */

+public void addLogListener(ILogListener listener) {

+	synchronized (logListeners) {

+		logListeners.add(listener);

+	}

+}

+/**

+ * Returns the plug-in with which this log is associated.

+ */

+public Plugin getPlugin() {

+	return plugin;

+}

+/**

+ * Logs the given status.  The status is distributed to the log listeners

+ * installed on this log and then to the log listeners installed on the platform.

+ *

+ * @see Plugin#getLogMask

+ */

+public void log(final IStatus status) {

+	// create array to avoid concurrent access

+	ILogListener[] listeners;

+	synchronized (logListeners) {

+		listeners = (ILogListener[]) logListeners.toArray(new ILogListener[logListeners.size()]);

+	}

+	for (int i = 0; i < listeners.length; i++) {

+		final ILogListener listener = listeners[i];

+		ISafeRunnable code = new ISafeRunnable() {

+			public void run() throws Exception {

+				listener.logging(status, plugin.getDescriptor().getUniqueIdentifier());

+			}

+			public void handleException(Throwable e) {

+			}

+		};

+		InternalPlatform.run(code);

+	}

+	InternalPlatform.log(status);

+}

+/**

+ * Removes the given log listener to this log.  Subsequently the log listener will

+ * no longer receive notification of log events passing through this log.

+ *

+ * @see Platform#removeLogListener

+ */

+public void removeLogListener(ILogListener listener) {

+	synchronized (logListeners) {

+		logListeners.remove(listener);

+	}

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Messages.properties b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Messages.properties
new file mode 100644
index 0000000..4e27253
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Messages.properties
@@ -0,0 +1,64 @@
+### Runtime plugin message catalog

+

+ok = OK

+

+### plugins

+plugin.extDefNotFound = Executable extension definition for {0} not found.

+plugin.extDefNoClass = Executable extension definition {0} does not specify a class name.

+plugin.deactivatedLoad = Attempt to load class {0} from deactivated plug-in {1}.

+plugin.loadClassError = Plug-in {0} was unable to load class {1}.

+plugin.instantiateClassError = Plugin {0} was unable to instantiate class {1}.

+plugin.initObjectError = Plugin {0} was unable to execute setInitializationData on an instance of {1}.

+plugin.bundleNotFound = Plugin {0} could not find resource bundle {1}.

+plugin.notPluginClass = Supplied runtime class {0} does not extend class Plugin.

+plugin.startupProblems = Problems encountered starting up plug-in: {0}.

+plugin.pluginDisabled = Attempt to activate a disabled plug-in: {0}.

+plugin.unableToResolve = Unable to resolve plug-in registry.

+plugin.mismatchRuntime = Runtime class declaration mismatch for plug-in: {0}.

+

+### parsing/resolve

+parse.error = Parsing error: {0}.

+parse.errorProcessing = Error while processing {0}.

+parse.errorNameLineColumn = Parsing error in {0} [line {1}, column {2}]: {3}.

+parse.extPointUnknown = Unknown extension point {0} specified in plug-in {1}.

+parse.extPointDisabled = Extension point {0} specified in plug-in {1} is disabled.

+parse.prereqDisabled = Plug-in {0} was disabled due to missing or disabled prerequisite plug-in {1}.

+parse.unsatisfiedPrereq = Unable to satisfy prerequisite constraint from {0} to {1}.

+parse.prereqLoop = Detected prerequisite loop from {0} to {1}.

+parse.registryProblems = Problems encountered loading the plug-in registry.

+parse.fragmentMissingAttr = Fragment {0} ignored due to missing attributes.

+parse.fragmentMissingIdName = Fragment ignored due to missing attributes (including name and id).

+parse.pluginMissingAttr = Plugin {0} disabled due to missing attributes.

+parse.pluginMissingIdName = Plugin disabled due to missing attributes (including name and id).

+parse.unknownElement = Unknown element {1}, found within a {0}, ignored.

+parse.unknownTopElement = Unknown element {0}, found at the top level, ignored.

+parse.initializationTrouble = Parser initialization using setFeature failed.

+parse.internalStack = Element/end element mismatch for element {0}.

+parse.validMatch = {0} is not a valid value for the attribute "match".   Use "exact" or "compatible".

+parse.validExport = {0} is not a valid value for the attribute "export".   Use "true" or "false".

+parse.unknownAttribute = Unknown attribute {1} for element {0} ignored.

+parse.missingFragmentPd = Plugin descriptor {0} not found for fragment {0}.  Fragment ignored.

+

+### metadata

+meta.unableToWriteRegistry = Unable to write plug-in registry to cache.

+meta.appNotInit = The application has not been initialized.

+meta.pluginProblems = Problems occurred when invoking code from plug-in: {0}.

+meta.notDir = Specified platform location {0} is not a directory.

+meta.readPlatformMeta = Could not read platform metadata: {0}.

+meta.writePlatformMeta = Could not write platform metadata: {0}.

+meta.couldNotCreate = Error trying to create the platform metadata area: {0}.

+meta.readonly = The platform metadata area could not be written: {0}.

+meta.unableToCreateCache = Unable to create output stream for registry cache.

+meta.unableToReadCache = Unable to create input stream for registry cache.

+meta.unableToCreateRegDebug = Unable to create output stream for registry debug information.

+meta.unableToWriteDebugRegistry = Unable to write plug-in registry to debug file.

+meta.unableToReadAuthorization = Unable to read authorization database: {0}.

+meta.unableToWriteAuthorization = Unable to write to authorization database: {0}.

+meta.registryCacheWriteProblems = Trouble writing to the registry cache file.

+meta.registryCacheReadProblems = Trouble reading from the registry cache file.

+meta.regCacheIOException = IOException encountered while writing {0}.

+

+### URL

+url.badVariant=Unsupported "platform:" protocol variation {0}.

+url.resolveFragment=Unable to resolve fragment {0}.

+url.resolvePlugin=Unable to resolve plug-in {0}.

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformLogListener.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformLogListener.java
new file mode 100644
index 0000000..9f8acf7
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformLogListener.java
@@ -0,0 +1,103 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import java.io.*;

+import java.util.Date;

+

+class PlatformLogListener implements ILogListener {

+	private PrintWriter log = null;

+	private boolean usingLogFile = false;

+PlatformLogListener() {

+	usingLogFile = true;

+	// remove old log file

+	InternalPlatform.getMetaArea().getLogLocation().toFile().delete();

+}

+/**

+ * It should only be used to pass System.out .

+ */

+PlatformLogListener(OutputStream out) {

+	log = new PrintWriter(out);

+}

+private void closeLogFile() {

+	try {

+		log.flush();

+		log.close();

+	} finally {

+		log = null;

+	}

+}

+private void indent(int count) {

+	for (int i = 0; i < count; i++)

+		log.print("\t");

+}

+private void logging(IStatus status, int nesting) {

+	indent(nesting);

+	log.print(status.getSeverity());

+	log.print(" ");

+	log.print(status.getPlugin());

+	log.print(" ");

+	log.print(status.getCode());

+	log.print(" ");

+	log.println(status.getMessage());

+	Throwable throwable = status.getException();

+	if (throwable != null) {

+		throwable.printStackTrace(log);

+		if (throwable instanceof CoreException) {

+			CoreException ex = (CoreException) throwable;

+			IStatus s = ex.getStatus();

+			if (s != null)

+				logging(s, nesting + 1);

+		}

+	}

+	if (status.isMultiStatus()) {

+		indent(nesting + 1);

+		log.print(nesting + 1);

+		log.println("=============<children>=============");

+		IStatus[] children = status.getChildren();

+		for (int i = 0; i < children.length; i++)

+			logging(children[i], nesting + 1);

+		indent(nesting + 1);

+		log.print(nesting + 1);

+		log.println("=============</children>=============");

+	}

+	log.flush();

+}

+public synchronized void logging(IStatus status, String plugin) {

+	// thread safety: (Concurrency003)

+	if (usingLogFile)

+		openLogFile();

+	if (log == null)

+		return;

+	try {

+		log.println("Log: " + new Date());

+		logging(status, 0);

+	} finally {

+		if (usingLogFile)

+			closeLogFile();

+	}

+}

+private void openLogFile() {

+	try {

+		log = new PrintWriter(new FileOutputStream(InternalPlatform.getMetaArea().getLogLocation().toOSString(), true));

+	} catch (IOException e) {

+		// there was a problem opening the log file so log to the console

+		log = new PrintWriter(System.out);

+	}

+}

+/**

+ * @see ILogListener

+ */

+public synchronized void shutdown() {

+	if (log == null)

+		return;

+	PrintWriter old = log;

+	log = null;

+	old.flush();

+	old.close();

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformMetaArea.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformMetaArea.java
new file mode 100644
index 0000000..2ba0f02
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformMetaArea.java
@@ -0,0 +1,160 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import java.util.*;

+import java.io.*;

+

+public class PlatformMetaArea {

+	IPath location;

+	

+	/* package */ static final String F_DESCRIPTION = ".platform";

+	/* package */ static final String F_META_AREA = ".metadata";

+	/* package */ static final String F_PLUGIN_PATH = ".plugin-path";

+	/* package */ static final String F_PLUGIN_DATA = ".plugins";

+	/* package */ static final String F_REGISTRY = ".registry";

+	/* package */ static final String F_SNAP = ".snap";

+	/* package */ static final String F_LOG = ".log";

+	/* package */ static final String F_BACKUP = ".bak";

+	/* package */ static final String F_OPTIONS = ".options";	

+	/* package */ static final String F_KEYRING = ".keyring";	

+/**

+ * 

+ */

+public PlatformMetaArea(IPath location) {

+	super();

+	this.location = location;

+}

+private Properties buildPathProperties(Hashtable paths) {

+	Properties result = new Properties();

+	for (Enumeration keys = paths.keys(); keys.hasMoreElements();) {

+		String key = (String) keys.nextElement();

+		StringBuffer entry = new StringBuffer(100);

+		IPath[] list = (IPath[]) paths.get(key);

+		for (int i = 0; i < list.length; i++) {

+			entry.append(list[i].toOSString());

+			entry.append(";");

+		}

+		result.put(key, entry.toString());

+	}

+	return result;

+}

+/**

+ * 

+ */

+public void createLocation() throws CoreException {

+	File file = getLocation().toFile();

+	try {

+		file.mkdirs();

+	} catch (Exception e) {

+		String message = Policy.bind("meta.couldNotCreate", file.getAbsolutePath());

+		throw new CoreException(new Status(IStatus.ERROR, Platform.PI_RUNTIME, Platform.FAILED_WRITE_METADATA, message, e));

+	}

+	if (!file.canWrite()) {

+		String message = Policy.bind("meta.readonly", file.getAbsolutePath());

+		throw new CoreException(new Status(IStatus.ERROR, Platform.PI_RUNTIME, Platform.FAILED_WRITE_METADATA, message, null));

+	}

+}

+public IPath getBackupFilePathFor(IPath file) {

+	return file.removeLastSegments(1).append(file.lastSegment() + F_BACKUP);

+}

+/**

+ * Returns the location of the platform's meta area.

+ */

+public IPath getLocation() {

+	return location.append(F_META_AREA);

+}

+/**

+ * 

+ */

+public IPath getLogLocation() {

+	return getLocation().append(F_LOG);

+}

+/**

+ * 

+ */

+public IPath getOptionsLocation() {

+	return getLocation().append(F_OPTIONS);

+}

+/**

+ * Returns the read/write location in which the given plugin can manage

+ * private state.  

+ */

+public IPath getPluginStateLocation(Plugin plugin) {

+	IPath result = getLocation().append(F_PLUGIN_DATA);

+	String id = plugin.getDescriptor().getUniqueIdentifier();

+	return result.append(id);

+}

+/**

+ * 

+ */

+public IPath getRegistryPath() {

+	return getLocation().append(F_REGISTRY);

+}

+/**

+ * 

+ */

+public IPath getSnapshotPath() {

+	return getLocation().append(F_SNAP);

+}

+private Hashtable parsePathProperties(Properties props) {

+	Hashtable result = new Hashtable(5);

+	for (Enumeration keys = props.propertyNames(); keys.hasMoreElements();) {

+		String key = (String) keys.nextElement();

+		String entry = props.getProperty(key);

+		Vector list = new Vector(4);

+		for (StringTokenizer tokens = new StringTokenizer(entry, ";"); tokens.hasMoreTokens();)

+			list.addElement(new Path(tokens.nextToken()));

+		IPath[] paths = new IPath[list.size()];

+		list.copyInto(paths);

+		result.put(key, paths);

+	}

+	return result;

+}

+public Hashtable readPluginPath(IPath location) throws CoreException {

+	Properties props = new Properties();

+	location = location.append(F_PLUGIN_PATH);

+	IPath tempLocation = getBackupFilePathFor(location);

+	SafeFileInputStream stream = null;

+	try {

+		try {

+			stream = new SafeFileInputStream(location.toOSString(), tempLocation.toOSString());

+			props.load(stream);

+		} finally {

+			if (stream != null)

+				stream.close();

+		}

+	} catch (IOException e) {

+		String message = Policy.bind("meta.readPlatformMeta", location.toString());

+		IStatus status = new Status(IStatus.ERROR, Platform.PI_RUNTIME, Platform.FAILED_READ_METADATA, message, e);

+		throw new CoreException (status);

+}

+	return parsePathProperties(props);

+}

+/**

+ * @see IWorkbenchProtected#setPluginPath

+ */

+public void writePluginPath(Hashtable paths, IPath location) throws CoreException {

+	Properties props = buildPathProperties(paths);

+	location = location.append(F_PLUGIN_PATH);

+	IPath tempLocation = getBackupFilePathFor(location);

+	SafeFileOutputStream stream = null;

+	try {

+		try {

+			stream = new SafeFileOutputStream(location.toOSString(), tempLocation.toOSString());

+			props.store(stream, null);

+		} finally {

+			if (stream != null)

+				stream.close();

+		}

+	} catch (IOException e) {

+		String message = Policy.bind("meta.writePlatformMeta", location.toString());

+		IStatus status = new Status(IStatus.ERROR, Platform.PI_RUNTIME, Platform.FAILED_WRITE_METADATA, message, e);

+		throw new CoreException (status);

+	}

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformURLFragmentConnection.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformURLFragmentConnection.java
new file mode 100644
index 0000000..811561a
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformURLFragmentConnection.java
@@ -0,0 +1,62 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * Platform URL support

+ * platform:/fragment/<fragmentId>/		maps to fragmentDescriptor.getInstallURLInternal()

+ */

+

+import java.io.IOException;

+import java.net.URL;

+

+import org.eclipse.core.internal.boot.PlatformURLConnection;

+import org.eclipse.core.internal.boot.PlatformURLHandler;

+import org.eclipse.core.runtime.Platform;

+import org.eclipse.core.runtime.model.PluginFragmentModel;

+import org.eclipse.core.runtime.model.PluginRegistryModel;

+ 

+public class PlatformURLFragmentConnection extends PlatformURLConnection {

+

+	// fragment/ protocol

+	private PluginFragmentModel fd = null;

+	private static boolean isRegistered = false;

+	public static final String FRAGMENT = "fragment";

+public PlatformURLFragmentConnection(URL url) {

+	super(url);

+}

+protected boolean allowCaching() {

+	return true;

+}

+protected URL resolve() throws IOException {

+	String spec = url.getFile().trim();

+	if (spec.startsWith("/")) 

+		spec = spec.substring(1);

+	if (!spec.startsWith(FRAGMENT)) 

+		throw new IOException(Policy.bind("url.badVariant", url.toString()));

+	int ix = spec.indexOf("/",FRAGMENT.length()+1);

+	String ref = ix==-1 ? spec.substring(FRAGMENT.length()+1) : spec.substring(FRAGMENT.length()+1,ix);

+	String id = getId(ref);

+	String vid = getVersion(ref);

+	PluginRegistryModel registry = (PluginRegistryModel)Platform.getPluginRegistry();

+	fd = vid==null ? registry.getFragment(id) : registry.getFragment(id,vid);

+	if (fd == null)

+		throw new IOException(Policy.bind("url.resolveFragment", url.toString()));

+	URL result = new URL (fd.getLocation());

+	if (ix == -1 || (ix + 1) >= spec.length()) 

+		return result;

+	else

+		return new URL(result, spec.substring(ix+1));

+}

+

+public static void startup() {

+	

+	// register connection type for platform:/fragment handling

+	if (isRegistered) return;

+	PlatformURLHandler.register(FRAGMENT, PlatformURLFragmentConnection.class);

+	isRegistered = true;

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformURLPluginConnection.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformURLPluginConnection.java
new file mode 100644
index 0000000..defd664
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformURLPluginConnection.java
Binary files differ
diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformURLPluginHandlerFactory.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformURLPluginHandlerFactory.java
new file mode 100644
index 0000000..548828f
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PlatformURLPluginHandlerFactory.java
@@ -0,0 +1,49 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import java.net.*;

+import java.util.*;

+import org.eclipse.core.runtime.*;

+import org.eclipse.core.internal.boot.PlatformURLHandler;

+import org.eclipse.core.internal.boot.PlatformURLHandlerFactory;

+ 

+public class PlatformURLPluginHandlerFactory implements URLStreamHandlerFactory {

+

+	IConfigurationElement ce = null;

+	

+	private static final String URL_HANDLERS_POINT = "org.eclipse.core.runtime.urlHandlers";

+	private static final String PROTOCOL = "protocol";

+	private static final String HANDLER = "class";

+public PlatformURLPluginHandlerFactory(IConfigurationElement ce) {

+	super();

+	this.ce = ce;	

+}

+public URLStreamHandler createURLStreamHandler(String protocol) {

+

+	URLStreamHandler handler = null;

+	try {

+		handler = (URLStreamHandler)ce.createExecutableExtension(HANDLER);

+	} catch (CoreException e) {}

+	return handler;

+}

+public static void startup() {

+

+	// register URL handler extensions

+	IPluginRegistry r = Platform.getPluginRegistry();

+	IConfigurationElement[] ce = r.getConfigurationElementsFor(URL_HANDLERS_POINT);

+	String protocol;

+	for (int i=0; i<ce.length; i++) {

+		// register factory elements (actual handlers lazily created on request)

+		protocol = ce[i].getAttribute(PROTOCOL);

+		if (protocol!=null) PlatformURLHandlerFactory.register(protocol,new PlatformURLPluginHandlerFactory(ce[i]));

+	}

+

+	// initialize plugin and fragment connection support

+	PlatformURLPluginConnection.startup();

+	PlatformURLFragmentConnection.startup();

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PluginStats.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PluginStats.java
new file mode 100644
index 0000000..6159b3c
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/PluginStats.java
@@ -0,0 +1,60 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.CoreException;

+import java.util.*;

+/**

+ * A placeholder for statistics about the runtime behaviour

+ * of a particular plugin.  PluginStats objects are used internally

+ * by the CoreStats mechanism.

+ */

+class PluginStats {

+	protected String pluginID;

+	protected long notificationRunningTime = 0;

+	protected long buildRunningTime = 0;

+	protected int notificationCount = 0;

+	protected int buildCount = 0;

+	protected Vector exceptions = new Vector();

+/**

+ * PluginStats constructor comment.

+ */

+PluginStats(String pluginID) {

+	this.pluginID = pluginID;

+}

+void addException(Exception e) {

+	exceptions.addElement(e);

+}

+Enumeration getCoreExceptions() {

+	Vector runtime = new Vector();

+	for (Enumeration e = exceptions.elements(); e.hasMoreElements();) {

+		Exception next = (Exception)e.nextElement();

+		if (next instanceof CoreException) {

+			runtime.addElement(next);

+		}

+	}

+	return runtime.elements();

+}

+int getExceptionCount() {

+	return exceptions.size();

+}

+String getName() {

+	return pluginID;

+}

+Enumeration getRuntimeExceptions() {

+	Vector runtime = new Vector();

+	for (Enumeration e = exceptions.elements(); e.hasMoreElements();) {

+		Exception next = (Exception) e.nextElement();

+		if (next instanceof RuntimeException) {

+			runtime.addElement(next);

+		}

+	}

+	return runtime.elements();

+}

+long getTotalRunningTime() {

+	return notificationRunningTime + buildRunningTime;

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Policy.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Policy.java
new file mode 100644
index 0000000..90f32b1
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/Policy.java
@@ -0,0 +1,109 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import java.util.*;

+

+public class Policy {

+	private static ResourceBundle bundle;

+	private static String bundleName = "org.eclipse.core.internal.runtime.messages";

+

+	static {

+		relocalize();

+	}

+/**

+ * Lookup the message with the given ID in this catalog 

+ */

+public static String bind(String id) {

+	return bind(id, (String[])null);

+}

+/**

+ * Lookup the message with the given ID in this catalog and bind its

+ * substitution locations with the given string.

+ */

+public static String bind(String id, String binding) {

+	return bind(id, new String[] {binding});

+}

+/**

+ * Lookup the message with the given ID in this catalog and bind its

+ * substitution locations with the given strings.

+ */

+public static String bind(String id, String binding1, String binding2) {

+	return bind(id, new String[] {binding1, binding2});

+}

+

+/**

+ * Lookup the message with the given ID in this catalog and bind its

+ * substitution locations with the given string values.

+ */

+public static String bind(String id, String[] bindings) {

+	if (id == null)

+		return "No message available";

+	String message = null;

+	try {

+		message = bundle.getString(id);

+	} catch (MissingResourceException e) {

+		// If we got an exception looking for the message, fail gracefully by just returning

+		// the id we were looking for.  In most cases this is semi-informative so is not too bad.

+		return "Missing message: " + id + " in: " + bundleName;

+	}

+	if (bindings == null)

+		return message;

+	int length = message.length();

+	int start = -1;

+	int end = length;

+	StringBuffer output = new StringBuffer(80);

+	while (true) {

+		if ((end = message.indexOf('{', start)) > -1) {

+			output.append(message.substring(start + 1, end));

+			if ((start = message.indexOf('}', end)) > -1) {

+				int index = -1;

+				try {

+					index = Integer.parseInt(message.substring(end + 1, start));

+					output.append(bindings[index]);

+				} catch (NumberFormatException nfe) {

+					output.append(message.substring(end + 1, start + 1));

+				} catch (ArrayIndexOutOfBoundsException e) {

+					output.append("{missing " + Integer.toString(index) + "}");

+				}

+			} else {

+				output.append(message.substring(end, length));

+				break;

+			}

+		} else {

+			output.append(message.substring(start + 1, length));

+			break;

+		}

+	}

+	return output.toString();

+}

+public static IProgressMonitor monitorFor(IProgressMonitor monitor) {

+	if (monitor == null)

+		return new NullProgressMonitor();

+	return monitor;

+}

+/**

+ * Creates a NLS catalog for the given locale.

+ */

+public static void relocalize() {

+	bundle = ResourceBundle.getBundle(bundleName, Locale.getDefault());

+}

+public static IProgressMonitor subMonitorFor(IProgressMonitor monitor, int ticks) {

+	if (monitor == null)

+		return new NullProgressMonitor();

+	if (monitor instanceof NullProgressMonitor)

+		return monitor;

+	return new SubProgressMonitor(monitor, ticks);

+}

+public static IProgressMonitor subMonitorFor(IProgressMonitor monitor, int ticks, int style) {

+	if (monitor == null)

+		return new NullProgressMonitor();

+	if (monitor instanceof NullProgressMonitor)

+		return monitor;

+	return new SubProgressMonitor(monitor, ticks, style);

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/RuntimeStats.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/RuntimeStats.java
new file mode 100644
index 0000000..ee2fdda
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/RuntimeStats.java
@@ -0,0 +1,92 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import java.io.*;

+import java.util.*;

+/**

+ * This class is used to gather stats on various aspects of

+ * core and plugin behaviour.  The Policy class determines whether

+ * stats are gathered or not, so that instrumentation can be turned

+ * off during production builds.

+ */

+public class RuntimeStats {

+	/**

+	 * If this flag is true, CoreStats prints debug info

+	 * to the console.  If false, it fails silently.

+	 */

+	public static boolean DEBUG = false;

+	/** Table mapping plugin identifiers (Strings) to PluginStats objects.

+	 */

+	private static Hashtable pluginTable = new Hashtable(10);

+

+	/** The start time of the current build or notification

+	 */

+	private static long currentStart;

+

+	/** Plugin statistics

+	 */

+	private static int snapshotCount = 0;

+	private static long snapshotTime = 0;

+	

+/**

+ * CoreStats cannot be instantiated.

+ */

+private RuntimeStats() {

+	super();

+}

+public static void dumpStats() {

+	dumpStats(System.out);

+}

+public static void dumpStats(PrintStream out) {

+	dumpStats(new PrintWriter(out));

+

+}

+public static void dumpStats(PrintWriter out) {

+	/* gather totals */

+	int totalExceptions = 0;

+

+	for (Enumeration e = pluginTable.elements(); e.hasMoreElements();) {

+		PluginStats stats = (PluginStats) e.nextElement();

+		totalExceptions += stats.getExceptionCount();

+	}

+	//dump stats

+	out.println(Integer.toString(snapshotCount) + " snapshots took: " + snapshotTime + "ms");

+	for (Enumeration e = pluginTable.elements(); e.hasMoreElements();) {

+		PluginStats stats = (PluginStats) e.nextElement();

+		out.println("Stats for: " + stats.getName());

+

+		int exceptions = stats.getExceptionCount();

+		if (exceptions > 0) {

+			out.println("  Exceptions: " + exceptions + " (" + (int) ((float) exceptions * 100.0 / (float) totalExceptions) + "% of total)");

+		}

+		out.println("");

+	}

+}

+public static void endSnapshot() {

+	snapshotTime += System.currentTimeMillis() - currentStart;

+	snapshotCount++;

+	currentStart = -1;

+}

+public static int getSnapcount() {

+	return snapshotCount;

+}

+/**

+ * Returns the plug-in stats object for the given plug-in id.

+ * If one does not currently exist, one is created, remembered and returned.

+ */

+private static PluginStats getStats(String pluginID) {

+	PluginStats stats = (PluginStats) pluginTable.get(pluginID);

+	if (stats == null) {

+		stats = new PluginStats(pluginID);

+		pluginTable.put(pluginID, stats);

+	}

+	return stats;

+}

+public static void startSnapshot() {

+	currentStart = System.currentTimeMillis();

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/SafeFileInputStream.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/SafeFileInputStream.java
new file mode 100644
index 0000000..e4e5ccc
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/SafeFileInputStream.java
@@ -0,0 +1,39 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import java.io.*;

+/**

+ * Given a target and a temporary locations, it tries to read the contents

+ * from the target. If a file does not exist at the target location, it tries

+ * to read the contents from the temporary location.

+ *

+ * @see SafeFileOutputStream

+ */

+public class SafeFileInputStream extends FilterInputStream {

+	protected static final String EXTENSION = ".bak";

+public SafeFileInputStream(File file) throws IOException {

+	this(file.getAbsolutePath(), null);

+}

+public SafeFileInputStream(String targetName) throws IOException {

+	this(targetName, null);

+}

+/**

+ * If targetPath is null, the file will be created in the default-temporary directory.

+ */

+public SafeFileInputStream(String targetPath, String tempPath) throws IOException {

+	super(getInputStream(targetPath, tempPath));

+}

+private static InputStream getInputStream(String targetPath, String tempPath) throws IOException {

+	File target = new File(targetPath);

+	if (!target.exists()) {

+		if (tempPath == null)

+			tempPath = target.getAbsolutePath() + EXTENSION;

+		target = new File(tempPath);

+	}

+	return new BufferedInputStream(new FileInputStream(target));

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/SafeFileOutputStream.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/SafeFileOutputStream.java
new file mode 100644
index 0000000..2c949bc
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/SafeFileOutputStream.java
Binary files differ
diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/URLTool.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/URLTool.java
new file mode 100644
index 0000000..79951f7
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/URLTool.java
@@ -0,0 +1,482 @@
+package org.eclipse.core.internal.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import java.net.MalformedURLException;

+import java.net.URL;

+import java.util.Vector;

+

+/**

+ * A utility for manipulating <code>URL</code>s.

+ */

+public class URLTool {

+/**

+ * Returns the given URL with a trailing slash appended to it. If the URL

+ * already has a trailing slash the URL is returned unchanged.

+ * <table>

+ * <caption>Example</caption>

+ * <tr>

+ *   <th>Given URL</th>

+ *   <th>Returned URL</th>

+ * <tr>

+ *   <td>"http://hostname/folder"</td>

+ *   <td>"http://hostname/folder/"</td>

+ * <tr>

+ *   <td>"http://hostname/folder/</td>

+ *   <td>"http://hostname/folder/"</td>

+ * </table>

+ *

+ * @param url a URL

+ * @return    the given URL with a trailing slash

+ * @throws    MalformedURLException if the given URL is malformed

+ */

+public static URL appendTrailingSlash(String url) throws MalformedURLException {

+	return appendTrailingSlash(new URL(url));

+}

+/**

+ * Returns the given <code>URL</code> with a trailing slash appended to

+ * it. If the <code>URL</code> already has a trailing slash the

+ * <code>URL</code> is returned unchanged.

+ * <table>

+ * <caption>Example</caption>

+ * <tr>

+ *   <th>Given URL</th>

+ *   <th>Returned URL</th>

+ * <tr>

+ *   <td>"http://hostname/folder"</td>

+ *   <td>"http://hostname/folder/"</td>

+ * <tr>

+ *   <td>"http://hostname/folder/</td>

+ *   <td>"http://hostname/folder/"</td>

+ * </table>

+ *

+ * @param url a URL

+ * @return    the given URL with a trailing slash

+ */

+public static URL appendTrailingSlash(URL url){

+	String file = url.getFile();

+	if (file.endsWith("/"))

+		return url;

+	try {

+		return new URL(url.getProtocol(), url.getHost(), url.getPort(), file + "/");

+	} catch(MalformedURLException e){

+		Assert.isTrue(false, "internal error");

+	}

+	return null;

+}

+/**

+ * Returns the child URL formed by joining the given member with the

+ * given parent URL.

+ *

+ * @return a child URL of the given parent

+ * @throws MalformedURLException if the given parent is malformed

+ */

+public static URL getChild(String parent, String member) throws MalformedURLException {

+	return getChild(new URL(parent), member);

+}

+/**

+ * Returns the child URL formed by joining the given member with the

+ * given parent URL.

+ *

+ * @return a child URL of the given parent

+ */

+public static URL getChild(URL parent, String member){

+	String file = parent.getFile();

+	if (!file.endsWith("/"))

+		file = file + "/";

+	try {

+		return new URL(parent.getProtocol(), parent.getHost(), parent.getPort(), file + member);

+	} catch(MalformedURLException e){

+		Assert.isTrue(false, "internal error");

+	}

+	return null;

+}

+/**

+ * Returns all elements in the given URLs path.

+ * <table>

+ * <caption>Example</caption>

+ * <tr>

+ *   <th>Given URL</th>

+ *   <th>Element</th>

+ * <tr>

+ *   <td>"http://hostname/"</td>

+ *   <td>[]</td>

+ * <tr>

+ *   <td>"http://hostname/folder/</td>

+ *   <td>[folder]</td>

+ * <tr>

+ *   <td>"http://hostname/folder/file</td>

+ *   <td>[folder, file]</td>

+ * </table>

+ * @param url a URL

+ * @return    all elements in the given URLs path

+ * @throws    MalformedURLException if the given URL is malformed

+ */

+public static Vector getElements(String url) throws MalformedURLException {

+	return getElements(new URL(url));

+}

+/**

+ * Returns all elements in the given URLs path.

+ * <table>

+ * <caption>Example</caption>

+ * <tr>

+ *   <th>Given URL</th>

+ *   <th>Element</th>

+ * <tr>

+ *   <td>"http://hostname/"</td>

+ *   <td>[]</td>

+ * <tr>

+ *   <td>"http://hostname/folder/</td>

+ *   <td>[folder]</td>

+ * <tr>

+ *   <td>"http://hostname/folder/file</td>

+ *   <td>[folder, file]</td>

+ * </table>

+ * @param url a URL

+ * @return    all elements in the given URLs path

+ */

+public static Vector getElements(URL url){

+	Vector result = new Vector(5);

+	String lastElement = null;

+	while((lastElement = getLastElement(url)) != null){

+		result.insertElementAt(lastElement, 0);

+		url = getParent(url);

+	}

+	return result;

+}

+/**

+ * Returns the last element in the given URLs path, or <code>null</code>

+ * if the URL is the root.

+ * <table>

+ * <caption>Example</caption>

+ * <tr>

+ *   <th>Given URL</th>

+ *   <th>Last Element</th>

+ * <tr>

+ *   <td>"http://hostname/"</td>

+ *   <td>null</td>

+ * <tr>

+ *   <td>"http://hostname/folder/</td>

+ *   <td>folder</td>

+ * <tr>

+ *   <td>"http://hostname/folder/file</td>

+ *   <td>file</td>

+ * </table>

+ * @param url a URL

+ * @return    the last element in the given URLs path, or

+ *            <code>null</code> if the URL is the root

+ * @throws    MalformedURLException if the given URL is malformed

+ */

+public static String getLastElement(String url) throws MalformedURLException {

+	return getLastElement(new URL(url));

+}

+/**

+ * Returns the last element in the given URLs path, or <code>null</code>

+ * if the URL is the root.

+ * <table>

+ * <caption>Example</caption>

+ * <tr>

+ *   <th>Given URL</th>

+ *   <th>Last Element</th>

+ * <tr>

+ *   <td>"http://hostname/"</td>

+ *   <td>null</td>

+ * <tr>

+ *   <td>"http://hostname/folder/</td>

+ *   <td>folder</td>

+ * <tr>

+ *   <td>"http://hostname/folder/file</td>

+ *   <td>file</td>

+ * </table>

+ * @param url a URL

+ * @return    the last element in the given URLs path, or

+ *            <code>null</code> if the URL is the root

+ */

+public static String getLastElement(URL url){

+	String file = url.getFile();

+	int len = file.length();

+	if (len == 0 || len == 1 && file.charAt(0) == '/')

+		return null;

+

+	int lastSlashIndex = -1;

+	for(int i = len - 2; lastSlashIndex == -1 && i >= 0; --i) {

+		if (file.charAt(i) == '/')

+			lastSlashIndex = i;

+	}

+	boolean isDirectory = file.charAt(len - 1) == '/';

+	if (lastSlashIndex == -1) {

+		if (isDirectory){

+			return file.substring(0, len - 1);

+		} else {

+			return file;

+		}

+	} else {

+		if (isDirectory) {

+			return file.substring(lastSlashIndex + 1, len - 1);

+		} else {

+			return file.substring(lastSlashIndex + 1, len);

+		}

+	}

+}

+/**

+ * Returns the parent URL of the given URL, or <code>null</code> if the

+ * given URL is the root.

+ * <table>

+ * <caption>Example</caption>

+ * <tr>

+ *   <th>Given URL</th>

+ *   <th>Parent URL</th>

+ * <tr>

+ *   <td>"http://hostname/"</td>

+ *   <td>null</td>

+ * <tr>

+ *   <td>"http://hostname/folder/file</td>

+ *   <td>"http://hostname/folder/</td>

+ * </table>

+ *

+ * @param url a URL

+ * @return    the parent of the given URL

+ * @throws    MalformedURLException if the given URL is malformed

+ */

+public static URL getParent(String url) throws MalformedURLException {

+	return getParent(new URL(url));

+}

+/**

+ * Returns the parent URL of the given URL, or <code>null</code> if the

+ * given URL is the root.

+ * <table>

+ * <caption>Example</caption>

+ * <tr>

+ *   <th>Given URL</th>

+ *   <th>Parent URL</th>

+ * <tr>

+ *   <td>"http://hostname/"</td>

+ *   <td>null</td>

+ * <tr>

+ *   <td>"http://hostname/folder/file</td>

+ *   <td>"http://hostname/folder/</td>

+ * </table>

+ *

+ * @param url a URL

+ * @return    the parent of the given URL

+ */

+public static URL getParent(URL url) {

+	String file = url.getFile();

+	int len = file.length();

+	if (len == 0 || len == 1 && file.charAt(0) == '/')

+		return null;

+	int lastSlashIndex = -1;

+	for (int i = len - 2; lastSlashIndex == -1 && i >= 0; --i){

+		if (file.charAt(i) == '/')

+			lastSlashIndex = i;

+	}

+	if (lastSlashIndex == -1)

+		file = "";

+	else

+		file = file.substring(0, lastSlashIndex + 1);

+

+	try {

+		url = new URL(url.getProtocol(), url.getHost(), url.getPort(), file);

+	} catch(MalformedURLException e){

+		Assert.isTrue(false, e.getMessage());

+	}

+	return url;

+}

+/**

+ * Returns the root URL of the given URL.

+ * <table>

+ * <caption>Example</caption>

+ * <tr>

+ *   <th>Given URL</th>

+ *   <th>Root URL</th>

+ * <tr>

+ *   <td>"http://hostname/"</td>

+ *   <td>"http://hostname/"</td>

+ * <tr>

+ *   <td>"http://hostname/folder/file</td>

+ *   <td>"http://hostname/"</td>

+ * </table>

+ *

+ * @param urlString a URL

+ * @return          the root url of the given URL

+ * @throws          MalformedURLException if the given URL is malformed

+ */

+public static URL getRoot(String urlString) throws MalformedURLException {

+	return getRoot(new URL(urlString));

+}

+/**

+ * Returns the root URL of the given URL.

+ * <table>

+ * <caption>Example</caption>

+ * <tr>

+ *   <th>Given URL</th>

+ *   <th>Root URL</th>

+ * <tr>

+ *   <td>"http://hostname/"</td>

+ *   <td>"http://hostname/"</td>

+ * <tr>

+ *   <td>"http://hostname/folder/file</td>

+ *   <td>"http://hostname/"</td>

+ * </table>

+ *

+ * @param url a URL

+ * @return    the root URL of the given URL

+ */

+public static URL getRoot(URL url) {

+	try {

+		return new URL(url.getProtocol(), url.getHost(), url.getPort(), "/");

+	} catch(MalformedURLException e){

+		Assert.isTrue(false, "internal error");

+	}

+

+	return null;

+}

+/**

+ * Returns the given URL with its trailing slash removed. If the URL has

+ * no trailing slash, the URL is returned unchanged.

+ * <table>

+ * <caption>Example</caption>

+ * <tr>

+ *   <th>Given URL</th>

+ *   <th>Returned URL</th>

+ * <tr>

+ *   <td>"http://hostname/folder"</td>

+ *   <td>"http://hostname/folder"</td>

+ * <tr>

+ *   <td>"http://hostname/folder/</td>

+ *   <td>"http://hostname/folder"</td>

+ * </table>

+ *

+ * @param url a URL

+ * @return    the given URL with its last slash removed

+ * @throws    MalformedURLException if the given URL is malformed

+ */

+public static URL removeTrailingSlash(String url) throws MalformedURLException {

+	return removeTrailingSlash(new URL(url));

+}

+/**

+ * Returns the given URL with its trailing slash removed. If the URL has

+ * no trailing slash, the URL is returned unchanged.

+ * <table>

+ * <caption>Example</caption>

+ * <tr>

+ *   <th>Given URL</th>

+ *   <th>Returned URL</th>

+ * <tr>

+ *   <td>"http://hostname/folder"</td>

+ *   <td>"http://hostname/folder"</td>

+ * <tr>

+ *   <td>"http://hostname/folder/</td>

+ *   <td>"http://hostname/folder"</td>

+ * </table>

+ *

+ * @param url a URL

+ * @return    the given URL with its last slash removed

+ */

+public static URL removeTrailingSlash(URL url) {

+	String file = url.getFile();

+

+	if(file.endsWith("/")){

+		file = file.substring(0, file.length() - 1);

+		try {

+			return new URL(

+				url.getProtocol(),

+				url.getHost(),

+				url.getPort(),

+				file);

+		} catch(MalformedURLException e){

+			Assert.isTrue(false, e.getMessage());

+		}

+	} else {

+		return url;

+	}

+

+	return null;

+}

+/**

+ * Returns a boolean indicating whether the given URLs overlap.

+ * <table>

+ * <caption>Example</caption>

+ * <tr>

+ *   <th>First URL</th>

+ *   <th>Second URL</th>

+ *   <th>Do they overlap</th>

+ * <tr>

+ *   <td>"http://hostname/folder/"</td>

+ *   <td>"http://hostname/folder/"</td>

+ *   <td>true</td>

+ * <tr>

+ *   <td>"http://hostname/folder/"</td>

+ *   <td>"http://hostname/folder/file"</td>

+ *   <td>true</td>

+ * <tr>

+ *   <td>"http://hostname/folder/file"</td>

+ *   <td>"http://hostname/folder/"</td>

+ *   <td>true</td>

+ * <tr>

+ *   <td>"http://hostname/folder1/"</td>

+ *   <td>"http://hostname/folder2/"</td>

+ *   <td>false</td>

+ * </table>

+ * @param  url1 firt URL

+ * @param  url2 second URL

+ * @return a boolean indicating whether the given URLs overlap

+ */

+public static boolean urlsOverlap(String url1, String url2) throws MalformedURLException {

+	return urlsOverlap(new URL(url1), new URL(url2));

+}

+/**

+ * Returns a boolean indicating whether the given URLs overlap.

+ * <table>

+ * <caption>Example</caption>

+ * <tr>

+ *   <th>First URL</th>

+ *   <th>Second URL</th>

+ *   <th>Do they overlap</th>

+ * <tr>

+ *   <td>"http://hostname/folder/"</td>

+ *   <td>"http://hostname/folder/"</td>

+ *   <td>true</td>

+ * <tr>

+ *   <td>"http://hostname/folder/"</td>

+ *   <td>"http://hostname/folder/file"</td>

+ *   <td>true</td>

+ * <tr>

+ *   <td>"http://hostname/folder/file"</td>

+ *   <td>"http://hostname/folder/"</td>

+ *   <td>true</td>

+ * <tr>

+ *   <td>"http://hostname/folder1/"</td>

+ *   <td>"http://hostname/folder2/"</td>

+ *   <td>false</td>

+ * <tr>

+ *   <td>"http://hostname1/folder/"</td>

+ *   <td>"http://hostname2/folder/"</td>

+ *   <td>false</td>

+ * </table>

+ * @param  url1 firt URL

+ * @param  url2 second URL

+ * @return a boolean indicating whether the given URLs overlap

+ */

+public static boolean urlsOverlap(URL url1, URL url2){

+	if(!getRoot(url1).equals(getRoot(url2))){

+		return false;

+	}

+

+	Vector elements1 = URLTool.getElements(url1);

+	Vector elements2 = URLTool.getElements(url2);

+

+	for(int i = 0; i < elements1.size() && i < elements2.size(); ++i){

+		String element1 = (String)elements1.elementAt(i);

+		String element2 = (String)elements2.elementAt(i);

+		if(!element1.equals(element2)){

+			return false;

+		}

+	}

+

+	return true;

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/messages.properties b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/messages.properties
new file mode 100644
index 0000000..edd0d4f
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/internal/runtime/messages.properties
@@ -0,0 +1,53 @@
+### Runtime plugin message catalog

+

+ok = OK

+

+### plugins

+plugin.extDefNotFound = Executable extension definition for {0} not found.

+plugin.extDefNoClass = Executable extension definition {0} does not specify a class name.

+plugin.deactivatedLoad = Attempt to load class {0} from deactivated plug-in {1}.

+plugin.loadClassError = Plug-in {0} was unable to load class {1}.

+plugin.instantiateClassError = Plugin {0} was unable to instantiate class {1}.

+plugin.initObjectError = Plugin {0} was unable to execute setInitializationData on an instance of {1}.

+plugin.bundleNotFound = Plugin {0} could not find resource bundle {1}.

+plugin.notPluginClass = Supplied runtime class {0} does not extend class Plugin.

+plugin.startupProblems = Problems encountered starting up plug-in: {0}.

+plugin.pluginDisabled = Attempt to activate a disabled plug-in: {0}.

+plugin.unableToResolve = Unable to resolve plug-in registry.

+plugin.mismatchRuntime = Runtime class declaration mismatch for plug-in: {0}.

+

+### parsing/resolve

+parse.error = Parsing error: {0}.

+parse.errorProcessing = Error while processing {0}.

+parse.errorNameLineColumn = Parsing error in {0} [line {1}, column {2}]: {3}.

+parse.extPointUnknown = Unknown extension point {0} specified in plug-in {1}.

+parse.extPointDisabled = Extension point {0} specified in plug-in {1} is disabled.

+parse.prereqDisabled = Plug-in {0} was disabled due to missing or disabled prerequisite plug-in {1}.

+parse.unsatisfiedPrereq = Unable to satisfy prerequisite constraint from {0} to {1}.

+parse.prereqLoop = Detected prerequisite loop from {0} to {1}.

+parse.registryProblems = Problems encountered loading the plug-in registry.

+parse.fragmentMissingAttr = Fragment {0} ignored due to missing attributes.

+parse.fragmentMissingIdName = Fragment ignored due to missing attributes (including name and id).

+parse.pluginMissingAttr = Plugin {0} disabled due to missing attributes.

+parse.pluginMissingIdName = Plugin disabled due to missing attributes (including name and id).

+

+### metadata

+meta.unableToWriteRegistry = Unable to write plug-in registry to cache.

+meta.appNotInit = The application has not been initialized.

+meta.pluginProblems = Problems occurred when invoking code from plug-in: {0}.

+meta.notDir = Specified platform location {0} is not a directory.

+meta.readPlatformMeta = Could not read platform metadata: {0}.

+meta.writePlatformMeta = Could not write platform metadata: {0}.

+meta.couldNotCreate = Error trying to create the platform metadata area: {0}.

+meta.readonly = The platform metadata area could not be written: {0}.

+meta.unableToCreateCache = Unable to create output stream for registry cache.

+meta.unableToReadCache = Unable to create input stream for registry cache.

+meta.unableToCreateRegDebug = Unable to create output stream for registry debug information.

+meta.unableToWriteDebugRegistry = Unable to write plug-in registry to debug file.

+meta.unableToReadAuthorization = Unable to read authorization database: {0}.

+meta.unableToWriteAuthorization = Unable to write to authorization database: {0}.

+

+### URL

+url.badVariant=Unsupported "platform:" protocol variation {0}.

+url.resolveFragment=Unable to resolve fragment {0}.

+url.resolvePlugin=Unable to resolve plug-in {0}.

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/CoreException.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/CoreException.java
new file mode 100644
index 0000000..95342cd
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/CoreException.java
@@ -0,0 +1,78 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import java.io.PrintStream;

+import java.io.PrintWriter;

+/**

+ * A checked expection representing a failure.

+ * <p>

+ * Core exceptions contain a status object describing the 

+ * cause of the exception.

+ * </p>

+ *

+ * @see IStatus

+ */

+public class CoreException extends Exception {

+

+	/** Status object. */

+	private IStatus status;

+/**

+ * Creates a new exception with the given status object.  The message

+ * of the given status is used as the exception message.

+ *

+ * @param status the status object to be associated with this exception

+ */

+public CoreException(IStatus status) {

+	super(status.getMessage());

+	this.status = status;

+}

+/**

+ * Returns the status object for this exception.

+ *

+ * @return a status object

+ */

+public final IStatus getStatus() {

+	return status;

+}

+/**

+ * Prints a stack trace out for the exception, and

+ * any nested exception that it may have embedded in

+ * its Status object.

+ */

+public void printStackTrace() {

+	printStackTrace(System.err);

+}

+/**

+ * Prints a stack trace out for the exception, and

+ * any nested exception that it may have embedded in

+ * its Status object.

+ */

+public void printStackTrace(PrintStream output) {

+	synchronized (output) {

+		if (status.getException() != null) {

+			output.print(getClass().getName() + "[" + status.getCode() + "]: ");

+			status.getException().printStackTrace(output);

+		} else

+			super.printStackTrace(output);

+	}

+}

+/**

+ * Prints a stack trace out for the exception, and

+ * any nested exception that it may have embedded in

+ * its Status object.

+ */

+public void printStackTrace(PrintWriter output) {

+	synchronized (output) {

+		if (status.getException() != null) {

+			output.print(getClass().getName() + "[" + status.getCode() + "]: ");

+			status.getException().printStackTrace(output);

+		} else

+			super.printStackTrace(output);

+	}

+}

+

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IAdaptable.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IAdaptable.java
new file mode 100644
index 0000000..002968d
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IAdaptable.java
@@ -0,0 +1,40 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * An interface for an adaptable object.

+ * <p>

+ * Adaptable objects can be dynamically extended to provide different 

+ * interfaces (or "adapters").  Adapters are created by adapter 

+ * factories, which are in turn managed by type by adapter managers.

+ * </p>

+ * For example,

+ * <pre>

+ *     IAdaptable a = [some adaptable];

+ *     IFoo x = (IFoo)a.getAdapter(IFoo.class);

+ *     if (x != null)

+ *         [do IFoo things with x]

+ * </pre>

+ * <p>

+ * Clients may implement this interface.

+ * </p>

+ * @see IAdapterFactory

+ * @see IAdapterManager

+ */

+public interface IAdaptable {

+/**

+ * Returns an object which is an instance of the given class

+ * associated with this object. Returns <code>null</code> if

+ * no such object can be found.

+ *

+ * @param adapter the adapter class to look up

+ * @return a object castable to the given class, 

+ *    or <code>null</code> if this object does not

+ *    have an adapter for the given class

+ */

+public Object getAdapter(Class adapter);

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IAdapterFactory.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IAdapterFactory.java
new file mode 100644
index 0000000..fa978b9
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IAdapterFactory.java
@@ -0,0 +1,47 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * An adapter factory defines behavioral extensions for

+ * one or more classes that implements the <code>IAdaptable</code>

+ * interface. Adapter factories are registered with an

+ * adapter manager.

+ * <p>

+ * Clients may implement this interface.

+ * </p>

+ *

+ * @see IAdapterManager

+ * @see IAdaptable

+ */

+public interface IAdapterFactory {

+/**

+ * Returns an object which is an instance of the given class

+ * associated with the given object. Returns <code>null</code> if

+ * no such object can be found.

+ *

+ * @param adaptableObject the adaptable object being queried

+ *   (usually an instance of <code>IAdaptable</code>)

+ * @param adapterType the type of adapter to look up

+ * @return a object castable to the given adapter type, 

+ *    or <code>null</code> if this adapter factory 

+ *    does not have an adapter of the given type for the

+ *    given object

+ */

+public Object getAdapter(Object adaptableObject, Class adapterType);

+/**

+ * Returns the collection of adapter types handled by this

+ * factory.

+ * <p>

+ * This method is generally used by an adapter manager

+ * to discover which adapter types are supported, in advance

+ * of dispatching any actual <code>getAdapter</code> requests.

+ * </p>

+ *

+ * @return the collection of adapter types

+ */

+public Class[] getAdapterList();

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IAdapterManager.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IAdapterManager.java
new file mode 100644
index 0000000..40ddadb
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IAdapterManager.java
@@ -0,0 +1,107 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * An adapter manager maintains a registry of adapter factories.

+ * Clients directly invoke methods on an adapter manager to register

+ * and unregister adapters.

+ * All adaptable objects (that is, objects that implement the 

+ * <code>IAdaptable</code> interface) funnel 

+ * <code>IAdaptable.getAdapter</code> invocations to their

+ * adapter manager's <code>IAdapterManger.getAdapter</code>

+ * method. The adapter manager then forwards this request

+ * unmodified to the <code>IAdapterFactory.getAdapter</code> 

+ * method on one of the registered adapter factories.

+ * <p>

+ * The following code snippet shows how one might register

+ * an adapter of type <code>com.example.acme.Sticky</code>

+ * on resources in the workspace.

+ * <p>

+ * <pre>

+ * IAdapterFactory pr = new IAdapterFactory() {

+ *     public Class[] getAdapterList() {

+ *         return new Class[] { com.example.acme.Sticky.class };

+ *     }

+ *     public Object getAdapter(Object adaptableObject, adapterType) {

+ *         IResource res = (IResource) adaptableObject;

+ *         QualifiedName key = new QualifiedName("com.example.acme", "sticky-note");

+ *         try {

+ *             com.example.acme.Sticky v = (com.example.acme.Sticky) res.getSessionProperty(key);

+ *             if (v == null) {

+ *                 v = new com.example.acme.Sticky();

+ *                 res.setSessionProperty(key, v);

+ *             }

+ *         } catch (CoreException e) {

+ *             // unable to access session property - ignore

+ *         }

+ *         return v;

+ *     }

+ * }

+ * Platform.getAdapterManager().registerAdapters(pr, IResource.class);

+</pre>

+ * </p>

+ * <p>

+ * This interface is not intended to be implemented by clients.

+ * </p>

+ *

+ * @see IAdaptable

+ * @see IAdapterFactory

+ */

+public interface IAdapterManager {

+/**

+ * Returns an object which is an instance of the given class

+ * associated with the given object. Returns <code>null</code> if

+ * no such object can be found.

+ *

+ * @param adaptable the adaptable object being queried

+ *   (usually an instance of <code>IAdaptable</code>)

+ * @param adapterType the type of adapter to look up

+ * @return a object castable to the given adapter type, 

+ *    or <code>null</code> if the given adaptable object does not

+ *    have an adapter of the given type

+ */

+public Object getAdapter(Object adaptable, Class adapterType);

+/**

+ * Registers the given adapter factory as extending objects of

+ * the given type.

+ * <p>

+ * If the type being extended is a class,

+ * the given factory's adapters are available on instances

+ * of that class and any of its subclasses.  If it is an interface, 

+ * the adapters are available to all classes that directly 

+ * or indirectly implement that interface.

+ * </p>

+ *

+ * @param factory the adapter factory

+ * @param adaptable the type being extended

+ * @see #unregisterAdapters

+ */

+public void registerAdapters(IAdapterFactory factory, Class adaptable);

+/**

+ * Removes the given adapter factory completely from the list of 

+ * registered factories. Equivalent to calling

+ * <code>unregisterAdapters(IAdapterFactory,Class)</code>

+ * on all classes against which it had been explicitly registered.

+ * Does nothing if the given factory is not currently registered.

+ *

+ * @param factory the adapter factory to remove

+ * @see #registerAdapters

+ */

+public void unregisterAdapters(IAdapterFactory factory);

+/**

+ * Removes the given adapter factory from the list of factories

+ * registered as extending the given class.

+ * Does nothing if the given factory and type combination is not

+ * registered.

+ *

+ * @param factory the adapter factory to remove

+ * @param adaptable one of the types against which the given

+ *    factory is registered

+ * @see #registerAdapters

+ */

+public void unregisterAdapters(IAdapterFactory factory, Class adaptable);

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IConfigurationElement.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IConfigurationElement.java
new file mode 100644
index 0000000..9a9423f
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IConfigurationElement.java
@@ -0,0 +1,203 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * A configuration element, with its attributes and children, 

+ * directly reflects the content and structure of the extension section

+ * within the declaring plug-in's manifest (<code>plugin.xml</code>) file.

+ * <p>

+ * This interface also provides a way to create executable extension

+ * objects.

+ * </p>

+ * <p>

+ * This interface is not intended to be implemented by clients.

+ * </p>

+ */

+public interface IConfigurationElement {

+/**

+ * Creates and returns a new instance of the executable extension 

+ * identified by the named attribute of this configuration element.

+ * The named attribute value must contain a fully qualified name

+ * of a Java class implementing the executable extension.

+ * <p>

+ * The specified class is instantiated using its 0-argument public 

+ * constructor. If the specified class implements the

+ * <code>IExecutableExtension</code> interface, the method

+ * <code>setInitializationData</code> is called, passing to the object

+ * the configuration information that was used to create it. 

+ * </p>

+ * <p>

+ * Unlike other methods on this object, invoking this method may activate 

+ * the plug-in.

+ * </p>

+ *

+ * @param propertyName the name of the property

+ * @return the executable instance

+ * @exception CoreException if an instance of the executable extension

+ *   could not be created for any reason.

+ * @see IExecutableExtension#setInitializationData

+ */

+public Object createExecutableExtension(String propertyName) throws CoreException;

+/**

+ * Returns the named attribute of this configuration element, or

+ * <code>null</code> if none. 

+ * <p>

+ * The names of configuration element attributes

+ * are the same as the attribute names of the corresponding XML element.

+ * For example, the configuration markup 

+ * <pre>

+ * &lt;bg pattern="stripes"/&gt;

+ * </pre>

+ * corresponds to a configuration element named <code>"bg"</code>

+ * with an attribute named <code>"pattern"</code>

+ * with attribute value <code>"stripes"</code>.

+ * </p>

+ * <p> Note that any translation specified in the plug-in manifest

+ * file is automatically applied.

+ * </p>

+ *

+ * @see IPluginDescriptor#getResourceString 

+ *

+ * @param name the name of the attribute

+ * @return attribute value, or <code>null</code> if none

+ */

+public String getAttribute(String name);

+/**

+ * Returns the named attribute of this configuration element, or

+ * <code>null</code> if none. 

+ * <p>

+ * The names of configuration element attributes

+ * are the same as the attribute names of the corresponding XML element.

+ * For example, the configuration markup 

+ * <pre>

+ * &lt;bg pattern="stripes"/&gt;

+ * </pre>

+ * corresponds to a configuration element named <code>"bg"</code>

+ * with an attribute named <code>"pattern"</code>

+ * with attribute value <code>"stripes"</code>.

+ * </p>

+ * <p>

+ * Note that any translation specified in the plug-in manifest

+ * file for this attribute is <b>not</b> automatically applied.

+ * </p>

+ *

+ * @param name the name of the attribute

+ * @return attribute value, or <code>null</code> if none

+ */

+public String getAttributeAsIs(String name);

+/**

+ * Returns the names of the attributes of this configuration element.

+ * Returns an empty array if this configuration element has no attributes.

+ * <p>

+ * The names of configuration element attributes

+ * are the same as the attribute names of the corresponding XML element.

+ * For example, the configuration markup 

+ * <pre>

+ * &lt;bg color="blue" pattern="stripes"/&gt;

+ * </pre>

+ * corresponds to a configuration element named <code>"bg"</code>

+ * with attributes named <code>"color"</code>

+ * and <code>"pattern"</code>.

+ * </p>

+ *

+ * @return the names of the attributes 

+ */

+public String[] getAttributeNames();

+/**

+ * Returns all configuration elements that are children of this

+ * configuration element. 

+ * Returns an empty array if this configuration element has no children.

+ * <p>

+ * Each child corresponds to a nested

+ * XML element in the configuration markup.

+ * For example, the configuration markup 

+ * <pre>

+ * &lt;view&gt;

+ * &nbsp&nbsp&nbsp&nbsp&lt;verticalHint&gt;top&lt;/verticalHint&gt;

+ * &nbsp&nbsp&nbsp&nbsp&lt;horizontalHint&gt;left&lt;/horizontalHint&gt;

+ * &lt;/view&gt;

+ * </pre>

+ * corresponds to a configuration element, named <code>"view"</code>,

+ * with two children.

+ * </p>

+ *

+ * @return the child configuration elements

+ */

+public IConfigurationElement[] getChildren();

+/**

+ * Returns all child configuration elements with the given name. 

+ * Returns an empty array if this configuration element has no children

+ * with the given name.

+ *

+ * @param name the name of the child configuration element

+ * @return the child configuration elements with that name

+ * @see #getChildren

+ */

+public IConfigurationElement[] getChildren(String name);

+/** 

+ * Returns the extension that declares this configuration element.

+ *

+ * @return the extension

+ */

+public IExtension getDeclaringExtension();

+/**

+ * Returns the name of this configuration element. 

+ * The name of a configuration element is the same as

+ * the XML tag of the corresponding XML element. 

+ * For example, the configuration markup 

+ * <pre>

+ * &lt;wizard name="Create Project"/&gt; 

+ * </pre>

+ * corresponds to a configuration element named <code>"wizard"</code>.

+ *

+ * @return the name of this configuration element

+ */

+public String getName();

+/**

+ * Returns the text value of this configuration element.

+ * For example, the configuration markup 

+ * <pre>

+ * &lt;script lang="javascript"&gt;.\scripts\cp.js&lt;/script&gt;

+ * </pre>

+ * corresponds to a configuration element <code>"script"</code>

+ * with value <code>".\scripts\cp.js"</code>.

+ * <p> Values may span multiple lines (i.e., contain carriage returns

+ * and/or line feeds).

+ * <p> Note that any translation specified in the plug-in manifest

+ * file is automatically applied.

+ * </p>

+ *

+ * @see IPluginDescriptor#getResourceString 

+ *

+ * @return the text value of this configuration element or <code>null</code>

+ */

+public String getValue();

+/**

+ * Returns the untranslated text value of this configuration element.

+ * For example, the configuration markup 

+ * <pre>

+ * &lt;script lang="javascript"&gt;.\scripts\cp.js&lt;/script&gt;

+ * </pre>

+ * corresponds to a configuration element <code>"script"</code>

+ * with value <code>".\scripts\cp.js"</code>.

+ * <p> Values may span multiple lines (i.e., contain carriage returns

+ * and/or line feeds).

+ * <p>

+ * Note that translation specified in the plug-in manifest

+ * file is <b>not</b> automatically applied.

+ * For example, the configuration markup 

+ * <pre>

+ * &lt;tooltip&gt;#hattip&lt;/tooltip&gt;

+ * </pre>

+ * corresponds to a configuration element, named <code>"tooltip"</code>,

+ * with value <code>"#hattip"</code>.

+ * </p>

+ *

+ * @return the untranslated text value of this configuration element or <code>null</code>

+ */

+public String getValueAsIs();

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IExecutableExtension.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IExecutableExtension.java
new file mode 100644
index 0000000..e5445da
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IExecutableExtension.java
@@ -0,0 +1,113 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * Interface for executable extension classes that require access to 

+ * their configuration element, or implement an extension adapter.

+ * <p>

+ * Extension adapters are typically required in cases where the extension

+ * implementation does not follow the interface rules specified

+ * by the provider of the extension point. In these

+ * cases, the role of the adapter is to map between the extension point

+ * interface, and the actual extension implementation. In general, adapters

+ * are used when attempting to plug-in existing Java implementations, or

+ * non-Java implementations (e.g., external executables).

+ * </p>

+ * <p>

+ * Clients may implement this interface.

+ * </p>

+ * 

+ * @see IConfigurationElement#createExecutableExtension 

+ */

+public interface IExecutableExtension {

+/**

+ * This method is called by the implementation of the method

+ * <code>IConfigurationElement.createExecutableExtension</code>

+ * on a newly constructed extension, passing it its relevant configuration 

+ * information. Most executable extensions only make use of the first 

+ * two call arguments.

+ * <p>

+ * Regular executable extensions specify their Java implementation 

+ * class name as an attribute of the configuration element for the 

+ * extension. For example

+ * <pre>

+ *     &lt;action run="com.example.BaseAction"/&gt;

+ * </pre>

+ * In the above example, this method would be called with a reference

+ * to the <code>&lt;action&gt;</code> element (first argument), and

+ * <code>"run"</code> as the name of the attribute that defined

+ * this executable extension (second argument).

+ * </p>

+ * <p>

+ * The last parameter is for the specific use of extension adapters

+ * and is typically not used by regular executable extensions.

+ * </p>

+ * <p>

+ * There are two supported ways of associating additional

+ * adapter-specific data with the configuration in a way that

+ * is transparent to the extension point implementor:

+ * </p>

+ * <p>

+ * (1) by specifying adapter data as part of the implementation

+ * class attribute value. The Java class name can be followed

+ * by a ":" separator, followed by any adapter data in string

+ * form. For example, if the extension point specifies an attribute

+ * <code>"run"</code> to contain the name of the extension implementation,

+ * an adapter can be configured as

+ * <pre>

+ *     &lt;action run="com.example.ExternalAdapter:./cmds/util.exe -opt 3"/&gt;

+ * </pre>

+ * </p>

+ * <p>

+ * (2) by converting the attribute used to specify the executable

+ * extension to a child element of the original configuration element,

+ * and specifying the adapter data in the form of xml markup.

+ * Using this form, the example above would become

+ * <pre>

+ *     &lt;action&gt;

+ *         &lt;<it>run</it> class="com.xyz.ExternalAdapter"&gt;

+ *             &lt;parameter name="exec" value="./cmds/util.exe"/&gt;

+ *             &lt;parameter name="opt"  value="3"/&gt;

+ *         &lt;/<it>run</it>&gt;

+ *     &lt;/action&gt;

+ * </pre>

+ * </p>

+ * <p>

+ * Form (2) will typically only be

+ * used for extension points that anticipate the majority of

+ * extensions configured into it will in fact be in the form

+ * of adapters.

+ * </p>

+ * <p>

+ * In either case, the specified adapter class is instantiated using its

+ * 0-argument public constructor. The adapter data is passed as the

+ * last argument of this method. The data argument is defined as Object.

+ * It can have the following values:

+ * <ul>

+ * <li><code>null</code>, if no adapter data was supplied</li>

+ * <li>in case (1), the initialization data

+ *		string is passed as a <code>String</code></li>

+ * <li>in case (2), the initialization data is passed

+ *		as a <code>Hashtable</code> containing the actual

+ *		parameter names and values (both <code>String</code>s)</li>

+ * </ul>

+ * </p>

+ *

+ * @param config the configuration element used to trigger this execution. 

+ *		It can be queried by the executable extension for specific

+ *		configuration properties

+ * @param propertyName the name of an attribute of the configuration element

+ *		used on the <code>createExecutableExtension(String)</code> call. This

+ *		argument can be used in the cases where a single configuration element

+ *		is used to define multiple executable extensions.

+ * @param data adapter data in the form of a <code>String</code>, 

+ *		a <code>Hashtable</code>, or <code>null</code>.

+ * @exception CoreException if error(s) detected during initialization processing

+ * @see IConfigurationElement#createExecutableExtension

+ */

+public void setInitializationData(IConfigurationElement config, String propertyName, Object data) throws CoreException;

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IExtension.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IExtension.java
new file mode 100644
index 0000000..3fb6469
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IExtension.java
@@ -0,0 +1,77 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * An extension declared in a plug-in.

+ * All information is obtained from the declaring plug-in's 

+ * manifest (<code>plugin.xml</code>) file. 

+ * <p>

+ * This interface is not intended to be implemented by clients.

+ * </p>

+ */

+public interface IExtension {

+/**

+ * Returns all configuration elements declared by this extension.

+ * These elements are a direct reflection of the configuration 

+ * markup supplied in the manifest (<code>plugin.xml</code>)

+ * file for the plug-in that declares this extension.

+ * Returns an empty array if this extension does not declare any

+ * configuration elements.

+ *

+ * @return the configuration elements declared by this extension 

+ */

+public IConfigurationElement[] getConfigurationElements();

+/** 

+ * Returns the descriptor of the plug-in that declares this extension.

+ *

+ * @return the plug-in that declares this extension

+ */

+public IPluginDescriptor getDeclaringPluginDescriptor();

+/**

+ * Returns the unique identifier of the extension point

+ * that this extension gets plugged into.

+ *

+ * @return the unique identifier of the relevant extension point

+ */

+public String getExtensionPointUniqueIdentifier();

+/**

+ * Returns a displayable label for this extension.

+ * Returns the empty string if no label for this extension

+ * is specified in the plug-in manifest file.

+ * <p> Note that any translation specified in the plug-in manifest

+ * file is automatically applied.

+ * <p>

+ *

+ * @see IPluginDescriptor#getResourceString 

+ *

+ * @return a displayable string label for this extension,

+ *    possibly the empty string

+ */

+public String getLabel();

+/**

+ * Returns the simple identifier of this extension, or <code>null</code>

+ * if this extension does not have an identifier.

+ * This identifier is specified in the plug-in manifest (<code>plugin.xml</code>) 

+ * file as a non-empty string containing no period characters 

+ * (<code>'.'</code>) and must be unique within the defining plug-in.

+ *

+ * @return the simple identifier of the extension (e.g. <code>"main"</code>)

+ *  or <code>null</code>

+ */

+public String getSimpleIdentifier();

+/**

+ * Returns the unique identifier of this extension, or <code>null</code>

+ * if this extension does not have an identifier.

+ * If available, this identifier is unique within the plug-in registry, and

+ * is composed of the identifier of the plug-in that declared

+ * this extension and this extension's simple identifier.

+ *

+ * @return the unique identifier of the extension

+ *    (e.g. <code>"com.example.acme.main"</code>), or <code>null</code>

+ */

+public String getUniqueIdentifier();

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IExtensionPoint.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IExtensionPoint.java
new file mode 100644
index 0000000..fa11bc7
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IExtensionPoint.java
@@ -0,0 +1,95 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * An extension point declared in a plug-in.

+ * Except for the list of extensions plugged in to it, the information 

+ * available for an extension point is obtained from the declaring plug-in's 

+ * manifest (<code>plugin.xml</code>) file.

+ * <p>

+ * This interface is not intended to be implemented by clients.

+ * </p>

+ */

+public interface IExtensionPoint {

+/**

+ * Returns all configuration elements from all extensions configured

+ * into this extension point. Returns an empty array if this extension 

+ * point has no extensions configured, or none of the extensions 

+ * contain configuration elements.

+ *

+ * @return the configuration elements for all extension configured 

+ *   into this extension point

+ */

+public IConfigurationElement[] getConfigurationElements();

+/** 

+ * Returns the descriptor of the plug-in that declares this extension point.

+ *

+ * @return the plug-in that declares this extension point

+ */

+public IPluginDescriptor getDeclaringPluginDescriptor();

+/**

+ * Returns the extension with the given unique identifier configured into

+ * this extension point, or <code>null</code> if there is no such extension.

+ * Since an extension might not have an identifier, some extensions

+ * can only be found via the <code>getExtensions</code> method.

+ *

+ * @param extensionId the unique identifier of an extension 

+ *		(e.g. <code>"com.example.acme.main"</code>).

+ * @return an extension, or <code>null</code>

+ */

+public IExtension getExtension(String extensionId) ;

+/**

+ * Returns all extensions configured into this extension point.

+ * Returns an empty array if this extension point has no extensions.

+ *

+ * @return the extensions configured into this extension point

+ */

+public IExtension[] getExtensions();

+/**

+ * Returns a displayable label for this extension point.

+ * Returns the empty string if no label for this extension point

+ * is specified in the plug-in manifest file.

+ * <p> Note that any translation specified in the plug-in manifest

+ * file is automatically applied.

+ * </p>

+ *

+ * @return a displayable string label for this extension point,

+ *    possibly the empty string

+ * @see IPluginDescriptor#getResourceString 

+ */

+public String getLabel();

+/**

+ * Returns reference to the extension point schema. The schema 

+ * reference is returned as a URL path relative to the plug-in 

+ * installation URL. 

+ * Returns the empty string if no schema for this extension point

+ * is specified in the plug-in manifest file.

+ *

+ * @return a relative URL path, or an empty string

+ * @see IPluginDescriptor#getInstallURL

+ */

+public String getSchemaReference();

+/**

+ * Returns the simple identifier of this extension point.

+ * This identifier is a non-empty string containing no

+ * period characters (<code>'.'</code>) and is guaranteed

+ * to be unique within the defining plug-in.

+ *

+ * @return the simple identifier of the extension point (e.g. <code>"builders"</code>)

+ */

+public String getSimpleIdentifier();

+/**

+ * Returns the unique identifier of this extension point.

+ * This identifier is unique within the plug-in registry, and

+ * is composed of the identifier of the plug-in that declared

+ * this extension point and this extension point's simple identifier.

+ *

+ * @return the unique identifier of the extension point

+ *    (e.g. <code>"org.eclipse.core.resources.builders"</code>)

+ */

+public String getUniqueIdentifier();

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ILibrary.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ILibrary.java
new file mode 100644
index 0000000..2518f30
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ILibrary.java
@@ -0,0 +1,85 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.model.LibraryModel;

+

+ /**

+ * A runtime library declared in a plug-in.  Libraries contribute elements to the search path.

+ * These contributions are specified as a path to a directory or Jar file.  This path is always

+ * considered to be relative to the containing plug-in.  

+ * <p>

+ * Libraries are typed.  The type is used to determine to which search path the library's

+ * contribution should be added.  The valid types are: <code>CODE</code> and

+ * <code>RESOURCE</code>.  

+ * </p>

+ * <p>

+ * This interface is not intended to be implemented by clients.

+ * </p>

+ *

+ * @see IPluginDescriptor#getRuntimeLibraries 

+ */

+public interface ILibrary {

+	/**

+	 * Constant string (value "code") indicating the code library type.

+	 * @see LibraryModel#CODE

+	 */

+	public static final String CODE = LibraryModel.CODE;

+	

+	/**

+	 * Constant string (value "resource") indicating the resource library type.

+	 * @see LibraryModel#RESOURCE

+	 */

+	public static final String RESOURCE = LibraryModel.RESOURCE;

+	

+/**

+ * Returns the content filters, or <code>null</code>.

+ * Each content filter identifies a specific class, or

+ * a group of classes, using a notation and matching rules

+ * equivalent to Java <code>import</code> declarations

+ * (e.g., "java.io.File", or "java.io.*"). Returns <code>null</code>

+ * if the library is not exported, or it is fully exported

+ * (no filtering).

+ *

+ * @return the content filters, or <code>null</codel> if none

+ */

+public String[] getContentFilters();

+/**

+ * Returns the path of this runtime library, relative to the

+ * installation location.

+ *

+ * @return the path of the library

+ * @see IPluginDescriptor#getInstallURL

+ */

+public IPath getPath();

+/**

+ * Returns this library's type.

+ *

+ * @return the type of this library.   The valid types are: <code>CODE</code> and <code>RESOURCE</code>.

+ * @see #CODE

+ * @see #RESOURCE

+ */

+public String getType();

+/**

+ * Returns whether the library is exported. The contents of an exported

+ * library may be visible to other plug-ins that declare a dependency

+ * on the plug-in containing this library, subject to content filtering.

+ * Libraries that are not exported are entirely private to the declaring

+ * plug-in.

+ *

+ * @return <code>true</code> if the library is exported, <code>false</code>

+ *    if it is private

+ */

+public boolean isExported();

+/**

+ * Returns whether this library is fully exported. A library is considered

+ * fully exported iff it is exported and has no content filters.

+ *

+ * @return <code>true</code> if the library is fully exported, and

+ *    <code>false</code> if it is private or has filtered content

+ */

+public boolean isFullyExported();

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ILog.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ILog.java
new file mode 100644
index 0000000..3f83326
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ILog.java
@@ -0,0 +1,47 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * A log to which status events can be written.  Logs appear on individual

+ * plug-ins and on the platform itself.  Clients can register log listeners which

+ * will receive notification of all log events as the come in.

+ * <p>

+ * This interface is not intended to be implemented by clients.

+ * </p>

+ */

+public interface ILog {

+/**

+ * Adds the given log listener to this log.  Subsequently the log listener will

+ * receive notification of all log events passing through this log.

+ * This method has no affect if the identical listener is already registered on this log.

+ *

+ * @param listener the listener to add to this log

+ * @see Platform#addLogListener

+ */

+public void addLogListener(ILogListener listener);

+/**

+ * Returns the plug-in with which this log is associated.

+ *

+ * @return the plug-in with which this log is associated

+ */

+public Plugin getPlugin();

+/**

+ * Logs the given status.  The status is distributed to the log listeners

+ * installed on this log and then to the log listeners installed on the platform.

+ *

+ * @param status the status to log

+ */

+public void log(IStatus status);

+/**

+ * Removes the given log listener to this log.  Subsequently the log listener will

+ * no longer receive notification of log events passing through this log.  

+ * This method has no affect if the identical listener is not registered on this log.

+ *

+ * @see Platform#removeLogListener

+ */

+public void removeLogListener(ILogListener listener);

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ILogListener.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ILogListener.java
new file mode 100644
index 0000000..40b3f0a
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ILogListener.java
@@ -0,0 +1,28 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import java.util.EventListener;

+

+/**

+ * A log listener is notified of entries added to a plug-in's log.

+ * <p>

+ * Clients may implement this interface.

+ * </p>

+ *

+ * @see ILog#addLogListener

+ * @see Platform#addLogListener

+ */

+public interface ILogListener extends EventListener {

+/**

+ * Notifies this listener that given status has been logged by

+ * a plug-in.  The listener is free to retain or ignore this status.

+ * 

+ * @param status the status being logged

+ * @param plugin the plugin of the log which generated this event

+ */

+public void logging(IStatus status, String plugin);

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPath.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPath.java
new file mode 100644
index 0000000..2ae456c
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPath.java
@@ -0,0 +1,449 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import java.io.File;

+

+/**

+ * A path is an ordered collection of string segments,

+ * separated by a standard separator character, "/".

+ * A path may also have a leading and/or a trailing separator.

+ * Paths also be prefixed by an optional device id, which includes

+ * the character(s) which separate the device id from the rest 

+ * of the path. For example, "C:" and "Server/Volume:" are typical

+ * device ids.

+ * A device independent path has <code>null</code> for a device id.

+ * <p>

+ * Note that paths are value objects; all operations on paths 

+ * return a new path; the receiver is unscathed.

+ * </p>

+ * <p>

+ * UNC paths are denoted by leading double-slashes such 

+ * as <code>//Server/Volume/My/Path</code>. When a new path

+ * is constructed all double-slashes are removed except those

+ * appearing at the beginning of the path.

+ * </p>

+ * <p>

+ * This interface is not intended to be implemented by clients.

+ * </p>

+ * 

+ * @see Path

+ */

+public interface IPath extends Cloneable {

+

+	/**

+	 * Path separator character constant "/" used in paths.

+	 */

+	public static final char SEPARATOR = '/';

+	

+	/** 

+	 * Device separator character constant ":" used in paths.

+	 */

+	public static final char DEVICE_SEPARATOR = ':';

+/**

+ * Returns a new path which is the same as this path but with

+ * the given file extension added.  If this path is empty, root or has a 

+ * trailing separator, this path is returned.  If this path already

+ * has an extension, the existing extension is left and the given

+ * extension simply appended.  Clients wishing to replace

+ * the current extension should first remove the extension and

+ * then add the desired one.

+ * <p>

+ * The file extension portion is defined as the string

+ * following the last period (".") character in the last segment.

+ * The given extension should not include a leading ".".

+ * </p>

+ *

+ * @param extension the file extension to append

+ * @return the new path

+ */

+public IPath addFileExtension(String extension);

+/**

+ * Returns a path with the same segments as this path

+ * but with a trailing separator added.

+ * This path must have at least one segment.

+ * <p>

+ * If this path already has a trailing separator,

+ * this path is returned.

+ * </p>

+ *

+ * @return the new path

+ * @see #hasTrailingSeparator

+ * @see #removeTrailingSeparator

+ */

+public IPath addTrailingSeparator();

+/**

+ * Returns the canonicalized path obtained from the

+ * concatenation of the given string path to the

+ * end of this path. The given string path must be a valid

+ * path. If it has a trailing separator, 

+ * the result will have a trailing separator.

+ * The device id of this path is preserved (the one

+ * of the given string is ignored). Duplicate slashes

+ * are removed from the path except at the beginning

+ * where the path is considered to be UNC.

+ * 

+ * @param path the string path to concatenate

+ * @return the new path

+ * @see #isValidPath 

+ */

+public IPath append(String path);

+/**

+ * Returns the canonicalized path obtained from the 

+ * concatenation of the given path's segments to the

+ * end of this path.  If the given path has a trailing

+ * separator, the result will have a trailing separator.

+ * The device id of this path is preserved (the one

+ * of the given path is ignored). Duplicate slashes

+ * are removed from the path except at the beginning

+ * where the path is considered to be UNC.

+ *

+ * @param path the path to concatenate

+ * @return the new path

+ */

+public IPath append(IPath path);

+/**

+ * Returns a copy of this path.

+ *

+ * @return the cloned path

+ */

+public Object clone();

+/**

+ * Returns whether this path equals the given object.

+ * <p>

+ * Equality for paths is defined to be: same sequence of segments,

+ * same absolute/relative status, and same device.

+ * Trailing separators are disregarded.

+ * Paths are not generally considered equal to objects other than paths.

+ * </p>

+ *

+ * @param obj the other object

+ * @return <code>true</code> if the paths are equivalent,

+ *    and <code>false</code> if they are not

+ */

+public boolean equals(Object obj);

+/**

+ * Returns the device id for this path, or <code>null</code> if this

+ * path has no device id. Note that the result will end in ':'.

+ *

+ * @return the device id, or <code>null</code>

+ * @see #setDevice

+ */

+public String getDevice();

+/**

+ * Returns the file extension portion of this path, 

+ * or <code>null</code> if there is none.

+ * <p>

+ * The file extension portion is defined as the string

+ * following the last period (".") character in the last segment.

+ * If there is no period in the last segment, the path has no

+ * file extension portion. If the last segment ends in a period,

+ * the file extension portion is the empty string.

+ * </p>

+ *

+ * @return the file extension or <code>null</code>

+ */

+public String getFileExtension();

+/**

+ * Returns whether this path has a trailing separator.

+ * <p>

+ * Note: In the root path ("/"), the separator is considered to

+ * be leading rather than trailing.

+ * </p>

+ *

+ * @return <code>true</code> if this path has a trailing

+ *    separator, and <code>false</code> otherwise

+ * @see #addTrailingSeparator

+ * @see #removeTrailingSeparator

+ */

+public boolean hasTrailingSeparator();

+/**

+ * Returns whether this path is an absolute path (ignoring

+ * any device id).

+ * <p>

+ * Absolute paths start with a path separator.

+ * A root path, like <code>/</code> or <code>C:/</code>, 

+ * is considered absolute.

+ * </p>

+ *

+ * @return <code>true</code> if this path is an absolute path,

+ *    and <code>false</code> otherwise

+ */

+public boolean isAbsolute();

+/**

+ * Returns whether this path has no segments and is not

+ * a root path.

+ *

+ * @return <code>true</code> if this path is empty,

+ *    and <code>false</code> otherwise

+ */

+public boolean isEmpty();

+/**

+ * Returns whether this path is a prefix of the given path.

+ * To be a prefix, this path's segments must

+ * appear in the argument path in the same order,

+ * and their device ids must match.

+ * <p>

+ * Modulo device ids, an empty path is a prefix of all paths;

+ * a root path is a prefix of all absolute paths.

+ * </p>

+ *

+ * @param anotherPath the other path

+ * @return <code>true</code> if this path is a prefix of the given path,

+ *    and <code>false</code> otherwise

+ */

+public boolean isPrefixOf(IPath anotherPath);

+/**

+ * Returns whether this path is a root path.

+ * <p>

+ * The root path is the absolute path with zero segments; 

+ * e.g., <code>/</code> or <code>C:/</code>.

+ * The separator is considered a leading separator, not a trailing one.

+ * </p>

+ *

+ * @return <code>true</code> if this path is a root path,

+ *    and <code>false</code> otherwise

+ */

+public boolean isRoot();

+/**

+ * Returns a boolean value indicating whether or not this path

+ * is considered to be in UNC form. Return false if this path

+ * has a device set or if the first 2 characters of the path string

+ * are not <code>Path.SEPARATOR</code>.

+ * 

+ * @return boolean indicating if this path is UNC

+ */

+public boolean isUNC();

+/**

+ * Returns whether the given string is syntactically correct as

+ * a path.  The device id is the prefix up to and including the first ":";

+ * the path proper is everything to the right of it, or the entire string

+ * if there is no ":". The device id is not checked for validity;

+ * the path proper is correct if each of the segments in its canonicalized

+ * form is valid.

+ *

+ * @return <code>true</code> if the given string is a valid path,

+ *    and <code>false</code> otherwise

+ * @see #isValidSegment

+ */

+public boolean isValidPath(String path);

+/**

+ * Returns whether the given string is valid as a segment in 

+ * a path. The rules for valid segments are as follows:

+ * <ul>

+ * <li> the empty string is not valid

+ * <li> any string containing the colon character (":") is not valid

+ * <li> any string containing the slash character ("/") is not valid

+ * <li> any string containing the backslash character ("\") is not valid

+ * <li> any string starting or ending with a whitespace character is not valid

+ * <li> all other strings are valid

+ * </ul>

+ *

+ * @param segment the path segment to check

+ * @return <code>true</code> if the given path segment is valid,

+ *    and <code>false</code> otherwise

+ * @see java.lang.Character#isWhitespace

+ */

+public boolean isValidSegment(String segment);

+/**

+ * Returns the last segment of this path, or

+ * <code>null</code> if it does not have any segments.

+ *

+ * @return the last segment of this path, or <code>null</code> 

+ */

+public String lastSegment();

+/**

+ * Returns an absolute path with the segments and device id of this path.

+ * If this path is absolute, it is simply returned.

+ *

+ * @return the new path

+ */

+public IPath makeAbsolute();

+/**

+ * Returns a relative path with the segments and device id of this path.

+ * If this path is relative, it is simply returned.

+ *

+ * @return the new path

+ */

+public IPath makeRelative();

+/**

+ * Return a new path which is the equivalent of this path converted to UNC

+ * form (if the given boolean is true) or this path not as a UNC path (if the given

+ * boolean is false). If UNC, the returned path will not have a device and the 

+ * first 2 characters of the path string will be <code>Path.SEPARATOR</code>. If not UNC, the

+ * 	first 2 characters of the returned path string will not be <code>Path.SEPARATOR</code>.

+ * 

+ * @param toUNC true if converting to UNC, false otherwise

+ * @return the new path, either in UNC form or not depending on the boolean parm

+ */

+public IPath makeUNC(boolean toUNC);

+/**

+ * Returns a count of the number of segments which match in

+ * this path and the given path (device ids are ignored),

+ * comparing in increasing segment number order.

+ *

+ * @param anotherPath the other path

+ * @return the number of matching segments

+ */

+public int matchingFirstSegments(IPath anotherPath);

+/**

+ * Returns a new path which is the same as this path but with

+ * the file extension removed.  If this path does not have an 

+ * extension, this path is returned.

+ * <p>

+ * The file extension portion is defined as the string

+ * following the last period (".") character in the last segment.

+ * If there is no period in the last segment, the path has no

+ * file extension portion. If the last segment ends in a period,

+ * the file extension portion is the empty string.

+ * </p>

+ *

+ * @return the new path

+ */

+public IPath removeFileExtension();

+/**

+ * Returns a copy of this path with the given number of segments

+ * removed from the beginning. The device id is preserved. 

+ * The number must be greater or equal zero.

+ * If the count is zero, this path is returned.

+ * The resulting path will always be a relative path with respect

+ * to this path.  If the number equals or exceeds the number

+ * of segments in this path, an empty relative path is returned.

+ *

+ * @return the new path

+ */

+public IPath removeFirstSegments(int count);

+/**

+ * Returns a copy of this path with the given number of segments

+ * removed from the end. The device id is preserved.

+ * The number must be greater or equal zero.

+ * If the count is zero, this path is returned.

+ * <p>

+ * If this path has a trailing separator, it will still

+ * have a trailing separator after the last segments are removed

+ * (assuming there are some segments left).  If there is no

+ * trailing separator, the result will not have a trailing

+ * separator.

+ * If the number equals or exceeds the number

+ * of segments in this path, an empty path is returned.

+ * </p>

+ *

+ * @return the new path

+ */

+public IPath removeLastSegments(int count);

+/**

+ * Returns a path with the same segments as this path

+ * but with a trailing separator removed.

+ * Does nothing if this path does not have at least one segment.

+ * The device id is preserved.

+ * <p>

+ * If this path does not have a trailing separator,

+ * this path is returned.

+ * </p>

+ *

+ * @return the new path

+ * @see #addTrailingSeparator

+ * @see #hasTrailingSeparator

+ */

+public IPath removeTrailingSeparator();

+/**

+ * Returns the specified segment of this path, or

+ * <code>null</code> if the path does not have such a segment.

+ *

+ * @param index the 0-based segment index

+ * @return the specified segment, or <code>null</code> 

+ */

+public String segment(int index);

+/**

+ * Returns the number of segments in this path.

+ * <p> 

+ * Note that both root and empty paths have 0 segments.

+ * </p>

+ *

+ * @return the number of segments

+ */

+public int segmentCount();

+/**

+ * Returns the segments in this path in order.

+ *

+ * @return an array of string segments

+ */

+public String[] segments();

+/**

+ * Returns a new path which is the same as this path but with 

+ * the given device id.  The device id must end with a ":".

+ * A device independent path is obtained by passing <code>null</code>.

+ * <p>

+ * For example, "C:" and "Server/Volume:" are typical device ids.

+ * </p>

+ *

+ * @param device the device id or <code>null</code>

+ * @return a new path

+ * @see #getDevice

+ */

+public IPath setDevice(String device);

+/**

+ * Returns a <code>java.io.File</code> corresponding to this path.

+ *

+ * @return the file corresponding to this path

+ */

+public java.io.File toFile();

+/**

+ * Returns a string representation of this path which uses the

+ * platform-dependent path separator defined by <code>java.io.File</code>.

+ * This method is like <code>toString()</code> except that the

+ * latter always uses the same separator (<code>/</code>) regardless of platform.

+ * <p>

+ * This string is suitable for passing to <code>java.io.File(String)</code>.

+ * </p>

+ *

+ * @return a platform-dependent string representation of this path

+ */

+public String toOSString();

+/**

+ * Returns a string representation of this path, including its

+ * device id.  The same separator, "/", is used on all platforms.

+ * <p>

+ * Example result strings (without and with device id):

+ * <pre>

+ * "/foo/bar.txt"

+ * "bar.txt"

+ * "/foo/"

+ * "foo/"

+ * ""

+ * "/"

+ * "C:/foo/bar.txt"

+ * "C:bar.txt"

+ * "C:/foo/"

+ * "C:foo/"

+ * "C:"

+ * "C:/"

+ * </pre>

+ * This string is suitable for passing to <code>Path(String)</code>.

+ * </p>

+ *

+ * @return a string representation of this path

+ * @see Path

+ */

+public String toString();

+/**

+ * Returns a copy of this path truncated after the

+ * given number of segments. The number must not be negative.

+ * The device id is preserved.

+ * <p>

+ * If this path has a trailing separator, the result will too

+ * (assuming there are some segments left). If there is no

+ * trailing separator, the result will not have a trailing

+ * separator.

+ * Copying up to segment zero simply means making an copy with

+ * no path segments.

+ * </p>

+ *

+ * @param count the segment number at which to truncate the path

+ * @return the new path

+ */

+public IPath uptoSegment(int count);

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPluginDescriptor.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPluginDescriptor.java
new file mode 100644
index 0000000..aafde0b
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPluginDescriptor.java
@@ -0,0 +1,257 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import java.util.MissingResourceException;

+import java.util.ResourceBundle;

+import java.net.URL;

+

+/**

+ * A plug-in descriptor contains information about a plug-in

+ * obtained from the plug-in's manifest (<code>plugin.xml</code>) file.

+ * <p>

+ * Plug-in descriptors are platform-defined objects that exist

+ * in the plug-in registry independent of whether a plug-in has

+ * been started. In contrast, a plug-in's runtime object 

+ * (<code>getPlugin</code>) generally runs plug-in-defined code.

+ * </p>

+ * <p>

+ * This interface is not intended to be implemented by clients.

+ * </p>

+ *

+ * @see #getPlugin

+ */

+public interface IPluginDescriptor {

+/**

+ * Returns the extension with the given simple identifier declared in

+ * this plug-in, or <code>null</code> if there is no such extension.

+ * Since an extension might not have an identifier, some extensions

+ * can only be found via the <code>getExtensions</code> method.

+ *

+ * @param extensionName the simple identifier of the extension (e.g. <code>"main"</code>).

+ * @return the extension, or <code>null</code>

+ */

+public IExtension getExtension(String extensionName);

+/**

+ * Returns the extension point with the given simple identifier

+ * declared in this plug-in, or <code>null</code> if there is no such extension point.

+ *

+ * @param extensionPointId the simple identifier of the extension point (e.g. <code>"wizard"</code>).

+ * @return the extension point, or <code>null</code>

+ */

+public IExtensionPoint getExtensionPoint(String extensionPointId);

+/**

+ * Returns all extension points declared by this plug-in.

+ * Returns an empty array if this plug-in does not declare any extension points.

+ *

+ * @return the extension points declared by this plug-in

+ */

+public IExtensionPoint[] getExtensionPoints();

+/**

+ * Returns all extensions declared by this plug-in.

+ * Returns an empty array if this plug-in does not declare any extensions.

+ *

+ * @return the extensions declared by this plug-in

+ */

+public IExtension[] getExtensions();

+/**

+ * Returns the URL of this plug-in's install directory. 

+ * This is the directory containing

+ * the plug-in manifest file, resource bundle, runtime libraries,

+ * and any other files supplied with this plug-in.

+ *

+ * @return the URL of this plug-in's install directory

+ */

+public URL getInstallURL() ;

+/**

+ * Returns a displayable label for this plug-in.

+ * Returns the empty string if no label for this plug-in

+ * is specified in the plug-in manifest file.

+ * <p> Note that any translation specified in the plug-in manifest

+ * file is automatically applied.

+ * </p>

+ *

+ * @return a displayable string label for this plug-in,

+ *    possibly the empty string

+ * @see #getResourceString 

+ */

+public String getLabel();

+/**

+ * Returns the plug-in runtime object corresponding to this

+ * plug-in descriptor. Unlike other methods on this object,

+ * invoking this method may activate the plug-in.

+ * The returned object is an instance of the plug-in runtime class

+ * specified in the plug-in's manifest file;

+ * if a class is not specified there, the returned object

+ * is an internally-supplied one that does not react to life cycle requests.

+ *

+ * @return the plug-in runtime object

+ * @exception CoreException 

+ *   if this plug-in's runtime object could not be created.

+ * @see #isPluginActivated

+ */

+public Plugin getPlugin() throws CoreException;

+/**

+ * Returns the plug-in class loader used to load classes and resources

+ * for this plug-in. The class loader can be used to directly access

+ * plug-in resources and classes. Note that accessing a resource will

+ * <b>not activate</b> the corresponding plug-in. Successfully loading 

+ * a class will <b>always activate</b> the corresponding plug-in.

+ * <p> 

+ * The following examples illustrate the direct use of the plug-in class

+ * loader and its effect on plug-in activation (example ignores error

+ * handling).

+ *

+ * <pre>

+ *     ClassLoader loader = descriptor.getPluginClassLoader();

+ *

+ *     // Load resource by name. Will not activate the plug-in.

+ *     URL res = loader.getResource("com/example/Foo/button.gif");

+ *     InputStream is = loader.getResourceAsStream("splash.jpg");

+ *

+ *     // Load resource for class. Will activate the plug-in because

+ *     // the referenced class is loaded first and triggers activation.

+ *     URL u = com.example.Foo.class.getResource("button.gif");

+ *

+ *     // Load class by name. Will activate the plug-in.

+ *     Class c = loader.loadClass("com.example.Bar");

+ *

+ *     // Load a resource bundle. May, or may not activate the plug-in, depending

+ *     // on the bundle implementation. If implemented as a class, the plug-in

+ *     // will be activated. If implemented as a properties file, the plug-in will

+ *     // not be activated.

+ *     ResourceBundle b = 

+ *         ResourceBundle.getBundle("bundle", Locale.getDefault(), loader);

+ * </pre>

+ *

+ * @return the plug-in class loader

+ * @see IConfigurationElement#createExecutableExtension

+ * @see #isPluginActivated

+ * @see #getResourceBundle

+ */

+public ClassLoader getPluginClassLoader();

+ /**

+ * Returns a list of plug-in prerequisites required

+ * for correct execution of this plug-in.

+ *

+ * @return an array of plug-in prerequisites, or an empty array

+ * if no prerequisites were specified

+ */

+public IPluginPrerequisite[] getPluginPrerequisites() ;

+/**

+ * Returns the name of the provider of this plug-in.

+ * Returns the empty string if no provider name is specified in 

+ * the plug-in manifest file.

+ * <p> Note that any translation specified in the plug-in manifest

+ * file is automatically applied.

+ * </p>

+ *

+ * @see #getResourceString 

+ *

+ * @return the name of the provider, possibly the empty string

+ */

+public String getProviderName();

+/**

+ * Returns this plug-in's resource bundle for the current locale. 

+ * <p>

+ * The bundle is stored as the <code>plugin.properties</code> file 

+ * in the plug-in install directory, and contains any translatable

+ * strings used in the plug-in manifest file (<code>plugin.xml</code>)

+ * along with other resource strings used by the plug-in implementation.

+ * </p>

+ *

+ * @return the resource bundle

+ * @exception MissingResourceException if the resource bundle was not found

+ */

+public ResourceBundle getResourceBundle() throws MissingResourceException;

+/**

+ * Returns a resource string corresponding to the given argument value.

+ * If the argument value specifies a resource key, the string

+ * is looked up in the default resource bundle. If the argument does not

+ * specify a valid key, the argument itself is returned as the

+ * resource string. The key lookup is performed in the

+ * plugin.properties resource bundle. If a resource string 

+ * corresponding to the key is not found in the resource bundle

+ * the key value, or any default text following the key in the

+ * argument value is returned as the resource string.

+ * A key is identified as a string begining with the "%" character.

+ * Note, that the "%" character is stripped off prior to lookup

+ * in the resource bundle.

+ * <p>

+ * Equivalent to <code>getResourceString(value, getBundle())</code>

+ * </p>

+ *

+ * @param value the value

+ * @return the resource string

+ * @see #getResourceBundle

+ */

+public String getResourceString(String value);

+/**

+ * Returns a resource string corresponding to the given argument 

+ * value and bundle.

+ * If the argument value specifies a resource key, the string

+ * is looked up in the given resource bundle. If the argument does not

+ * specify a valid key, the argument itself is returned as the

+ * resource string. The key lookup is performed against the

+ * specified resource bundle. If a resource string 

+ * corresponding to the key is not found in the resource bundle

+ * the key value, or any default text following the key in the

+ * argument value is returned as the resource string.

+ * A key is identified as a string begining with the "%" character.

+ * Note that the "%" character is stripped off prior to lookup

+ * in the resource bundle.

+ * <p>

+ * For example, assume resource bundle plugin.properties contains

+ * name = Project Name

+ * <pre>

+ *     getResourceString("Hello World") returns "Hello World"</li>

+ *     getResourceString("%name") returns "Project Name"</li>

+ *     getResourceString("%name Hello World") returns "Project Name"</li>

+ *     getResourceString("%abcd Hello World") returns "Hello World"</li>

+ *     getResourceString("%abcd") returns "%abcd"</li>

+ *     getResourceString("%%name") returns "%name"</li>

+ * </pre>

+ * </p>

+ *

+ * @param value the value

+ * @param bundle the resource bundle

+ * @return the resource string

+ * @see #getResourceBundle

+ */

+public String getResourceString(String value, ResourceBundle bundle);

+/**

+ * Returns all runtime libraries declared by this plug-in.

+ * Returns an empty array if this plug-in has no runtime libraries.

+ *

+ * @return the runtime libraries declared by this plug-in

+ */

+public ILibrary[] getRuntimeLibraries();

+/**

+ * Returns the unique identifier of this plug-in.

+ * This identifier is a non-empty string and is unique 

+ * within the plug-in registry.

+ *

+ * @return the unique identifier of the plug-in 

+ *		(e.g. <code>"org.eclipse.core.runtime"</code>)

+ */

+public String getUniqueIdentifier();

+/**

+ * Returns the version identifier of this plug-in.

+ *

+ * @return the plug-in version identifier

+ */

+public PluginVersionIdentifier getVersionIdentifier();

+/**

+ * Returns whether the plug-in described by this descriptor

+ * has been activated. Invoking this method will not cause the

+ * plug-in to be activated.

+ *

+ * @return <code>true</code> if this plug-in is activated, and

+ *   <code>false</code> otherwise

+ * @see #getPlugin

+ */

+public boolean isPluginActivated();

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPluginPrerequisite.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPluginPrerequisite.java
new file mode 100644
index 0000000..55fd77b
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPluginPrerequisite.java
@@ -0,0 +1,79 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * A prerequisite entry declared by a plug-in. The declaration causes

+ * classes defined by the prerequisite plug-in to be visible

+ * to the plug-in that declared the dependency.

+ * <p>

+ * This interface is not intended to be implemented by developers.

+ * </p>

+ *

+ * @see IPluginDescriptor#getPluginPrerequisites

+ */

+public interface IPluginPrerequisite {

+/**

+ * Returns the actual version identifier that is used

+ * at runtime to resolve this prerequisite dependency,

+ * or null, if the dependency is not resolved.

+ * 

+ * @return the plug-in version identifier, or null

+ */

+public PluginVersionIdentifier getResolvedVersionIdentifier();

+/**

+ * Returns the plug-in identifier of the prerequisite plug-in.

+ * 

+ * @return the plug-in identifier

+ */

+public String getUniqueIdentifier();

+/**

+ * Returns the version identifier of the prerequisite plug-in,

+ * or <code>null</code> if none.

+ * 

+ * @return the plug-in version identifier, or <code>null</code> if 

+ *    none was specified

+ */

+public PluginVersionIdentifier getVersionIdentifier();

+/**

+ * Indicates whether this prerequisite plug-in is further exposed to any

+ * plug-ins that declare a dependency on this plug-in. This allows

+ * for chaining of dependencies. For example, if plug-in A depends

+ * on plug-in B which depends on plug-in C, the classes from C 

+ * are typically visible to B, but not to A.  A can get around this 

+ * if either B explicitly exports its dependency on C, or 

+ * A explicitly declares C as a prerequisite in addition to B.

+ * 

+ * @return <code>true</code> if this prerequisite plug-in is exposed,

+ *    <code>false</code> otherwise

+ */

+public boolean isExported();

+/**

+ * Indicates that this plug-in prerequisite can be resolved

+ * against a configured plug-in with a compatible identifier.

+ *

+ * @return <code>true</code> if compatible match is allowed,

+ *   <code>false</code> if exact match is required.

+ */

+public boolean isMatchedAsCompatible();

+/**

+ * Indicates that this plug-in prerequisite can only be resolved

+ * against a configured plug-in with exactly the same plug-in 

+ * identifier.

+ *

+ * @return <code>true</code> if only exact identifier match

+ * satisfies this dependency, <code>false</code> if compatible

+ * plug-in will satisfy this dependency.

+ */

+public boolean isMatchedAsExact();

+/**

+ * Indicates whether this plug-in prerequisite is optional.  If a required (i.e., non-optional)

+ * prerequisite is missing, this plugin is disabled.  

+ *

+ * @return <code>true</code> if this prerequisite is optional, <code>false</code> otherwise

+ */

+public boolean isOptional();

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPluginRegistry.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPluginRegistry.java
new file mode 100644
index 0000000..a84ad3d
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IPluginRegistry.java
@@ -0,0 +1,157 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import java.net.URL;

+

+/**

+ * The plug-in registry holds the master list of all

+ * discovered plug-ins, extension points, and extensions.

+ * <p>

+ * The plug-in registry can be queried, by name, for 

+ * plug-ins, extension points, and extensions.

+ * </p>

+ * <p>

+ * This interface is not intended to be implemented by clients.

+ * </p>

+ */

+public interface IPluginRegistry {

+/**

+ * Returns all configuration elements from all extensions configured

+ * into the identified extension point. Returns an empty array if the extension 

+ * point does not exist, has no extensions configured, or none of the extensions 

+ * contain configuration elements.

+ *

+ * @param extensionPointId the unique identifier of the extension point

+ *		(e.g. <code>"org.eclipse.core.resources.builders"</code>)

+ * @return the configuration elements

+ */

+public IConfigurationElement[] getConfigurationElementsFor(String extensionPointId);

+/**

+ * Returns all configuration elements from all extensions configured

+ * into the identified extension point. Returns an empty array if the extension 

+ * point does not exist, has no extensions configured, or none of the extensions 

+ * contain configuration elements.

+ *

+ * @param pluginId the unique identifier of the plug-in 

+ *		(e.g. <code>"org.eclipse.core.resources"</code>)

+ * @param extensionPointName the simple identifier of the 

+ *		extension point (e.g. <code>"builders"</code>)

+ * @return the configuration elements

+ */

+public IConfigurationElement[] getConfigurationElementsFor(String pluginId, String extensionPointName);

+/**

+ * Returns all configuration elements from the identified extension.

+ * Returns an empty array if the extension does not exist or 

+ * contains no configuration elements.

+ *

+ * @param pluginId the unique identifier of the plug-in 

+ *		(e.g. <code>"org.eclipse.core.resources"</code>)

+ * @param extensionPointName the simple identifier of the 

+ *		extension point (e.g. <code>"builders"</code>)

+ * @param extensionId the unique identifier of the extension 

+ *		(e.g. <code>"com.example.acme.coolbuilder</code>)

+ * @return the configuration elements

+ */

+public IConfigurationElement[] getConfigurationElementsFor(String pluginId, String extensionPointName, String extensionId);

+/**

+ * Returns the specified extension in this plug-in registry, 

+ * or <code>null</code> if there is no such extension.

+ * The first parameter identifies the extension point, and the second

+ * parameter identifies an extension plugged in to that extension point.

+ *

+ * @param extensionPointId the unique identifier of the extension point

+ *		(e.g. <code>"org.eclipse.core.resources.builders"</code>)

+ * @param extensionId the unique identifier of the extension 

+ *		(e.g. <code>"com.example.acme.coolbuilder"</code>)

+ * @return the extension, or <code>null</code>

+ */

+public IExtension getExtension(String extensionPointId, String extensionId);

+/**

+ * Returns the specified extension in this plug-in registry, 

+ * or <code>null</code> if there is no such extension.

+ * The first two parameters identify the extension point, and the third

+ * parameter identifies an extension plugged in to that extension point.

+ *

+ * @param pluginId the unique identifier of the plug-in 

+ *		(e.g. <code>"org.eclipse.core.resources"</code>)

+ * @param extensionPointName the simple identifier of the 

+ *		extension point (e.g. <code>"builders"</code>)

+ * @param extensionId the unique identifier of the extension 

+ *		(e.g. <code>"com.example.acme.coolbuilder"</code>)

+ * @return the extension, or <code>null</code>

+ */

+public IExtension getExtension(String pluginId, String extensionPointName, String extensionId);

+/**

+ * Returns the extension point with the given extension point identifier

+ * in this plug-in registry, or <code>null</code> if there is no such

+ * extension point.

+ *

+ * @param extensionPointId the unique identifier of the extension point 

+ *    (e.g., <code>"org.eclipse.core.resources.builders"</code>)

+ * @return the extension point, or <code>null</code>

+ */

+public IExtensionPoint getExtensionPoint(String extensionPointId);

+/**

+ * Returns the extension point in this plug-in registry

+ * with the given plug-in identifier and extension point simple identifier,

+ * or <code>null</code> if there is no such extension point.

+ *

+ * @param pluginId the unique identifier of the plug-in 

+ *		(e.g. <code>"org.eclipse.core.resources"</code>)

+ * @param extensionPointName the simple identifier of the 

+ *		extension point (e.g. <code>" builders"</code>)

+ * @return the extension point, or <code>null</code>

+ */

+public IExtensionPoint getExtensionPoint(String pluginId, String extensionPointName);

+/**

+ * Returns all extension points known to this plug-in registry.

+ * Returns an empty array if there are no extension points.

+ *

+ * @return the extension points known to this plug-in registry

+ */

+public IExtensionPoint[] getExtensionPoints();

+/**

+ * Returns the plug-in descriptor with the given plug-in identifier

+ * in this plug-in registry, or <code>null</code> if there is no such

+ * plug-in.  If there are multiple versions of the identified plug-in,

+ * one will be non-deterministically choosen and returned.  

+ *

+ * @param pluginId the unique identifier of the plug-in 

+ *		(e.g. <code>"com.example.acme"</code>).

+ * @return the plug-in descriptor, or <code>null</code>

+ */

+public IPluginDescriptor getPluginDescriptor(String pluginId);

+/**

+ * Returns the plug-in descriptor with the given plug-in identifier

+ * and version in this plug-in registry, or <code>null</code> if 

+ * there is no such plug-in.

+ *

+ * @param pluginId the unique identifier of the plug-in 

+ *		(e.g. <code>"org.eclipse.core.resources"</code>).

+ * @param version plug-in version identifier

+ * @return the plug-in descriptor, or <code>null</code>

+ */

+public IPluginDescriptor getPluginDescriptor(String pluginId, PluginVersionIdentifier version);

+/**

+ * Returns all plug-in descriptors known to this plug-in registry.

+ * Returns an empty array if there are no installed plug-ins.

+ *

+ * @return the plug-in descriptors known to this plug-in registry

+ */

+public IPluginDescriptor[] getPluginDescriptors();

+/**

+ * Returns all versions of the identified plug-in descriptor

+ * known to this plug-in registry.

+ * Returns an empty array if there are no plug-ins

+ * with the specified identifier.

+ *

+ * @param pluginId the unique identifier of the plug-in 

+ *		(e.g. <code>"org.eclipse.core.resources"</code>).

+ * @return the plug-in descriptors known to this plug-in registry

+ */

+public IPluginDescriptor[] getPluginDescriptors(String pluginId);

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IProgressMonitor.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IProgressMonitor.java
new file mode 100644
index 0000000..467fc36
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IProgressMonitor.java
@@ -0,0 +1,115 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * The <code>IProgressMonitor</code> interface is implemented

+ * by objects that monitor the progress of an activity; the methods

+ * in this interface are invoked by code that performs the activity.

+ * <p>

+ * All activity is broken down into a linear sequence of tasks against

+ * which progress is reported. When a task begins, a <code>beginTask(String, int)

+ * </code> notification is reported, followed by any number and mixture of 

+ * progress reports (<code>worked()</code>) and subtask notifications 

+ * (<code>subTask(String)</code>).  When the task is eventually completed, a 

+ * <code>done()</code> notification is reported.  After the <code>done()</code>

+ * notification, the progress monitor cannot be reused;  i.e., <code>

+ * beginTask(String, int)</code> cannot be called again after the call to 

+ * <code>done()</code>.

+ * </p>

+ * <p>

+ * A request to cancel an operation can be signaled using the 

+ * <code>setCanceled</code> method.  Operations taking a progress

+ * monitor are expected to poll the monitor (using <code>isCanceled</code>)

+ * periodically and abort at their earliest convenience.  Operation can however 

+ * choose to ignore cancelation requests.

+ * </p>

+ * <p>

+ * Since notification is synchronous with the activity itself, the listener should 

+ * provide a fast and robust implementation. If the handling of notifications would 

+ * involve blocking operations, or operations which might throw uncaught exceptions, 

+ * the notifications should be queued, and the actual processing deferred (or perhaps

+ * delegated to a separate thread).

+ * </p>

+ * <p>

+ * Clients may implement this interface.

+ * </p>

+ */

+public interface IProgressMonitor {

+

+	/** Constant indicating an unknown amount of work.

+	 */

+	public final static int UNKNOWN = -1;

+	

+/**

+ * Notifies that the main task is beginning.  This must only be called once

+ * on a given progress monitor instance.

+ * 

+ * @param name the name (or description) of the main task

+ * @param totalWork the total number of work units into which

+ *  the main task is been subdivided. If the value is <code>UNKNOWN</code> 

+ *  the implemenation is free to indicate progress in a way which 

+ *  doesn't require the total number of work units in advance.

+ */

+public void beginTask(String name, int totalWork);

+/**

+ * Notifies that the work is done; that is, either the main task is completed 

+ * or the user canceled it. This method may be called more than once 

+ * (implementations should be prepared to handle this case).

+ */

+public void done();

+/**

+ * Internal method to handle scaling correctly. This method

+ * must not be called by a client. Clients should 

+ * always use the method </code>worked(int)</code>.

+ */

+public void internalWorked(double work);

+/**

+ * Returns whether cancelation of current operation has been requested.

+ * Long-running operations should poll to see if cancelation

+ * has been requested.

+ *

+ * @return <code>true</code> if cancellation has been requested,

+ *    and <code>false</code> otherwise

+ * @see #setCanceled

+ */

+public boolean isCanceled();

+/**

+ * Sets the cancel state to the given value.

+ * 

+ * @param value <code>true</code> indicates that cancelation has

+ *     been requested (but not necessarily acknowledged);

+ *     <code>false</code> clears this flag

+ *

+ * @see #isCanceled

+ */

+public void setCanceled(boolean value);

+/**

+ * Sets the task name to the given value. This method is used to 

+ * restore the task label after a nested operation was executed. 

+ * Normally there is no need for clients to call this method.

+ *

+ * @param name the name (or description) of the main task

+ * @see #beginTask(java.lang.String, int)

+ */

+public void setTaskName(String name);

+/**

+ * Notifies that a subtask of the main task is beginning.

+ * Subtasks are optional; the main task might not have subtasks.

+ *

+ * @param name the name (or description) of the subtask

+ */

+public void subTask(String name);

+/**

+ * Notifies that a given number of work unit of the main task

+ * has been completed. Note that this amount represents an

+ * installment, as opposed to a cumulative amount of work done

+ * to date.

+ *

+ * @param work the number of work units just completed

+ */

+public void worked(int work);

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ISafeRunnable.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ISafeRunnable.java
new file mode 100644
index 0000000..c098b92
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ISafeRunnable.java
@@ -0,0 +1,42 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * Safe runnables represent blocks of code and associated exception

+ * handlers.  They are typically used when a plug-in needs to call some

+ * untrusted code (e.g., code contributed by another plug-in via an

+ * extension).

+* <p>

+ * Clients may implement this interface.

+ * </p>

+ * 

+ * @see Platform#run

+ */

+public interface ISafeRunnable {

+/**

+ * Handles an exception thrown by this runnable's <code>run</code>

+ * method.  The processing done here should be specific to the

+ * particular usecase for this runnable.  Generalized exception

+ * processing (e.g., logging in the platform's log) is done by the

+ * Platform's run mechanism.

+ *

+ * @param exception an exception which occurred during processing

+ *		the body of this runnable (i.e., in <code>run()</code>)

+ * @see Platform#run

+ */

+public void handleException(Throwable exception);

+/**

+ * Runs this runnable.  Any exceptions thrown from this method will

+ * be passed to this runnable's <code>handleException</code>

+ * method.

+ *

+ * @exception Exception if a problem occurred while running this method.

+ *		The exception will be processed by <code>handleException</code>

+ * @see Platform#run

+ */

+public void run() throws Exception;

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IStatus.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IStatus.java
new file mode 100644
index 0000000..8efcd52
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/IStatus.java
@@ -0,0 +1,158 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * A status object represents the outcome of an operation.

+ * All <code>CoreException</code>s carry a status object to indicate 

+ * what went wrong. Status objects are also returned by methods needing 

+ * to provide details of failures (e.g., validation methods).

+ * <p>

+ * A status carries the following information:

+ * <ul>

+ * <li> plug-in identifier (required)</li>

+ * <li> severity (required)</li>

+ * <li> status code (required)</li>

+ * <li> message (required) - localized to current locale</li>

+ * <li> exception (optional) - for problems stemming from a failure at

+ *    a lower level</li>

+ * </ul>

+ * Some status objects, known as multi-statuses, have other status objects 

+ * as children.

+ * </p>

+ * <p>

+ * The class <code>Status</code> is the standard public implementation

+ * of status objects; the subclass <code>MultiStatus</code> is the

+ * implements multi-status objects.

+ * </p>

+ * @see MultiStatus

+ * @see Status

+ */

+public interface IStatus {

+	

+	/** Status severity constant (value 0) indicating this status represents the nominal case.

+	 * This constant is also used as the status code representing the nominal case.

+	 * @see #getSeverity

+	 * @see #isOK

+ 	 */

+	public static final int OK = 0;

+

+	/** Status type severity (bit mask, value 1) indicating this status is informational only.

+	 * @see #getSeverity

+	 * @see #matches

+ 	 */

+	public static final int INFO = 1;

+

+	/** Status type severity (bit mask, value 2) indicating this status represents a warning.

+	 * @see #getSeverity

+	 * @see #matches

+ 	 */

+	public static final int WARNING = 2;

+

+	/** Status type severity (bit mask, value 4) indicating this status represents an error.

+	 * @see #getSeverity

+	 * @see #matches

+ 	 */

+	public static final int ERROR = 4;

+/**

+ * Returns a list of status object immediately contained in this

+ * multi-status, or an empty list if this is not a multi-status.

+ *

+ * @return an array of status objects

+ * @see #isMultiStatus

+ */

+public IStatus[] getChildren();

+/**

+ * Returns the plug-in-specific status code describing the outcome.

+ *

+ * @return plug-in-specific status code

+ */

+public int getCode();

+/**

+ * Returns the relevant low-level exception, or <code>null</code> if none. 

+ * For example, when an operation fails because of a network communications

+ * failure, this might return the <code>java.io.IOException</code>

+ * describing the exact nature of that failure.

+ *

+ * @return the relevant low-level exception, or <code>null</code> if none

+ */

+public Throwable getException();

+/**

+ * Returns the message describing the outcome.

+ * The message is localized to the current locale.

+ *

+ * @return a localized message

+ */

+public String getMessage();

+/**

+ * Returns the unique identifier of the plug-in associated with this status

+ * (this is the plug-in that defines the meaning of the status code).

+ *

+ * @return the unique identifier of the relevant plug-in

+ */

+public String getPlugin();

+/**

+ * Returns the severity. The severities are as follows (in

+ * descending order):

+ * <ul>

+ * <li><code>ERROR</code> - a serious error (most severe)</li>

+ * <li><code>WARNING</code> - a warning (less severe)</li>

+ * <li><code>INFO</code> - an informational ("fyi") message (least severe)</li>

+ * <li><code>OK</code> - everything is just fine</li>

+ * </ul>

+ * <p>

+ * The severity of a multi-status is defined to be the maximum

+ * severity of any of its children, or <code>OK</code> if it has

+ * no children.

+ * </p>

+ *

+ * @return the severity: one of <code>OK</code>,

+ *   <code>ERROR</code>, <code>INFO</code>, or <code>WARNING</code>

+ * @see #matches

+ */

+public int getSeverity();

+/**

+ * Returns whether this status is a multi-status.

+ * A multi-status describes the outcome of an operation

+ * involving multiple operands.

+ * <p>

+ * The severity of a multi-status is derived from the severities

+ * of its children; a multi-status with no children is

+ * <code>OK</code> by definition.

+ * A multi-status carries a plug-in identifier, a status code,

+ * a message, and an optional exception. Clients may treat

+ * multi-status objects in a multi-status unaware way.

+ * </p>

+ *

+ * @return <code>true</code> for a multi-status, 

+ *    <code>false</code> otherwise

+ * @see #getChildren

+ */

+public boolean isMultiStatus();

+/**

+ * Returns whether this status indicates everything is okay

+ * (neither info, warning, nor error).

+ *

+ * @return <code>true</code> if this status has severity

+ *    <code>OK</code>, and <code>false</code> otherwise

+ */

+public boolean isOK();

+/**

+ * Returns whether the severity of this status matches the given

+ * specification.

+ *

+ * @param severityMask a mask formed by bitwise or'ing severity mask

+ *    constants (<code>ERROR</code>, <code>WARNING</code>,

+ *    <code>INFO</code>)

+ * @return <code>true</code> if there is at least one match, 

+ *    <code>false</code> if there are no matches

+ * @see #getSeverity

+ * @see #ERROR

+ * @see #WARNING

+ * @see #INFO

+ */

+public boolean matches(int severityMask);

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/MultiStatus.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/MultiStatus.java
new file mode 100644
index 0000000..d671d10
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/MultiStatus.java
@@ -0,0 +1,129 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.internal.runtime.Assert;

+

+/**

+ * A concrete multi-status implementation, 

+ * suitable either for instantiating or subclassing.

+ */

+public class MultiStatus extends Status {

+

+	/** List of child statuses.

+	 */

+	private IStatus[] children;

+/**

+ * Creates and returns a new multi-status object with the given children.

+ *

+ * @param pluginId the unique identifier of the relevant plug-in

+ * @param code the plug-in-specific status code

+ * @param children the list of children status objects

+ * @param message a human-readable message, localized to the

+ *    current locale

+ * @param exception a low-level exception, or <code>null</code> if not

+ *    applicable 

+ */

+public MultiStatus(String pluginId, int code, IStatus[] children, String message, Throwable exception) {

+	this(pluginId, code, message, exception);

+	Assert.isLegal(children != null);

+	for (int i = 0; i < children.length; i++) {

+		Assert.isLegal(children[i] != null);

+		add(children[i]);

+	}

+}

+/**

+ * Creates and returns a new multi-status object with no children.

+ *

+ * @param pluginId the unique identifier of the relevant plug-in

+ * @param code the plug-in-specific status code

+ * @param message a human-readable message, localized to the

+ *    current locale

+ * @param exception a low-level exception, or <code>null</code> if not

+ *    applicable 

+ */

+public MultiStatus(String pluginId, int code, String message, Throwable exception) {

+	super(OK, pluginId, code, message, exception);

+	children = new IStatus[0];

+}

+/**

+ * Adds the given status to this multi-status.

+ *

+ * @param status the new child status

+ */

+public void add(IStatus status) {

+	Assert.isLegal(status != null);

+	IStatus[] result = new IStatus[children.length + 1];

+	System.arraycopy(children, 0, result, 0, children.length);

+	result[result.length - 1] = status;

+	children = result;

+	int newSev = status.getSeverity();

+	if (newSev > getSeverity()) {

+		setSeverity(newSev);

+	}

+}

+/**

+ * Adds all of the children of the given status to this multi-status.

+ * Does nothing if the given status has no children (which includes

+ * the case where it is not a multi-status).

+ *

+ * @param status the status whose children are to be added to this one

+ */

+public void addAll(IStatus status) {

+	Assert.isLegal(status != null);

+	IStatus[] statuses = status.getChildren();

+	for (int i = 0; i < statuses.length; i++) {

+		add(statuses[i]);

+	}

+}

+/* (Intentionally not javadoc'd)

+ * Implements the corresponding method on <code>IStatus</code>.

+ */

+public IStatus[] getChildren() {

+	return children;

+}

+/* (Intentionally not javadoc'd)

+ * Implements the corresponding method on <code>IStatus</code>.

+ */

+public boolean isMultiStatus() {

+	return true;

+}

+/**

+ * Merges the given status into this multi-status.

+ * Equivalent to <code>add(status)</code> if the

+ * given status is not a multi-status. 

+ * Equivalent to <code>addAll(status)</code> if the

+ * given status is a multi-status. 

+ *

+ * @param status the status to merge into this one

+ * @see #add

+ * @see #addAll

+ */

+public void merge(IStatus status) {

+	Assert.isLegal(status != null);

+	if (!status.isMultiStatus()) {

+		add(status);

+	} else {

+		addAll(status);

+	}

+}

+/**

+ * Returns a string representation of the status, suitable 

+ * for debugging purposes only.

+ */

+public String toString() {

+	StringBuffer buf = new StringBuffer(super.toString());

+	buf.append(" children=[");

+	for (int i = 0; i < children.length; i++) {

+		if (i != 0) {

+			buf.append(" ");

+		}

+		buf.append(children[i].toString());

+	}

+	buf.append("]");

+	return buf.toString();

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/NullProgressMonitor.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/NullProgressMonitor.java
new file mode 100644
index 0000000..4f140f1
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/NullProgressMonitor.java
@@ -0,0 +1,103 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * A default progress monitor implementation suitable for

+ * subclassing.

+ * <p>

+ * This implementation supports cancelation. The default

+ * implementations of the other methods do nothing.

+ * </p>

+ */

+public class NullProgressMonitor implements IProgressMonitor {

+

+	/**

+	 * Indicates whether cancel has been requested.

+	 */

+	private boolean cancelled = false;

+/**

+ * Constructs a new progress monitor.

+ */

+public NullProgressMonitor() {

+}

+/**

+ * This implementation does nothing. 

+ * Subclasses may override this method to do interesting

+ * processing when a task begins.

+ * 

+ * @see IProgressMonitor#beginTask

+ */

+public void beginTask(String name, int totalWork) {

+}

+/**

+ * This implementation does nothing.

+ * Subclasses may override this method to do interesting

+ * processing when a task is done.

+ * 

+ * @see IProgressMonitor#done

+ */

+public void done() {

+}

+/**

+ * This implementation does nothing.

+ * Subclasses may override this method.

+ * 

+ * @see IProgressMonitor#internalWorked

+ */

+public void internalWorked(double work) {

+}

+/**

+ * This implementation returns the value of the internal 

+ * state variable set by <code>setCanceled</code>.

+ * Subclasses which override this method should

+ * override <code>setCanceled</code> as well.

+ *

+ * @see IProgressMonitor#isCanceled

+ * @see IProgressMonitor#setCanceled

+ */

+public boolean isCanceled() {

+	return cancelled;

+}

+/**

+ * This implementation sets the value of an internal state variable.

+ * Subclasses which override this method should override 

+ * <code>isCanceled</code> as well.

+ *

+ * @see IProgressMonitor#isCanceled

+ * @see IProgressMonitor#setCanceled

+ */

+public void setCanceled(boolean cancelled) {

+	this.cancelled = cancelled;

+}

+/**

+ * This implementation does nothing.

+ * Subclasses may override this method to do something

+ * with the name of the task.

+ * 

+ * @see IProgressMonitor#setTaskName

+ */

+public void setTaskName(String name) {

+}

+/**

+ * This implementation does nothing.

+ * Subclasses may override this method to do interesting

+ * processing when a subtask begins.

+ * 

+ * @see IProgressMonitor#subTask

+ */

+public void subTask(String name) {

+}

+/**

+ * This implementation does nothing.

+ * Subclasses may override this method to do interesting

+ * processing when some work has been completed.

+ * 

+ * @see IProgressMonitor#worked

+ */

+public void worked(int work) {

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/OperationCanceledException.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/OperationCanceledException.java
new file mode 100644
index 0000000..1a7dc9e
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/OperationCanceledException.java
@@ -0,0 +1,25 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * This exception is thrown to blow out of a long-running method 

+ * when the user cancels it.

+ */

+public final class OperationCanceledException extends RuntimeException {

+/**

+ * Creates a new exception.

+ */

+public OperationCanceledException() {

+	super();

+}

+/**

+ * Creates a new exception with the given message.

+ */

+public OperationCanceledException(String message) {

+	super(message);

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Path.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Path.java
new file mode 100644
index 0000000..6b5f799
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Path.java
@@ -0,0 +1,827 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+import org.eclipse.core.internal.runtime.Assert;

+import java.util.*;

+import java.io.File;

+

+/** 

+ * The standard implementation of the <code>IPath</code> interface.

+ * Paths are always maintained in canonicalized form.  That is, parent

+ * references (i.e., <code>../../</code>) and duplicate separators are 

+ * resolved.  For example,

+ * <pre>     new Path("/a/b").append("../foo/bar")</pre>

+ * will yield the path

+ * <pre>     /a/foo/bar</pre>

+ * <p>

+ * This class is not intended to be subclassed by clients but

+ * may be instantiated.

+ * </p>

+ * @see IPath

+ */

+public class Path implements IPath, Cloneable {

+	

+	/** The path segments */

+	private String[] segments;

+

+	/** The device id string. May be null if there is no device. */

+	private String device = null;

+	

+	/** flags indicating separators (has leading, is UNC, has trailing) */

+	private int separators;

+	

+	/** masks for separator values */

+	private static final int HAS_LEADING = 1;

+	private static final int IS_UNC = 2;

+	private static final int HAS_TRAILING = 4;

+	

+	/** Constant value indicating no segments */

+	private static final String[] NO_SEGMENTS = new String[0];

+

+	/** Constant root path string (<code>"/"</code>). */

+	private static final String ROOT_STRING = "/";

+

+	/** Constant value containing the root path with no device. */

+	public static final Path ROOT = new Path(ROOT_STRING);

+

+	/** Constant empty string value. */

+	private static final String EMPTY_STRING = "";

+

+	/** Constant value containing the empty path with no device. */

+	public static final Path EMPTY = new Path(EMPTY_STRING);

+

+	//Private implementation note: the segments and separators 

+	//arrays are never modified, so that they can be shared between 

+	//path instances

+	

+/* (Intentionally not included in javadoc)

+ * Private constructor.

+ */

+private Path() {

+	super();

+}

+/* (Intentionally not included in javadoc)

+ * Private constructor.

+ */

+private Path(String device, String[] segments, int separators) {

+	this.segments = segments;

+	this.device = device;

+	this.separators = separators;

+}

+

+/** 

+ * Constructs a new path from the given string path.

+ * The given string path must be valid.

+ * The path is canonicalized and double slashes are removed

+ * except at the beginning. (to handle UNC paths) All backslashes ('\')

+ * are replaced with forward slashes. ('/')

+ *

+ * @param fullPath the string path

+ * @see #isValidPath

+ */

+public Path(String fullPath) {

+	super();

+	initialize(null, fullPath);

+}

+/** 

+ * Constructs a new path from the given device id and string path.

+ * The given string path must be valid.

+ * The path is canonicalized and double slashes are removed except

+ * at the beginning (to handle UNC paths). All backslashes ('\')

+ * are replaced with forward slashes. ('/')

+ *

+ * @param device the device id

+ * @param path the string path

+ * @see #isValidPath

+ * @see #setDevice

+ */

+public Path(String device, String path) {

+	super();

+	initialize(device, path);

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#addFileExtension

+ */

+public IPath addFileExtension(String extension) {

+	if (isRoot() || isEmpty() || hasTrailingSeparator())

+		return this;

+	int len = segments.length;

+	String[] newSegments = new String[len];

+	System.arraycopy(segments, 0, newSegments, 0, len-1);

+	newSegments[len-1] = segments[len-1] + "." + extension;

+	return new Path(device, newSegments, separators);

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#addTrailingSeparator

+ */

+public IPath addTrailingSeparator() {

+	if (hasTrailingSeparator() || isRoot()) {

+		return this;

+	}

+	//XXX workaround, see 1GIGQ9V

+	if (isEmpty()) {

+		return new Path(device, segments, HAS_LEADING);

+	}

+	return new Path(device, segments, separators | HAS_TRAILING);

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#append(java.lang.String)

+ */

+public IPath append(String tail) {

+	//optimize addition of a single segment

+	if (tail.indexOf(SEPARATOR) == -1) {

+		int tailLength = tail.length();

+		if (tailLength < 3) {

+			//some special cases

+			if (tailLength == 0 || ".".equals(tail)) {

+				return this;

+			}

+			if ("..".equals(tail))

+				return removeLastSegments(1);

+		}

+		//just add the segment

+		int myLen = segments.length;

+		String[] newSegments = new String[myLen+1];

+		System.arraycopy(segments, 0, newSegments, 0, myLen);

+		newSegments[myLen] = tail;

+		return new Path(device, newSegments, separators);

+	}

+	//go with easy implementation for now

+	return append(new Path(tail));

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#append(IPath)

+ */

+public IPath append(IPath tail) {

+	//optimize some easy cases

+	if (tail == null || tail.isEmpty() || tail.isRoot())

+		return this;

+	if (this.isEmpty())

+		return tail.makeRelative();

+	if (this.isRoot())

+		return tail.makeAbsolute();

+	

+	//concatenate the two segment arrays

+	int myLen = segments.length;

+	int tailLen = tail.segmentCount();

+	String[] newSegments = new String[myLen+tailLen];

+	System.arraycopy(segments, 0, newSegments, 0, myLen);

+	for (int i = 0; i < tailLen; i++) {

+		newSegments[myLen+i] = tail.segment(i);

+	}

+	//use my leading separators and the tail's trailing separator

+	Path result = new Path(device, newSegments, 

+		(separators & (HAS_LEADING | IS_UNC)) | (tail.hasTrailingSeparator() ? HAS_TRAILING : 0));

+	String tailFirstSegment = newSegments[myLen];

+	if (tailFirstSegment.equals("..") || tailFirstSegment.equals(".")) {

+		result.canonicalize();

+	}

+	return result;

+}

+/**

+ * Destructively converts this path to its canonical form.

+ * <p>

+ * In its canonical form, a path does not have any

+ * "." segments, and parent references ("..") are collapsed

+ * where possible.

+ * </p>

+ * @return the canonicalized path

+ */

+private void canonicalize() {

+	//look for segments that need canonicalizing

+	for (int i = 0, max = segments.length; i < max; i++) {

+		String segment = segments[i];

+		if (segment.charAt(0) == '.' && (segment.equals("..") || segment.equals("."))) {

+			//path needs to be canonicalized

+			collapseParentReferences();

+			return;

+		}

+	}

+}

+/* (Intentionally not included in javadoc)

+ * Clones this object.

+ */

+public Object clone() {

+	try {

+		return super.clone();

+	} catch (CloneNotSupportedException e) {

+		return null;

+	}

+}

+/**

+ * Destructively removes all occurrences of ".." segments from this path.

+ */

+private void collapseParentReferences() {

+	int segmentCount = segments.length;

+	String[] stack = new String[segmentCount];

+	int stackPointer = 0;

+	for (int i = 0; i < segmentCount; i++) {

+		String segment = segments[i];

+		if (segment.equals("..")) {

+			if (stackPointer==0) {

+				// if the stack is empty we are going out of our scope 

+				// so we need to accumulate segments.  But only if the original

+				// path is relative.  If it is absolute then we can't go any higher than

+				// root so simply toss the .. references.

+				if (!isAbsolute())					

+					stack[stackPointer++] = segment;//stack push

+			} else {

+				// if the top is '..' then we are accumulating segments so don't pop

+				if ("..".equals(stack[stackPointer-1]))

+					stack[stackPointer++] = "..";

+				else

+					stackPointer--;//stack pop

+			}

+			//collapse current references

+		} else

+			if (!segment.equals(".") || (i == 0 && !isAbsolute()))

+				stack[stackPointer++] = segment;//stack push

+	}

+	//if the number of segments hasn't changed, then no modification needed

+	if (stackPointer== segmentCount)

+		return;

+	//build the new segment array backwards by popping the stack

+	String[] newSegments = new String[stackPointer];

+	System.arraycopy(stack, 0, newSegments, 0, stackPointer);

+	this.segments = newSegments;

+}

+/**

+ * Removes duplicate slashes from the given path, with the exception

+ * of leading double slash which represents a UNC path.

+ */

+private String collapseSlashes(String path) {

+	int length = path.length();

+	// if the path is only 0, 1 or 2 chars long then it could not possibly have illegal

+	// duplicate slashes.

+	if (length < 3)

+		return path;

+	// check for an occurence of // in the path.  Start at index 1 to ensure we skip leading UNC //

+	// If there are no // then there is nothing to collapse so just return.

+	if (path.indexOf("//", 1) == -1)

+		return path;

+	// We found an occurence of // in the path so do the slow collapse.

+	char[] result = new char[path.length()];

+	int count = 0;

+	boolean hasPrevious = false;

+	char[] characters = path.toCharArray();

+	for (int index = 0; index < characters.length; index++) {

+		char c = characters[index];

+		if (c == SEPARATOR) {

+			if (hasPrevious) {

+				// skip double slashes, except for beginning of UNC.

+				// note that a UNC path can't have a device.

+				if (device == null && index == 1) {

+					result[count] = c;

+					count++;

+				}

+			} else {

+				hasPrevious = true;

+				result[count] = c;

+				count++;

+			}

+		} else {

+			hasPrevious = false;

+			result[count] = c;

+			count++;

+		}

+	}

+	return new String(result, 0, count);

+}

+/* (Intentionally not included in javadoc)

+ * Returns the size of the string that will be created by toString or toOSString.

+ */

+private int computeLength() {

+	int length = 0;

+	if (device != null)

+		length += device.length();

+	if ((separators & HAS_LEADING) != 0) 

+		length ++;

+	if ((separators & IS_UNC) != 0)

+		length++;

+	//add the segment lengths

+	int max = segments.length;

+	if (max > 0) {

+		for (int i = 0; i < max; i++) {

+			length += segments[i].length();

+		}

+		//add the separator lengths

+		length += max-1;

+	}

+	if ((separators & HAS_TRAILING) != 0) 

+		length++;

+	return length;

+}

+/* (Intentionally not included in javadoc)

+ * Returns the number of segments in the given path

+ */

+private int computeSegmentCount(String path) {

+	int len = path.length();

+	if (len == 0 || (len == 1 && path.charAt(0) == SEPARATOR)) {

+		return 0;

+	}

+	int count = 1;

+	int prev = -1;

+	int i;

+	while ((i = path.indexOf(SEPARATOR, prev + 1)) != -1) {

+		if (i != prev + 1 && i != len) {

+			++count;

+		}

+		prev = i;

+	}

+	if (path.charAt(len - 1) == SEPARATOR) {

+		--count;

+	}

+	return count;

+}

+/**

+ * Computes the segment array for the given canonicalized path.

+ */

+private String[] computeSegments(String path) {

+	// performance sensitive --- avoid creating garbage

+	int segmentCount = computeSegmentCount(path);

+	String[] newSegments = new String[segmentCount];

+	if (segmentCount == 0) {

+		return NO_SEGMENTS;

+	}

+	int len = path.length();

+	// check for initial slash

+	int firstPosition = (path.charAt(0) == SEPARATOR) ? 1 : 0;

+	// check for UNC

+	if (firstPosition == 1 && isUNC())

+		firstPosition = 2;

+	int lastPosition = (path.charAt(len - 1) != SEPARATOR) ? len - 1 : len - 2;

+	// for non-empty paths, the number of segments is 

+	// the number of slashes plus 1, ignoring any leading

+	// and trailing slashes

+	int next = firstPosition;

+	for (int i = 0; i < segmentCount; i++) {

+		int start = next;

+		int end = path.indexOf(SEPARATOR, next);

+		if (end == -1) {

+			newSegments[i] = path.substring(start, lastPosition + 1);

+		} else {

+			newSegments[i] = path.substring(start, end);

+		}

+		next = end + 1;

+	}

+	return newSegments;

+}

+/* (Intentionally not included in javadoc)

+ * Compares objects for equality.

+ */

+public boolean equals(Object obj) {

+	if (this == obj) {

+		return true;

+	}

+	if (!(obj instanceof Path)) {

+		return false;

+	}

+	Path target = (Path)obj;

+	//check leading separators

+	int mask = HAS_LEADING | IS_UNC;

+	if ((separators & mask) != (target.separators & mask)) {

+		return false;

+	}

+	//check segment count

+	int segmentCount = segments.length;

+	if (segmentCount != target.segmentCount()) {

+		return false;

+	}

+	//check device

+	if (device == null) {

+		if (target.device != null) {

+			return false;

+		}

+	} else {

+		if (!device.equals(target.device)) {

+			return false;

+		}

+	}

+	//check segments

+	for (int i = 0; i < segmentCount; i++) {

+		if (!segments[i].equals(target.segment(i))) {

+			return false;

+		}

+	}

+	//they're the same!

+	return true;

+}

+

+/* (Intentionally not included in javadoc)

+ * @see IPath#getDevice

+ */

+public String getDevice() {

+	return device;

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#getFileExtension

+ */

+public String getFileExtension() {

+	if (hasTrailingSeparator()) {

+		return null;

+	}

+	String lastSegment = lastSegment();

+	if (lastSegment == null) {

+		return null;

+	}

+	int index = lastSegment.lastIndexOf(".");

+	if (index == -1) {

+		return null;

+	}

+	return lastSegment.substring(index + 1);

+}

+/* (Intentionally not included in javadoc)

+ * Computes the hash code for this object.

+ */

+public int hashCode() {

+	int hash = device == null ? 0 : device.hashCode();

+	int segmentCount = segments.length;

+	for (int i = 0; i < segmentCount; i++) {

+		hash += segments[i].hashCode();

+	}

+	return hash;

+}

+

+/* (Intentionally not included in javadoc)

+ * @see IPath#hasTrailingSeparator

+ */

+public boolean hasTrailingSeparator() {

+	return (separators & HAS_TRAILING) != 0;

+}

+/*

+ * Initialize the current path with the given string.

+ */

+private void initialize(String device, String fullPath) {

+	Assert.isNotNull(fullPath);

+	this.device = device;

+

+	String path = fullPath.replace('\\', SEPARATOR);

+	int i = path.indexOf(DEVICE_SEPARATOR);

+	if (i != -1) {

+		// if the specified device is null then set it to

+		// be whatever is defined in the path string

+		if (device == null)

+			this.device = path.substring(0, i + 1);

+		path = path.substring(i + 1, path.length());

+	}

+	path = collapseSlashes(path);

+

+	//compute the separators array

+	if (path.length() < 2) {

+		if (path.length() == 1 && path.charAt(0) == SEPARATOR) {

+			this.separators = HAS_LEADING;

+		} else {

+			this.separators = 0;

+		}

+	} else {

+		boolean hasLeading = path.charAt(0) == SEPARATOR;

+		boolean isUNC = hasLeading && path.charAt(1) == SEPARATOR;

+		//UNC path of length two has no trailing separator

+		boolean hasTrailing = !(isUNC && path.length() == 2) && path.charAt(path.length()-1) == SEPARATOR;

+		separators = hasLeading ? HAS_LEADING : 0;

+		if (isUNC) separators |= IS_UNC;

+		if (hasTrailing) separators |= HAS_TRAILING;

+	}

+	//compute segments and ensure canonical form

+	segments = computeSegments(path);

+	canonicalize();

+

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#isAbsolute

+ */

+public boolean isAbsolute() {

+	//it's absolute if it has a leading separator

+	return (separators & HAS_LEADING) != 0;

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#isEmpty

+ */

+public boolean isEmpty() {

+	//true if no segments and no leading prefix

+	return segments.length == 0 && ((separators & HAS_LEADING) == 0);

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#isPrefixOf

+ */

+public boolean isPrefixOf(IPath anotherPath) {

+	Assert.isNotNull(anotherPath);

+	if (device == null) {

+		if (anotherPath.getDevice() != null) {

+			return false;

+		}

+	} else {

+		if (!device.equalsIgnoreCase(anotherPath.getDevice())) {

+			return false;

+		}

+	}

+	if (isEmpty() || (isRoot() && anotherPath.isAbsolute())) {

+		return true;

+	}

+	int len = segments.length;

+	if (len > anotherPath.segmentCount()) {

+		return false;

+	}

+	for (int i = 0; i < len; i++) {

+		if (!segments[i].equals(anotherPath.segment(i)))

+			return false;

+	}

+	return true;

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#isRoot

+ */

+public boolean isRoot() {

+	//must have no segments, a leading separator, and not be a UNC path.

+	return this == ROOT || (segments.length == 0 && isAbsolute() && ((separators & IS_UNC) == 0));

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#isUNC

+ */

+public boolean isUNC() {

+	if (device != null) 

+		return false;

+	return (separators & IS_UNC) != 0;

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#isValidPath

+ */

+public boolean isValidPath(String path) {

+	// We allow "//" at the beginning for UNC paths

+	if (path.indexOf("//") > 0) {

+		return false;

+	}

+	Path test = new Path(path);

+	int segmentCount = test.segmentCount();

+	for (int i = 0; i < segmentCount; i++) {

+		if (!test.isValidSegment(test.segment(i))) {

+			return false;

+		}

+	}

+	return true;

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#isValidSegment

+ */

+public boolean isValidSegment(String segment) {

+	int size = segment.length();

+	if (size == 0) {

+		return false;

+	}

+	if (Character.isWhitespace(segment.charAt(0)) || Character.isWhitespace(segment.charAt(size - 1))) {

+		return false;

+	}

+	for (int i = 0; i < size; i++) {

+		char c = segment.charAt(i);

+		if (c == '/' || c == '\\' || c == ':') {

+			return false;

+		}

+	}

+	return true;

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#lastSegment

+ */

+public String lastSegment() {

+	int len = segments.length;

+	return len == 0 ? null : segments[len-1];

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#makeAbsolute

+ */

+public IPath makeAbsolute() {

+	if (isAbsolute()) {

+		return this;

+	}

+	Path result = new Path(device, segments, separators | HAS_LEADING);

+	//may need canonicalizing if it has leading ".." or "." segments

+	if (result.segmentCount() > 0) {

+		String first = result.segment(0);

+		if (first.equals("..") || first.equals(".")) {

+			result.canonicalize();

+		}

+	}

+	return result;

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#makeRelative

+ */

+public IPath makeRelative() {

+	if (!isAbsolute()) {

+		return this;

+	}

+	return new Path(device, segments, separators & HAS_TRAILING);

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#makeUNC

+ */

+public IPath makeUNC(boolean toUNC) {

+	// if we are already in the right form then just return

+	if (!(toUNC ^ isUNC()))

+		return this;

+

+	int newSeparators = this.separators;

+	if (toUNC) {

+		newSeparators |= HAS_LEADING | IS_UNC;

+	} else {

+		//mask out the UNC bit

+		newSeparators &= HAS_LEADING | HAS_TRAILING;

+	}

+	return new Path(toUNC ? null : device, segments, newSeparators);

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#matchingFirstSegments

+ */

+public int matchingFirstSegments(IPath anotherPath) {

+	Assert.isNotNull(anotherPath);

+	String[] argument = anotherPath.segments();

+	int max = Math.min(segments.length, argument.length);

+	int count = 0;

+	for (int i = 0; i < max; i++) {

+		if (!segments[i].equals(argument[i])) {

+			return count;

+		}

+		count++;

+	}

+	return count;

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#removeFileExtension

+ */

+public IPath removeFileExtension() {

+	String extension = getFileExtension();

+	if (extension == null || extension.equals("")) {

+		return this;

+	}

+	String lastSegment = lastSegment();

+	int index = lastSegment.lastIndexOf(extension) - 1;

+	return removeLastSegments(1).append(lastSegment.substring(0, index));

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#removeFirstSegments

+ */

+public IPath removeFirstSegments(int count) {

+	if (count == 0)

+		return this;

+	if (count >= segments.length) {

+		return new Path(device, NO_SEGMENTS, 0);

+	}

+	Assert.isLegal(count > 0);

+	int newSize = segments.length - count;

+	String[] newSegments = new String[newSize];

+	System.arraycopy(this.segments, count, newSegments, 0, newSize);

+

+	//result is always a relative path

+	return new Path(device, newSegments, separators & HAS_TRAILING);

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#removeLastSegments

+ */

+public IPath removeLastSegments(int count) {

+	if (count == 0)

+		return this;

+	if (count >= segments.length) {

+		return new Path(device, NO_SEGMENTS, separators);

+	}

+	Assert.isLegal(count > 0);

+	int newSize = segments.length - count;

+	String[] newSegments = new String[newSize];

+	System.arraycopy(this.segments, 0, newSegments,0, newSize);

+	return new Path(device, newSegments, separators);

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#removeTrailingSeparator

+ */

+public IPath removeTrailingSeparator() {

+	if (!hasTrailingSeparator()) {

+		return this;

+	}

+	return new Path(device, segments, separators & (HAS_LEADING | IS_UNC));

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#segment

+ */

+public String segment(int index) {

+	if (index >= segments.length)

+		return null;

+	return segments[index];

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#segmentCount

+ */

+public int segmentCount() {

+	return segments.length;

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#segments

+ */

+public String[] segments() {

+	return (String[])segments.clone();

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#setDevice

+ */

+public IPath setDevice(String value) {

+	if (value != null) {

+		Assert.isTrue(value.indexOf(IPath.DEVICE_SEPARATOR) == (value.length() - 1), "Last character should be the device separator");

+	}

+	return new Path(value, segments, separators);

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#toFile

+ */

+public File toFile() {

+	return new File(toOSString());

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#toOSString

+ */

+public String toOSString() {

+	//Note that this method is identical to toString except

+	//it uses the OS file separator instead of the path separator

+	int resultSize = computeLength();

+	if (resultSize <= 0)

+		return EMPTY_STRING;

+	char FILE_SEPARATOR = File.separatorChar;

+	char[] result = new char[resultSize];

+	int offset = 0;

+	if (device != null) {

+		int size = device.length();

+		device.getChars(0, size, result, offset);

+		offset += size;

+	}

+	if ((separators & HAS_LEADING) != 0) 

+		result[offset++] = FILE_SEPARATOR;

+	if ((separators & IS_UNC) != 0)

+		result[offset++] = FILE_SEPARATOR;

+	int len = segments.length-1;

+	if (len>=0) {

+		//append all but the last segment, with separators

+		for (int i = 0; i < len; i++) {

+			int size = segments[i].length();

+			segments[i].getChars(0, size, result, offset);

+			offset += size;

+			result[offset++] = FILE_SEPARATOR;

+		}

+		//append the last segment

+		int size = segments[len].length();

+		segments[len].getChars(0, size, result, offset);

+		offset += size;

+	}

+	if ((separators & HAS_TRAILING) != 0) 

+		result[offset++] = FILE_SEPARATOR;

+	return new String(result);

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#toString

+ */

+public String toString() {

+	int resultSize = computeLength();

+	if (resultSize <= 0)

+		return EMPTY_STRING;

+	char[] result = new char[resultSize];

+	int offset = 0;

+	if (device != null) {

+		int size = device.length();

+		device.getChars(0, size, result, offset);

+		offset += size;

+	}

+	if ((separators & HAS_LEADING) != 0) 

+		result[offset++] = SEPARATOR;

+	if ((separators & IS_UNC) != 0)

+		result[offset++] = SEPARATOR;

+	int len = segments.length-1;

+	if (len>=0) {

+		//append all but the last segment, with separators

+		for (int i = 0; i < len; i++) {

+			int size = segments[i].length();

+			segments[i].getChars(0, size, result, offset);

+			offset += size;

+			result[offset++] = SEPARATOR;

+		}

+		//append the last segment

+		int size = segments[len].length();

+		segments[len].getChars(0, size, result, offset);

+		offset += size;

+	}

+	if ((separators & HAS_TRAILING) != 0) 

+		result[offset++] = SEPARATOR;

+	return new String(result);

+}

+/* (Intentionally not included in javadoc)

+ * @see IPath#uptoSegment

+ */

+public IPath uptoSegment(int count) {

+	if (count == 0)

+		return Path.EMPTY;

+	if (count >= segments.length)

+		return this;

+	Assert.isTrue(count > 0, "Invalid parameter to Path.uptoSegment");

+	String[] newSegments = new String[count];

+	System.arraycopy(segments, 0, newSegments, 0, count);

+	return new Path(device, newSegments, separators);

+}

+}
\ No newline at end of file
diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Platform.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Platform.java
new file mode 100644
index 0000000..e943e78
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Platform.java
@@ -0,0 +1,397 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.boot.*;

+import org.eclipse.core.runtime.model.Factory;

+import org.eclipse.core.runtime.model.PluginRegistryModel;

+import org.eclipse.core.internal.plugins.PluginClassLoader;

+import org.eclipse.core.internal.plugins.PluginDescriptor;

+import org.eclipse.core.internal.runtime.*;

+import java.io.IOException;

+import java.lang.reflect.Constructor;

+import java.net.URL;

+import java.net.URLConnection;

+import java.util.Map;

+

+/**

+ * The central class of the Eclipse Platform Runtime. This class cannot

+ * be instantiated or subclassed by clients; all functionality is provided 

+ * by static methods.  Features include:

+ * <ul>

+ * <li>the platform registry of installed plug-ins</li>

+ * <li>the platform adapter manager</li>

+ * <li>the platform log</li>

+ * <li>the authorization info management</li>

+ * </ul>

+ * <p>

+ * The platform is in one of two states, running or not running, at all

+ * times. The only ways to start the platform running, or to shut it down,

+ * are on the bootstrap <code>BootLoader</code> class. Code in plug-ins will

+ * only observe the platform in the running state. The platform cannot

+ * be shutdown from inside (code in plug-ins have no access to

+ * <code>BootLoader</code>).

+ * </p>

+ */

+public final class Platform {

+	/**

+	 * The unique identifier constant (value "<code>org.eclipse.core.runtime</code>")

+	 * of the Core Runtime (pseudo-) plug-in.

+	 */

+	public static final String PI_RUNTIME = "org.eclipse.core.runtime";

+

+	/** 

+	 * The simple identifier constant (value "<code>applications</code>") of

+	 * the extension point of the Core Runtime plug-in where plug-ins declare

+	 * the existence of runnable applications. A plug-in may define any

+	 * number of applications; however, the platform is only capable

+	 * of running one application at a time.

+	 * 

+	 * @see org.eclipse.core.boot.BootLoader#run

+	 */

+	public static final String PT_APPLICATIONS = "applications";	

+	

+	/** 

+	 * Debug option value denoting the time at which the platform runtime

+	 * was started.  This constant can be used in conjunction with

+	 * <code>getDebugOption</code> to find the string value of

+	 * <code>System.currentTimeMillis()</code> when the platform was started.

+ 	 */

+	public static final String OPTION_STARTTIME = PI_RUNTIME + "/starttime";

+

+	/** 

+	 * Status code constant (value 1) indicating a problem in a plug-in

+	 * manifest (<code>plugin.xml</code>) file.

+ 	 */

+	public static final int PARSE_PROBLEM = 1;

+

+	/**

+	 * Status code constant (value 2) indicating an error occurred while running a plug-in.

+ 	 */

+	public static final int PLUGIN_ERROR = 2;

+

+	/**

+	 * Status code constant (value 3) indicating an error internal to the

+	 * platform has occurred.

+ 	 */

+	public static final int INTERNAL_ERROR = 3;

+	

+	/**

+	 * Status code constant (value 4) indicating the platform could not read

+	 * some of its metadata.

+ 	 */

+	public static final int FAILED_READ_METADATA = 4;

+	

+	/**

+	 * Status code constant (value 5) indicating the platform could not write

+	 * some of its metadata.

+ 	 */

+	public static final int FAILED_WRITE_METADATA = 5;

+	

+	/**

+	 * Status code constant (value 6) indicating the platform could not delete

+	 * some of its metadata.

+ 	 */

+	public static final int FAILED_DELETE_METADATA = 6;

+/**

+ * Private constructor to block instance creation.

+ */

+private Platform() {

+}

+/**

+ * Adds the given authorization information to the keyring. The

+ * information is relevant for the specified protection space and the

+ * given authorization scheme. The protection space is defined by the

+ * combination of the given server URL and realm. The authorization 

+ * scheme determines what the authorization information contains and how 

+ * it should be used. The authorization information is a <code>Map</code> 

+ * of <code>String</code> to <code>String</code> and typically

+ * contains information such as usernames and passwords.

+ *

+ * @param serverUrl the URL identifying the server for this authorization

+ *		information. For example, "http://www.example.com/".

+ * @param realm the subsection of the given server to which this

+ *		authorization information applies.  For example,

+ *		"realm1@example.com" or "" for no realm.

+ * @param authScheme the scheme for which this authorization information

+ *		applies. For example, "Basic" or "" for no authorization scheme

+ * @param info a <code>Map</code> containing authorization information 

+ *		such as usernames and passwords (key type : <code>String</code>, 

+ *		value type : <code>String</code>)

+ * @exception CoreException if there are problems setting the

+ *		authorization information. Reasons include:

+ * <ul>

+ * <li>The keyring could not be saved.</li>

+ * </ul>

+ */

+public static void addAuthorizationInfo(URL serverUrl, String realm, String authScheme, Map info) throws CoreException {

+	InternalPlatform.addAuthorizationInfo(serverUrl, realm, authScheme, info);

+}

+/** 

+ * Adds the given log listener to the notification list of the platform.

+ * <p>

+ * Once registered, a listener starts receiving notification as entries

+ * are added to plug-in logs via <code>ILog.log()</code>. The listener continues to

+ * receive notifications until it is replaced or removed.

+ * </p>

+ *

+ * @param listener the listener to register

+ * @see ILog#addLogListener

+ * @see #removeLogListener

+ */

+public static void addLogListener(ILogListener listener) {

+	InternalPlatform.addLogListener(listener);

+}

+/**

+ * Adds the specified resource to the protection space specified by the

+ * given realm. All targets at or deeper than the depth of the last

+ * symbolic element in the path of the given resource URL are assumed to

+ * be in the same protection space.

+ *

+ * @param resourceUrl the URL identifying the resources to be added to

+ *		the specified protection space. For example,

+ *		"http://www.example.com/folder/".

+ * @param realm the name of the protection space. For example,

+ *		"realm1@example.com"

+ * @exception CoreException if there are problems setting the

+ *		authorization information. Reasons include:

+ * <ul>

+ * <li>The keyring could not be saved.</li>

+ * </ul>

+ */

+public static void addProtectionSpace(URL resourceUrl, String realm) throws CoreException {

+	InternalPlatform.addProtectionSpace(resourceUrl, realm);

+}

+/**

+ * Returns a URL which is the local equivalent of the

+ * supplied URL. This method is expected to be used with 

+ * plug-in-relative URLs returned by IPluginDescriptor.

+ * If the specified URL is not a plug-in-relative URL, it 

+ * is returned asis. If the specified URL is a plug-in-relative

+ * URL of a file (incl. .jar archive), it is returned as 

+ * a locally-accessible URL using "file:" or "jar:file:" protocol

+ * (caching the file locally, if required). If the specified URL

+ * is a plug-in-relative URL of a directory,

+ * an exception is thrown.

+ *

+ * @param url original plug-in-relative URL.

+ * @return the resolved URL

+ * @exception IOException if unable to resolve URL

+ * @see #resolve

+ * @see IPluginDescriptor#getInstallURL

+ */

+public static URL asLocalURL(URL url) throws IOException {

+	return InternalPlatform.asLocalURL(url);

+}

+

+/**

+ * Takes down the splash screen if one was put up.

+ */

+public static void endSplash() {

+	InternalPlatform.endSplash();

+}

+

+/**

+ * Removes the authorization information for the specified protection

+ * space and given authorization scheme. The protection space is defined

+ * by the given server URL and realm.

+ *

+ * @param serverUrl the URL identifying the server to remove the

+ *		authorization information for. For example,

+ *		"http://www.example.com/".

+ * @param realm the subsection of the given server to remove the

+ *		authorization information for. For example,

+ *		"realm1@example.com" or "" for no realm.

+ * @param authScheme the scheme for which the authorization information

+ *		to remove applies. For example, "Basic" or "" for no

+ *		authorization scheme.

+ * @exception CoreException if there are problems removing the

+ *		authorization information. Reasons include:

+ * <ul>

+ * <li>The keyring could not be saved.</li>

+ * </ul>

+ */

+public static void flushAuthorizationInfo(URL serverUrl, String realm, String authScheme) throws CoreException {

+	InternalPlatform.flushAuthorizationInfo(serverUrl, realm, authScheme);

+}

+/**

+ * Returns the adapter manager used for extending

+ * <code>IAdaptable</code> objects.

+ *

+ * @return the adapter manager for this platform

+ * @see IAdapterManager

+ */

+public static IAdapterManager getAdapterManager() {

+	return InternalPlatform.getAdapterManager();

+}

+/**

+ * Returns the authorization information for the specified protection

+ * space and given authorization scheme. The protection space is defined

+ * by the given server URL and realm. Returns <code>null</code> if no

+ * such information exists.

+ *

+ * @param serverUrl the URL identifying the server for the authorization

+ *		information. For example, "http://www.example.com/".

+ * @param realm the subsection of the given server to which the

+ *		authorization information applies.  For example,

+ *		"realm1@example.com" or "" for no realm.

+ * @param authScheme the scheme for which the authorization information

+ *		applies. For example, "Basic" or "" for no authorization scheme

+ * @return the authorization information for the specified protection

+ *		space and given authorization scheme, or <code>null</code> if no

+ *		such information exists

+ */

+public static Map getAuthorizationInfo(URL serverUrl, String realm, String authScheme) {

+	return InternalPlatform.getAuthorizationInfo(serverUrl, realm, authScheme);

+}

+/**

+ * Returns the command line args provided to the platform when it was first run.

+ * Note that individual platform runnables may be provided with different arguments

+ * if they are being run individually rather than with <code>Platform.run()</code>.

+ * 

+ * @return the command line used to start the platform

+ */

+public static String[] getCommandLineArgs() {

+	return BootLoader.getCommandLineArgs();

+}

+/**

+ * Returns the identified option.  <code>null</code>

+ * is returned if no such option is found.   Options are specified

+ * in the general form <i>&ltplug-in id&gt/&ltoption-path&gt</i>.  

+ * For example, <code>org.eclipse.core.runtime/debug</code>

+ *

+ * @param option the name of the option to lookup

+ * @return the value of the requested debug option or <code>null</code>

+ */

+public static String getDebugOption(String option) {

+	return InternalPlatform.getDebugOption(option);

+}

+/**

+ * Returns the location of the platform working directory.  This 

+ * corresponds to the <i>-platform</i> command line argument if

+ * present or, if not, the current working directory when the platform

+ * was started.

+ *

+ * @return the location of the platform

+ */

+public static IPath getLocation() {

+	return InternalPlatform.getLocation();

+}

+/**

+ * Returns the plug-in runtime object for the identified plug-in

+ * or <code>null</code> if no such plug-in can be found.  If

+ * the plug-in is defined but not yet activated, the plug-in will

+ * be activated before being returned.

+ *

+ * @param id the unique identifier of the desired plug-in 

+ *		(e.g., <code>"com.example.acme"</code>).

+ * @return the plug-in runtime object, or <code>null</code>

+ */

+public static Plugin getPlugin(String id) {

+	return InternalPlatform.getPlugin(id);

+}

+/**

+ * Returns the plug-in registry for this platform.

+ *

+ * @return the plug-in registry

+ * @see IPluginRegistry

+ */

+public static IPluginRegistry getPluginRegistry() {

+	return InternalPlatform.getPluginRegistry();

+}

+/**

+ * Returns the location in the local file system of the plug-in 

+ * state area for the given plug-in.

+ * The platform must be running.

+ * <p>

+ * The plug-in state area is a file directory within the

+ * platform's metadata area where a plug-in is free to create files.

+ * The content and structure of this area is defined by the plug-in,

+ * and the particular plug-in is solely responsible for any files

+ * it puts there. It is recommended for plug-in preference settings.

+ * </p>

+ *

+ * @param plugin the plug-in whose state location is returned

+ * @return a local file system path

+ */

+public static IPath getPluginStateLocation(Plugin plugin) {

+	return InternalPlatform.getPluginStateLocation(plugin);

+}

+/**

+ * Returns the protection space (realm) for the specified resource, or

+ * <code>null</code> if the realm is unknown.

+ *

+ * @param resourceUrl the URL of the resource whose protection space is

+ *		returned. For example, "http://www.example.com/folder/".

+ * @return the protection space (realm) for the specified resource, or

+ *		<code>null</code> if the realm is unknown

+ */

+public static String getProtectionSpace(URL resourceUrl) {

+	return InternalPlatform.getProtectionSpace(resourceUrl);

+}

+/**

+ * Returns a plug-in registry containing all of the plug-ins discovered

+ * on the given plug-in path.  Any problems encountered are added to

+ * the status managed by the supplied factory.

+ * <p>

+ * The given plug-in path is the list of locations in which to look for plug-ins.

+ * If an entry identifies a directory (i.e., ends in a '/'), this method

+ * attempts to scan all sub-directories for plug-ins.  Alternatively, an

+ * entry may identify a particular plug-in manifest (<code>plugin.xml</code>) file.

+ * </p>

+ * <p>

+ * <b>Note:</b> this method does not affect the running platform.  It is intended

+ * for introspecting installed plug-ins on this and other platforms.  The returned

+ * registry is <b>not</b> the same as the platform's registry.

+ * </p>

+ *

+ * @param pluginPath the list of locations in which to look for plug-ins

+ * @param factory the factory to use to create runtime model objects

+ * @return the registry of parsed plug-ins

+ */

+public static PluginRegistryModel parsePlugins(URL[] pluginPath, Factory factory) {

+	return InternalPlatform.parsePlugins(pluginPath, factory);

+}

+/** 

+ * Removes the indicated (identical) log listener from the notification list

+ * of the platform.  If no such listener exists, no action is taken.

+ *

+ * @param listener the listener to deregister

+ * @see ILog#removeLogListener

+ * @see #addLogListener

+ */

+public static void removeLogListener(ILogListener listener) {

+	InternalPlatform.removeLogListener(listener);

+}

+/**

+ * Returns a URL which is the resolved equivalent of the

+ * supplied URL. This method is expected to be used with 

+ * plug-in-relative URLs returned by IPluginDescriptor.

+ * If the specified URL is not a plug-in-relative URL, it is returned

+ * asis. If the specified URL is a plug-in-relative URL, it is

+ * resolved to a URL using the actuall URL protocol

+ * (eg. file, http, etc)

+ *

+ * @param url original plug-in-relative URL.

+ * @return the resolved URL

+ * @exception IOException if unable to resolve URL

+ * @see #asLocalURL

+ * @see IPluginDescriptor#getInstallURL

+ */

+public static URL resolve(URL url) throws java.io.IOException {

+	return InternalPlatform.resolve(url);

+}

+/**

+ * Runs the given runnable in a protected mode.   Exceptions

+ * thrown in the runnable are logged and passed to the runnable's

+ * exception handler.  Such exceptions are not rethrown by this method.

+ *

+ * @param code the runnable to run

+ */

+public static void run(ISafeRunnable runnable) {

+	InternalPlatform.run(runnable);

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/PlatformObject.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/PlatformObject.java
new file mode 100644
index 0000000..4e83261
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/PlatformObject.java
@@ -0,0 +1,55 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * An abstract superclass implementing the <code>IAdaptable</code>

+ * interface. <code>getAdapter</code> invocations are directed

+ * to the platform's adapter manager.

+ * <p>

+ * Note: In situations where it would be awkward to subclass this

+ * class, the same affect can be achieved simply by implementing

+ * the <code>IAdaptable</code> interface and explicitly forwarding

+ * the <code>getAdapter</code> request to the platform's 

+ * adapater manager. The method would look like:

+ * <pre>

+ *     public Object getAdapter(Class adapter) {

+ *         return Platform.getAdapterManager().getAdapter(this, adapter);

+ *     }

+ * </pre>

+ * </p>

+ * <p>

+ * Clients may subclass.

+ * </p>

+ *

+ * @see Platform#getAdapterManager

+ */

+public abstract class PlatformObject implements IAdaptable {

+/**

+ * Constructs a new platform object.

+ */

+public PlatformObject() {

+}

+/**

+ * Returns an object which is an instance of the given class

+ * associated with this object. Returns <code>null</code> if

+ * no such object can be found.

+ * <p>

+ * This implementation of the method declared by <code>IAdaptable</code>

+ * passes the request along to the platform's adapter manager; roughly

+ * <code>Platform.getAdapterManager().getAdapter(this, adapter)</code>.

+ * Subclasses may override this method (however, if they do so, they

+ * should invoke the method on their superclass to ensure that the

+ * Platform's adapter manager is consulted).

+ * </p>

+ *

+ * @see IAdaptable#getAdapter

+ * @see Platform#getAdapterManager

+ */

+public Object getAdapter(Class adapter) {

+	return Platform.getAdapterManager().getAdapter(this, adapter);

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Plugin.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Plugin.java
new file mode 100644
index 0000000..160b66f
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Plugin.java
@@ -0,0 +1,463 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.internal.plugins.DefaultPlugin;

+import org.eclipse.core.internal.plugins.PluginDescriptor;

+import org.eclipse.core.internal.runtime.*;

+import org.eclipse.core.runtime.model.PluginFragmentModel;

+import org.eclipse.core.boot.BootLoader;

+import org.eclipse.core.internal.boot.PlatformURLHandler;

+import java.util.StringTokenizer;

+import java.util.Vector;

+import java.net.*;

+import java.io.*;

+

+/**

+ * The abstract superclass of all plug-in runtime class

+ * implementations. A plug-in subclasses this class and overrides

+ * the <code>startup</code> and <code>shutdown</code> methods 

+ * in order to react to life cycle requests automatically issued

+ * by the platform.

+ * <p>

+ * Conceptually, the plug-in runtime class represents the entire plug-in

+ * rather than an implementation of any one particular extension the

+ * plug-in declares. A plug-in is not required to explicitly

+ * specify a plug-in runtime class; if none is specified, the plug-in

+ * will be given a default plug-in runtime object that ignores all life 

+ * cycle requests (it still provides access to the corresponding

+ * plug-in descriptor).

+ * </p>

+ * <p>

+ * In the case of more complex plug-ins, it may be desireable

+ * to define a concrete subclass of <code>Plugin</code>.

+ * However, just subclassing <code>Plugin</code> is not

+ * sufficient. The name of the class must be explicitly configured

+ * in the plug-in's manifest (<code>plugin.xml</code>) file

+ * with the class attribute of the <code>&ltplugin&gt</code> element markup.

+ * </p>

+ * <p>

+ * Instances of plug-in runtime classes are automatically created 

+ * by the platform in the course of plug-in activation.

+ * <b>Clients must never explicitly instantiate a plug-in runtime class</b>.

+ * </p>

+ * <p>

+ * A typical implementation pattern for plug-in runtime classes is to

+ * provide a static convenience method to gain access to a plug-in's

+ * runtime object. This way, code in other parts of the plug-in

+ * implementation without direct access to the plug-in runtime object

+ * can easily obtain a reference to it, and thence to any plug-in-wide

+ * resources recorded on it. An example follows:

+ * <pre>

+ *     package myplugin;

+ *     public class MyPluginClass extends Plugin {

+ *         private static MyPluginClass instance;

+ *

+ *         public static MyPluginClass getInstance() { return instance; }

+ *

+ *         public void MyPluginClass(IPluginDescriptor descriptor) {

+ *             super(descriptor);

+ *             instance = this;

+ *             // ... other initialization

+ *         }

+ *         // ... other methods

+ *     }

+ * </pre>

+ * In the above example, a call to <code>MyPluginClass.getInstance()</code>

+ * will always return an initialized instance of <code>MyPluginClass</code>.

+ * </p>

+ * <p>

+ * The static method <code>Platform.getPlugin()</code>

+ * can be used to locate a plug-in's runtime object by name.

+ * The extension initialization would contain the following code:

+ * <pre>

+ *     Plugin myPlugin = Platform.getPlugin("com.example.myplugin");

+ * </pre>

+ * 

+ * Another typical implementation pattern for plug-in classes

+ * is handling of any initialization files required by the plug-in.

+ * Typically, each plug-in will ship one or more default files

+ * as part of the plug-in install. The executing plug-in will

+ * use the defaults on initial startup (or when explicitly requested

+ * by the user), but will subsequently rewrite any modifications

+ * to the default settings into one of the designated plug-in

+ * working directory locations. An example of such an implementation

+ * pattern is illustrated below:

+ * <pre>

+ * package myplugin;

+ * public class MyPlugin extends Plugin {

+ *

+ *     private static final String INI = "myplugin.ini"; 

+ *     private Properties myProperties = null;

+ *

+ *     public void startup() throws CoreException {

+ *         try {

+ *             InputStream input = null;

+ *             // look for working properties.  If none, use shipped defaults 

+ *             File file = getStateLocation().append(INI).toFile();

+ *             if (!file.exists()) {			

+ *                 URL base = getDescriptor().getInstallURL();

+ *                 input = (new URL(base,INI)).openStream();

+ *             } else 

+ *                 input = new FileInputStream(file);

+ * 

+ *             // load properties 

+ *             try {

+ *                 myProperties = new Properties();

+ *                 myProperties.load(input);

+ *             } finally {

+ *                 try {

+ *                     input.close();

+ *                 } catch (IOException e) {

+ *                     // ignore failure on close

+ *                 }

+ *             }

+ *         } catch (Exception e) {

+ *             throw new CoreException(

+ *                 new Status(IStatus.ERROR, getDescriptor().getUniqueIdentifier(),

+ *                     0, "Problems starting plug-in myplugin", e));

+ *         }

+ *     }

+ *

+ *     public void shutdown() throws CoreException { 

+ *         // save properties in plugin state location (r/w)

+ *         try {

+ *             FileOutputStream output = null; 

+ *             try {

+ *                 output = new FileOutputStream(getStateLocation().append(INI)); 

+ *                 myProperties.store(output, null);

+ *             } finally {

+ *                 try {

+ *                     output.close();

+ *                 } catch (IOException e) {

+ *                     // ignore failure on close

+ *                 }

+ *             }

+ *         } catch (Exception e) {

+ *             throw new CoreException(

+ *                 new Status(IStatus.ERROR, getDescriptor().getUniqueIdentifier(),

+ *                     0, "Problems shutting down plug-in myplugin", e));

+ *         }

+ *     }

+ *

+ *     public Properties getProperties() {	

+ *         return myProperties; 

+ *     }

+ * }

+ * </pre>

+ * </p>

+ */

+public abstract class Plugin  {

+

+	/**

+	 * The debug flag for this plug-in.  The flag is false by default.

+	 * It can be set to true either by the plug-in itself or in the platform 

+	 * debug options.

+	 */

+	private boolean debug = false;

+	

+	/** The plug-in descriptor.

+	 */

+	private IPluginDescriptor descriptor;

+/**

+ * Creates a new plug-in runtime object for the given plug-in descriptor.

+ * <p>

+ * Instances of plug-in runtime classes are automatically created 

+ * by the platform in the course of plug-in activation.

+ * <b>Clients must never explicitly instantiate a plug-in runtime class.</b>

+ * </p>

+ *

+ * @param descriptor the plug-in descriptor

+ * @see #getDescriptor

+ */

+public Plugin(IPluginDescriptor descriptor) {

+	Assert.isNotNull(descriptor);

+	Assert.isTrue(!descriptor.isPluginActivated(), Policy.bind("plugin.deactivatedLoad", this.getClass().getName(), descriptor.getUniqueIdentifier() + " is not activated"));

+	String className = ((PluginDescriptor) descriptor).getPluginClass();

+	if (this.getClass() == DefaultPlugin.class) 

+		Assert.isTrue(className == null || className.equals(""), Policy.bind("plugin.mismatchRuntime", descriptor.getUniqueIdentifier()));

+	else 

+		Assert.isTrue(this.getClass().getName().equals(className), Policy.bind("plugin.mismatchRuntime", descriptor.getUniqueIdentifier()));

+	this.descriptor = descriptor;

+	String key = descriptor.getUniqueIdentifier() + "/debug";

+	String value = Platform.getDebugOption(key);

+	this.debug = value == null ? false : value.equalsIgnoreCase("true");

+}

+/**

+ * Returns a URL for the given path.  Returns <code>null</code> if the URL

+ * could not be computed or created.

+ * 

+ * @param file path relative to plug-in installation location 

+ * @return a URL for the given path or <code>null</code>

+ */

+public final URL find(IPath path) {

+	URL install = getDescriptor().getInstallURL();

+	String first = path.segment(0);

+	if (first.charAt(0) != '$') {		

+		URL result = findInPlugin(install, path.toString());

+		if (result != null)

+			return result;	

+		return findInFragments(path.toString());

+	}

+	IPath rest = path.removeFirstSegments(1);

+	if (first.equalsIgnoreCase("$nl$"))

+		return findNL(install, rest);

+	if (first.equalsIgnoreCase("$os$"))

+		return findOS(install, rest);

+	if (first.equalsIgnoreCase("$ws$"))

+		return findWS(install, rest);

+	if (first.equalsIgnoreCase("$files$"))

+		return null;

+	return null;

+}

+

+private URL findOS(URL install, IPath path) {

+	String filePath = "os/" + BootLoader.getOS() + "/" + path.toString();	

+	URL result = findInPlugin(install, filePath);

+	if (result != null)

+		return result;	

+	return findInFragments(filePath);

+}

+

+private URL findWS(URL install, IPath path) {

+	String filePath = "ws/" + BootLoader.getWS() + "/" + path.toString();	

+	URL result = findInPlugin(install, filePath);

+	if (result != null)

+		return result;	

+	return findInFragments(filePath);

+}

+

+private URL findNL(URL install, IPath path) {

+	String nl = BootLoader.getNL();

+	URL result = null;

+	boolean done = false;

+	

+	while (!done) {		

+		String filePath = "nl/" + (nl.equals("") ? nl : nl + "/") + path.toString();

+		result = findInPlugin(install, filePath);

+		if (result != null)

+			return result;

+		result = findInFragments(filePath);

+		if (result != null)

+			return result;

+		if (nl.length() == 0)

+			done = true;

+		else {

+			int i = nl.lastIndexOf('_');

+			if (i < 0)

+				nl = "";

+			else

+				nl = nl.substring(0, i);

+		}

+	}

+	return null;

+}

+

+private URL findInPlugin(URL install, String filePath) {

+	try {

+		URL result = new URL(install, filePath);

+		URL location = Platform.resolve(result);

+		String file = getFileFromURL(location);

+		if (file != null && new File(file).exists())

+			return result;						

+	} catch (IOException e) {

+	}

+	return null;

+}

+

+private URL findInFragments(String path) {

+	PluginFragmentModel[] fragments = ((PluginDescriptor)getDescriptor()).getFragments();

+	if (fragments == null)

+		return null;

+		

+	for (int i = 0; i < fragments.length; i++) {

+		try {

+			URL location = new URL(fragments[i].getLocation() + path);

+			String file = getFileFromURL(location);

+			if (file != null && new File(file).exists())

+				return location;

+		} catch (IOException e) {

+			// skip malformed url and urls that cannot be resolved

+		}

+	}

+	return null;

+}

+

+private String getFileFromURL(URL target) {

+	String protocol = target.getProtocol();

+	if (protocol.equals(PlatformURLHandler.FILE))

+		return target.getFile();

+	if (protocol.equals(PlatformURLHandler.VA))

+		return target.getFile();

+	if (protocol.equals(PlatformURLHandler.JAR)) {

+		// strip off the jar separator at the end of the url then do a recursive call

+		// to interpret the sub URL.

+		String file = target.getFile();

+		file = file.substring(0, file.length() - PlatformURLHandler.JAR_SEPARATOR.length());

+		try {

+			return getFileFromURL(new URL(file));

+		} catch (MalformedURLException e) {

+		}

+	}

+	return null;

+}

+/**

+ * Returns the plug-in descriptor for this plug-in runtime object.

+ *

+ * @return the plug-in descriptor for this plug-in runtime object

+ */

+public final IPluginDescriptor getDescriptor() {

+	return descriptor;

+}

+/**

+ * Returns the log for this plug-in.  If no such log exists, one is created.

+ *

+ * @return the log for this plug-in

+ */

+public final ILog getLog() {

+	return InternalPlatform.getLog(this);

+}

+/**

+ * Returns the location in the local file system of the 

+ * plug-in state area for this plug-in.

+ * If the plug-in state area did not exist prior to this call,

+ * it is created.

+ * <p>

+ * The plug-in state area is a file directory within the

+ * platform's metadata area where a plug-in is free to create files.

+ * The content and structure of this area is defined by the plug-in,

+ * and the particular plug-in is solely responsible for any files

+ * it puts there. It is recommended for plug-in preference settings and 

+ * other configuration parameters.

+ * </p>

+ *

+ * @return a local file system path

+ */

+public final IPath getStateLocation() {

+	return InternalPlatform.getPluginStateLocation(this);

+}

+/**

+ * Returns whether this plug-in is in debug mode.

+ * By default plug-ins are not in debug mode.  A plug-in can put itself

+ * into debug mode or the user can set an execution option to do so.

+ *

+ * @return whether this plug-in is in debug mode

+ */

+public boolean isDebugging() {

+	return debug;

+}

+/**

+ * Returns an input stream for the specified file. The file path

+ * must be specified relative this the plug-in's installation location.

+ *

+ * @param file path relative to plug-in installation location

+ * @return an input stream

+ * @see #openStream(IPath,boolean)

+ */

+public final InputStream openStream(IPath file) throws IOException {

+	return openStream(file, false);

+}

+/**

+ * Returns an input stream for the specified file. The file path

+ * must be specified relative to this plug-in's installation location.

+ * Optionally, the platform searches for the correct localized version

+ * of the specified file using the users current locale, and Java

+ * naming convention for localized resource files (locale suffix appended 

+ * to the specified file extension).

+ * <p>

+ * The caller must close the returned stream when done.

+ * </p>

+ *

+ * @param file path relative to plug-in installation location

+ * @param localized <code>true</code> for the localized version

+ *   of the file, and <code>false</code> for the file exactly

+ *   as specified

+ * @return an input stream

+ */

+public final InputStream openStream(IPath file, boolean localized) throws IOException {

+	URL target = new URL(getDescriptor().getInstallURL() + file.toString());

+	return target.openStream();

+}

+/**

+ * Sets whether this plug-in is in debug mode.

+ * By default plug-ins are not in debug mode.  A plug-in can put itself

+ * into debug mode or the user can set a debug option to do so.

+ *

+ * @param value whether or not this plugi-in is in debug mode

+ */

+public void setDebugging(boolean value) {

+	debug = value;

+}

+/**

+ * Shuts down this plug-in and discards all plug-in state.

+ * <p>

+ * This method should be re-implemented in subclasses that need to do something

+ * when the plug-in is shut down.  Implementors should call the inherited method

+ * to ensure that any system requirements can be met.

+ * </p>

+ * <p>

+ * Plug-in shutdown code should be robust. In particular, this method

+ * should always make an effort to shut down the plug-in. Furthermore,

+ * the code should not assume that the plug-in was started successfully,

+ * as this method will be invoked in the event of a failure during startup.

+ * </p>

+ * <p>

+ * Note 1: If a plug-in has been started, this method will be automatically

+ * invoked by the platform when the platform is shut down.

+ * </p>

+ * <p>

+ * Note 2: This method is intended to perform simple termination

+ * of the plug-in environment. The platform may terminate invocations

+ * that do not complete in a timely fashion.

+ * </p>

+ * <b>Cliens must never explicitly call this method.</b>

+ *

+ * @exception CoreException if this method fails to shut down

+ *   this plug-in 

+ */

+public void shutdown() throws CoreException {

+}

+/**

+ * Starts up this plug-in.

+ * <p>

+ * This method should be overridden in subclasses that need to do something

+ * when this plug-in is started.  Implementors should call the inherited method

+ * to ensure that any system requirements can be met.

+ * </p>

+ * <p>

+ * If this method throws an exception, it is taken as an indication that

+ * plug-in initialization has failed; as a result, the plug-in will not

+ * be activated; moreover, the plug-in will be marked as disabled and 

+ * ineligible for activation for the duration.

+ * </p>

+ * <p>

+ * Plug-in startup code should be robust. In the event of a startup failure,

+ * the plug-in's <code>shutdown</code> method will be invoked automatically,

+ * in an attempt to close open files, etc.

+ * </p>

+ * <p>

+ * Note 1: This method is automatically invoked by the platform 

+ * the first time any code in the plug-in is executed.

+ * </p>

+ * <p>

+ * Note 2: This method is intended to perform simple initialization 

+ * of the plug-in environment. The platform may terminate initializers 

+ * that do not complete in a timely fashion.

+ * </p>

+ * <b>Cliens must never explicitly call this method.</b>

+ *

+ * @exception CoreException if this plug-in did not start up properly

+ */

+public void startup() throws CoreException {

+}

+/**

+ * Returns a string representation of the plug-in, suitable 

+ * for debugging purposes only.

+ */

+public String toString() {

+	return descriptor.toString();

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/PluginVersionIdentifier.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/PluginVersionIdentifier.java
new file mode 100644
index 0000000..401eef8
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/PluginVersionIdentifier.java
@@ -0,0 +1,249 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import java.util.Vector;

+import java.util.StringTokenizer;

+import org.eclipse.core.internal.runtime.Assert;

+

+/**

+ * <p>

+ * Version identifier for a plug-in. In its string representation, 

+ * it consists of up to 3 positive integer numbers separated by decimal point.

+ * For example, the following are valid version identifiers 

+ * (as strings):

+ * <ul>

+ *   <li><code>0.0.0</code></li>

+ *   <li><code>1.0.127564</code></li>

+ *   <li><code>3.7.2</code></li>

+ *   <li><code>1.9</code> (interpreted as <code>1.9.0</code>)</li>

+ *   <li><code>3</code> (interpreted as <code>3.0.0</code>)</li>

+ * </ul>

+ * </p>

+ * <p>

+ * The version identifier can be decomposed into a major, minor

+ * and service level component. A difference in the major 

+ * component is interpreted as an incompatible version change. 

+ * A difference in the minor (and not the major) component is 

+ * interpreted as a compatible version change. The service

+ * level component is interpreted as a cumulative 

+ * and compatible service update of the minor version component.

+ * </p>

+ * <p>

+ * Version identifiers can be matched for equality, equivalency,

+ * and compatibility.

+ * </p>

+ * <p>

+ * Clients may instantiate; not intended to be subclassed by clients.

+ * </p>

+ * @see IPluginDescriptor#getVersionIdentifier

+ */	

+public final class PluginVersionIdentifier {

+		

+	private	int major = 0;

+	private int minor = 0;

+	private int service = 0;

+	

+	private static final String	SEPARATOR = ".";

+/**

+ * Creates a plug-in version identifier from its components.

+ * 

+ * @param major major component of the version identifier

+ * @param minor minor component of the version identifier

+ * @param service service update component of the version identifier

+ */

+public PluginVersionIdentifier(int major, int minor, int service) {

+

+	Assert.isTrue(major>=0);

+	Assert.isTrue(minor>=0);

+	Assert.isTrue(service>=0);

+	

+	this.major = major;

+	this.minor = minor;

+	this.service = service;

+}

+/**

+ * Creates a plug-in version identifier from the given string.

+ * The string represenation consists of up to 3 integer 

+ * numbers separated by decimal point.

+ * For example, the following are valid version identifiers 

+ * (as strings):

+ * <ul>

+ *   <li><code>0.0.0</code></li>

+ *   <li><code>1.0.127564</code></li>

+ *   <li><code>3.7.2</code></li>

+ *   <li><code>1.9</code> (interpreted as <code>1.9.0</code>)</li>

+ *   <li><code>3</code> (interpreted as <code>3.0.0</code>)</li>

+ * </ul>

+ * </p>

+ * 

+ * @param versionId string representation of the version identifier

+ */

+public PluginVersionIdentifier(String versionId) {

+

+	Assert.isNotNull(versionId);

+	String s = versionId.trim();

+	Assert.isTrue(!s.equals(""));

+	Assert.isTrue(!s.startsWith(SEPARATOR));

+	Assert.isTrue(!s.endsWith(SEPARATOR));

+	Assert.isTrue(s.indexOf(SEPARATOR+SEPARATOR)==-1);

+	

+	StringTokenizer st = new StringTokenizer(s, SEPARATOR);

+	Integer token;

+	Vector elements = new Vector(3);

+

+	while(st.hasMoreTokens()) {

+		token = new Integer((String)st.nextToken());

+		Assert.isTrue(token.intValue() >= 0);

+		elements.addElement(token);

+	}

+

+	Assert.isTrue(elements.size()>0);

+	Assert.isTrue(elements.size()<=3);

+

+	if (elements.size()>=1) this.major = ((Integer)elements.elementAt(0)).intValue();

+	if (elements.size()>=2) this.minor = ((Integer)elements.elementAt(1)).intValue();

+	if (elements.size()>=3) this.service = ((Integer)elements.elementAt(2)).intValue();

+

+}

+/**

+ * Compare version identifiers for equality. Identifiers are

+ * equal if all of their components are equal.

+ *

+ * @param object an object to compare

+ * @return whehter or not the two objects are equal

+ */

+public boolean equals(Object object) {

+	if (!(object instanceof PluginVersionIdentifier))

+		return false;

+	PluginVersionIdentifier v = (PluginVersionIdentifier) object;

+	return v.getMajorComponent() == major && v.getMinorComponent() == minor && v.getServiceComponent() == service;

+}

+/**

+ * Returns a hash code value for the object. 

+ *

+ * @return an integer which is a hash code value for this object.

+ */

+public int hashCode() {

+	return major + minor + service;

+}

+/**

+ * Returns the major (incompatible) component of this 

+ * version identifier.

+ *

+ * @return the major version

+ */

+public int getMajorComponent() {

+	return major;

+}

+/**

+ * Returns the minor (compatible) component of this 

+ * version identifier.

+ *

+ * @return the minor version

+ */

+public int getMinorComponent() {

+	return minor;

+}

+/**

+ * Returns the service level component of this 

+ * version identifier.

+ *

+ * @return the service level

+ */

+public int getServiceComponent() {

+	return service;

+}

+/**

+ * Compares two version identifiers for compatibility.

+ * <p>

+ * A version identifier is considered to be compatible if its major 

+ * component equals to the argument major component, and its minor component

+ * is greater than or equal to the argument minor component.

+ * If the minor components are equal, than the service level of the

+ * version identifier must be greater than or equal to the service level

+ * of the argument identifier.

+ * </p>

+ *

+ * @param versionId the other version identifier

+ * @return <code>true</code> is this version identifier

+ *    is compatible with the given version identifier, and

+ *    <code>false</code> otherwise

+ */

+public boolean isCompatibleWith(PluginVersionIdentifier id) {

+	if (id == null)

+		return false;

+	if (major != id.getMajorComponent())

+		return false;

+	if (minor > id.getMinorComponent())

+		return true;

+	if (minor < id.getMinorComponent())

+		return false;

+	if (service >= id.getServiceComponent())

+		return true;

+	else

+		return false;

+}

+/**

+ * Compares two version identifiers for equivalency.

+ * <p>

+ * Two version identifiers are considered to be equivalent if their major 

+ * and minor component equal and are at least at the same service level 

+ * as the argument.

+ * </p>

+ *

+ * @param versionId the other version identifier

+ * @return <code>true</code> is this version identifier

+ *    is equivalent to the given version identifier, and

+ *    <code>false</code> otherwise

+ */

+public boolean isEquivalentTo(PluginVersionIdentifier id) {

+	if (id == null)

+		return false;

+	if (major != id.getMajorComponent())

+		return false;

+	if (minor != id.getMinorComponent())

+		return false;

+	if (service >= id.getServiceComponent())

+		return true;

+	else

+		return false;

+}

+/**

+ * Compares two version identifiers for order using multi-decimal

+ * comparison. 

+ *

+ * @param versionId the other version identifier

+ * @return <code>true</code> is this version identifier

+ *    is greater than the given version identifier, and

+ *    <code>false</code> otherwise

+ */

+public boolean isGreaterThan(PluginVersionIdentifier id) {

+

+	if (id == null) {

+		if (major==0 && minor==0 && service==0) return false;

+		else return true;

+	}

+

+	if (major > id.getMajorComponent()) return true;

+	if (major < id.getMajorComponent()) return false;

+	if (minor > id.getMinorComponent()) return true;

+	if (minor < id.getMinorComponent()) return false;	

+	if (service > id.getServiceComponent()) return true;

+	else return false;

+

+}

+/**

+ * Returns the string representation of this version identifier. 

+ * The result satisfies

+ * <code>vi.equals(new PluginVersionIdentifier(vi.toString()))</code>.

+ *

+ * @return the string representation of this plug-in version identifier

+ */

+public String toString() {

+	return major+SEPARATOR+minor+SEPARATOR+service;

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ProgressMonitorWrapper.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ProgressMonitorWrapper.java
new file mode 100644
index 0000000..ff86d29
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/ProgressMonitorWrapper.java
@@ -0,0 +1,128 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.internal.runtime.Assert;

+

+/**

+ * An abstract wrapper around a progress monitor which,

+ * unless overridden, forwards <code>IProgressMonitor</code>

+ * methods to the wrapped progress monitor.

+ * <p>

+ * Clients may subclass.

+ * </p>

+ */

+public abstract class ProgressMonitorWrapper implements IProgressMonitor {

+

+	/** The wrapped progress monitor. */

+	private IProgressMonitor progressMonitor;

+

+/** 

+ * Creates a new wrapper around the given monitor.

+ *

+ * @param monitor the progress monitor to forward to

+ */

+protected ProgressMonitorWrapper(IProgressMonitor monitor) {

+	Assert.isNotNull(monitor);

+	progressMonitor = monitor;

+}

+/** 

+ * This implementation of a <code>IProgressMonitor</code>

+ * method forwards to the wrapped progress monitor.

+ * Clients may override this method to do additional

+ * processing.

+ *

+ * @see IProgressMonitor#beginTask

+ */

+public void beginTask(String name, int totalWork) {

+	progressMonitor.beginTask(name, totalWork);

+}

+/**

+ * This implementation of a <code>IProgressMonitor</code>

+ * method forwards to the wrapped progress monitor.

+ * Clients may override this method to do additional

+ * processing.

+ *

+ * @see IProgressMonitor#done

+ */

+public void done() {

+	progressMonitor.done();

+}

+/**

+ * Returns the wrapped progress monitor.

+ *

+ * @return the wrapped progress monitor

+ */

+public IProgressMonitor getWrappedProgressMonitor() {

+	return progressMonitor;

+}

+/**

+ * This implementation of a <code>IProgressMonitor</code>

+ * method forwards to the wrapped progress monitor.

+ * Clients may override this method to do additional

+ * processing.

+ *

+ * @see IProgressMonitor#internalWorked

+ */

+public void internalWorked(double work) {

+	progressMonitor.internalWorked(work);

+}

+/**

+ * This implementation of a <code>IProgressMonitor</code>

+ * method forwards to the wrapped progress monitor.

+ * Clients may override this method to do additional

+ * processing.

+ *

+ * @see IProgressMonitor#isCanceled

+ */

+public boolean isCanceled() {

+	return progressMonitor.isCanceled();

+}

+/**

+ * This implementation of a <code>IProgressMonitor</code>

+ * method forwards to the wrapped progress monitor.

+ * Clients may override this method to do additional

+ * processing.

+ *

+ * @see IProgressMonitor#setCanceled

+ */

+public void setCanceled(boolean b) {

+	progressMonitor.setCanceled(b);

+}

+/**

+ * This implementation of a <code>IProgressMonitor</code>

+ * method forwards to the wrapped progress monitor.

+ * Clients may override this method to do additional

+ * processing.

+ *

+ * @see IProgressMonitor#setTaskName

+ */

+public void setTaskName(String name) {

+	progressMonitor.setTaskName(name);

+}

+/**

+ * This implementation of a <code>IProgressMonitor</code>

+ * method forwards to the wrapped progress monitor.

+ * Clients may override this method to do additional

+ * processing.

+ *

+ * @see IProgressMonitor#subTask

+ */

+public void subTask(String name) {

+	progressMonitor.subTask(name);

+}

+/**

+ * This implementation of a <code>IProgressMonitor</code>

+ * method forwards to the wrapped progress monitor.

+ * Clients may override this method to do additional

+ * processing.

+ *

+ * @see IProgressMonitor#worked

+ */

+public void worked(int work) {

+	progressMonitor.worked(work);

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/QualifiedName.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/QualifiedName.java
new file mode 100644
index 0000000..17d8724
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/QualifiedName.java
@@ -0,0 +1,103 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.internal.runtime.Assert;

+ 

+/**

+ * Qualified names are two-part names: qualifier and local name.

+ * The qualifier must be in URI form (see RFC2396).  

+ * Note however that the qualifier may be <code>null</code> if

+ * the default name space is being used.  The empty string is not 

+ * a valid local name.

+ * <p>

+ * This class is not intended to be subclassed by clients.

+ * </p>

+ */

+public final class QualifiedName {

+

+	/** Qualifier part (potentially <code>null</code>). */

+	/*package*/ String qualifier = null;

+

+	/** Local name part. */

+	/*package*/ String localName = null;

+/**

+ * Creates and returns a new qualified name with the given qualifier

+ * and local name.  The local name must not be the empty string.

+ * The qualifier may be <code>null</code>.

+ * <p>

+ * Clients may instantiate.

+ * </p>

+ * @param qualifier the qualifier string, or <code>null</code>

+ * @param localName the local name string

+ */

+public QualifiedName(String qualifier, String localName) {

+	Assert.isLegal(localName != null && localName.length() != 0);

+	this.qualifier = qualifier;

+	this.localName = localName;

+}

+/**

+ * Returns whether this qualified name is equivalent to the given object.

+ * <p>

+ * Qualified names are equal if and only if they have the same

+ * qualified parts and local parts.

+ * Qualified names are not equal to objects other than qualified names.

+ * </p>

+ *

+ * @param obj the object to compare to

+ * @return <code>true</code> if these are equivalent qualified

+ *    names, and <code>false</code> otherwise

+ */

+public boolean equals(Object obj) {

+	if (obj == this) {

+		return true;

+	}

+	if (!(obj instanceof QualifiedName)) {

+		return false;

+	}

+	QualifiedName qName = (QualifiedName) obj;

+	/* There may or may not be a quailfier */

+	if (qualifier == null && qName.getQualifier() != null) {

+		return false;

+	}

+	if (qualifier != null && !qualifier.equals(qName.getQualifier())) {

+		return false;

+	}

+	return localName.equals(qName.getLocalName());

+}

+/**

+ * Returns the local part of this name.

+ *

+ * @return the local name string

+ */

+public String getLocalName() {

+	return localName;

+}

+/**

+ * Returns the qualifier part for this qualifed name, or <code>null</code>

+ * if none.

+ *

+ * @return the qualifier string, or <code>null</code>

+ */

+public String getQualifier() {

+	return qualifier;

+}

+/* (Intentionally omitted from javadoc)

+ * Implements the method <code>Object.hashCode</code>.

+ * 

+ * Returns the hash code for this qualified name.

+ */

+public int hashCode() {

+	return (qualifier == null ? 0 : qualifier.hashCode()) + localName.hashCode();

+}

+/**

+ * Converts this qualified name into a string, suitable for 

+ * debug purposes only.

+ */

+public String toString() {

+	return "QualifiedName(" + (getQualifier() == null ? "null" : getQualifier()) + "," + getLocalName() + ")";

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Status.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Status.java
new file mode 100644
index 0000000..b6d8f13
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/Status.java
@@ -0,0 +1,192 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.internal.runtime.Assert;

+

+/**

+ * A concrete status implementation, suitable either for 

+ * instantiating or subclassing.

+ */

+public class Status implements IStatus {

+	/**

+	 * The severity. One of

+	 * <ul>

+	 * <li><code>ERROR</code></li>

+	 * <li><code>WARNING</code></li>

+	 * <li><code>INFO</code></li>

+	 * <li>or <code>OK</code> (0)</li>

+	 * </ul>

+	 */

+	private int severity = OK;

+	

+	/** Unique identifier of plug-in.

+	 */

+	private String pluginId;

+	

+	/** Plug-in-specific status code.

+	 */

+	private int code;

+

+	/** Message, localized to the current locale.

+	 */

+	private String message;

+

+	/** Wrapped exception, or <code>null</code> if none.

+	 */

+	private Throwable exception = null;

+

+	/** Constant to avoid generating garbage.

+	 */

+	private static final IStatus[] theEmptyStatusArray = new IStatus[0];

+/**

+ * Creates a new status object.  The created status has no children.

+ *

+ * @param severity the severity; one of <code>OK</code>,

+ *   <code>ERROR</code>, <code>INFO</code>, or <code>WARNING</code>

+ * @param pluginId the unique identifier of the relevant plug-in

+ * @param code the plug-in-specific status code, or <code>OK</code>

+ * @param message a human-readable message, localized to the

+ *    current locale

+ * @param exception a low-level exception, or <code>null</code> if not

+ *    applicable 

+ */

+public Status(int severity, String pluginId, int code, String message, Throwable exception) {

+	setSeverity(severity);

+	setPlugin(pluginId);

+	setCode(code);

+	setMessage(message);

+	setException(exception);

+}

+/* (Intentionally not javadoc'd)

+ * Implements the corresponding method on <code>IStatus</code>.

+ */

+public IStatus[] getChildren() {

+	return theEmptyStatusArray;

+}

+/* (Intentionally not javadoc'd)

+ * Implements the corresponding method on <code>IStatus</code>.

+ */

+public int getCode() {

+	return code;

+}

+/* (Intentionally not javadoc'd)

+ * Implements the corresponding method on <code>IStatus</code>.

+ */

+public Throwable getException() {

+	return exception;

+}

+/* (Intentionally not javadoc'd)

+ * Implements the corresponding method on <code>IStatus</code>.

+ */

+public String getMessage() {

+	return message;

+}

+/* (Intentionally not javadoc'd)

+ * Implements the corresponding method on <code>IStatus</code>.

+ */

+public String getPlugin() {

+	return pluginId;

+}

+/* (Intentionally not javadoc'd)

+ * Implements the corresponding method on <code>IStatus</code>.

+ */

+public int getSeverity() {

+	return severity;

+}

+/* (Intentionally not javadoc'd)

+ * Implements the corresponding method on <code>IStatus</code>.

+ */

+public boolean isMultiStatus() {

+	return false;

+}

+/* (Intentionally not javadoc'd)

+ * Implements the corresponding method on <code>IStatus</code>.

+ */

+public boolean isOK() {

+	return severity == OK;

+}

+/* (Intentionally not javadoc'd)

+ * Implements the corresponding method on <code>IStatus</code>.

+ */

+public boolean matches(int severityMask) {

+	return (severity & severityMask) != 0;

+}

+/**

+ * Sets the status code.

+ *

+ * @param code the plug-in-specific status code, or <code>OK</code>

+ */

+protected void setCode(int code) {

+	this.code = code;

+}

+/**

+ * Sets the exception.

+ *

+ * @param exception a low-level exception, or <code>null</code> if not

+ *    applicable 

+ */

+protected void setException(Throwable exception) {

+	this.exception = exception;

+}

+/**

+ * Sets the message.

+ *

+ * @param message a human-readable message, localized to the

+ *    current locale

+ */

+protected void setMessage(String message) {

+	Assert.isLegal(message != null);

+	this.message = message;

+}

+/**

+ * Sets the plug-in id.

+ *

+ * @param pluginId the unique identifier of the relevant plug-in

+ */

+protected void setPlugin(String pluginId) {

+	Assert.isLegal(pluginId != null && pluginId.length() > 0);

+	this.pluginId = pluginId;

+}

+/**

+ * Sets the severity.

+ *

+ * @param severity the severity; one of <code>OK</code>,

+ *   <code>ERROR</code>, <code>INFO</code>, or <code>WARNING</code>

+ */

+protected void setSeverity(int severity) {

+	Assert.isLegal(severity == OK || severity == ERROR || severity == WARNING || severity == INFO);

+	this.severity = severity;

+}

+/**

+ * Returns a string representation of the status, suitable 

+ * for debugging purposes only.

+ */

+public String toString() {

+	StringBuffer buf = new StringBuffer();

+	buf.append("Status ");

+	if (severity == OK) {

+		buf.append("OK");

+	} else if (severity == ERROR) {

+		buf.append("ERROR");

+	} else if (severity == WARNING) {

+		buf.append("WARNING");

+	} else if (severity == INFO) {

+		buf.append("INFO");

+	} else {

+		buf.append("severity=");

+		buf.append(severity);

+	}

+	buf.append(pluginId);

+	buf.append(" code=");

+	buf.append(code);

+	buf.append(" ");

+	buf.append(message);

+	buf.append(" ");

+	buf.append(exception);

+	return buf.toString();

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/SubProgressMonitor.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/SubProgressMonitor.java
new file mode 100644
index 0000000..9692e97
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/SubProgressMonitor.java
@@ -0,0 +1,164 @@
+package org.eclipse.core.runtime;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * A progress monitor that uses the a given amount of work ticks

+ * form a parent monitor. It can be used as follows:

+ * <pre>

+ *     try {

+ *         pm.beginTask("Main Task", 100);

+ *         doSomeWork(pm, 30);

+ *         SubProgressMonitor subMonitor= new SubProgressMonitor(pm, 40);

+ *         try {

+ *             subMonitor.beginTask("", 300);

+ *             doSomeWork(subMonitor, 300);

+ *         } finally {

+ *             subMonitor.done();

+ *         }

+ *         doSomeWork(pm, 30);

+ *     } finally {

+ *         pm.done();

+ *     }

+ * </pre>

+ * <p>

+ * This class may be instantiated or subclassed by clients.

+  * </p>

+ */

+public class SubProgressMonitor extends ProgressMonitorWrapper {

+

+	/**

+	 * Style constant indicating that calls to <code>subTask</code>

+	 * should not have any effect.

+	 *

+	 * @see #SubProgressMonitor(IProgressMonitor,int,int)

+	 */

+	public static final int SUPPRESS_SUBTASK_LABEL= 1 << 1;

+	/**

+	 * Style constant indicating that the main task label 

+	 * should be prepended to the subtask label.

+	 *

+	 * @see #SubProgressMonitor(IProgressMonitor,int,int)

+	 */

+	public static final int PREPEND_MAIN_LABEL_TO_SUBTASK= 1 << 2;

+

+	private int parentTicks = 0;

+	private double sentToParent = 0.0;

+	private double scale = 0.0;

+	private int nestedBeginTasks = 0;

+	private boolean usedUp = false;

+	private int style;

+	private String mainTaskLabel;

+

+/**

+ * Creates a new sub-progress monitor for the given monitor. The sub 

+ * progress monitor uses the given number of work ticks from its 

+ * parent monitor.

+ *

+ * @param monitor the parent progress monitor

+ * @param ticks the number of work ticks allocated from the

+ *    parent monitor

+ */

+public SubProgressMonitor(IProgressMonitor monitor, int ticks) {

+	this(monitor, ticks, 0);

+}

+/**

+ * Creates a new sub-progress monitor for the given monitor. The sub 

+ * progress monitor uses the given number of work ticks from its 

+ * parent monitor.

+ *

+ * @param monitor the parent progress monitor

+ * @param ticks the number of work ticks allocated from the

+ *    parent monitor

+ * @param styles one of

+ *    <ul>

+ *    <li> <code>SUPPRESS_SUBTASK_LABEL</code> </li>

+ *    <li> <code>PREPEND_MAIN_LABEL_TO_SUBTASK</code> </li>

+ *    </ul>

+ * @see #SUPPRESS_SUBTASK_LABEL

+ * @see #PREPEND_MAIN_LABEL_TO_SUBTASK

+ */

+public SubProgressMonitor(IProgressMonitor monitor, int ticks, int style) {

+	super(monitor);

+	this.parentTicks = ticks;

+	this.style = style;

+}

+/* (Intentionally not javadoc'd)

+ * Implements the method <code>IProgressMonitor.beginTask</code>.

+ *

+ * Starts a new main task. Since this progress monitor is a sub

+ * progress monitor, the given name will NOT be used to update

+ * the progress bar's main task label. That means the given 

+ * string will be ignored. If style <code>PREPEND_MAIN_LABEL_TO_SUBTASK

+ * <code> is specified, then the given string will be prepended to

+ * every string passed to <code>subTask(String)</code>.

+ */

+public void beginTask(String name, int totalWork) {

+	nestedBeginTasks++;

+	// Ignore nested begin task calls.

+	if (nestedBeginTasks > 1) {

+		return;

+	}

+	// be safe:  if the argument would cause math errors (zero or 

+	// negative), just use 0 as the scale.  This disables progress for

+	// this submonitor. 

+	scale = totalWork <= 0 ? 0 : (double) parentTicks / (double) totalWork;

+	if ((style & PREPEND_MAIN_LABEL_TO_SUBTASK) != 0) {

+		mainTaskLabel = name;

+	}

+}

+/* (Intentionally not javadoc'd)

+ * Implements the method <code>IProgressMonitor.done</code>.

+ */

+public void done() {

+	// Ignore if more done calls than beginTask calls or if we are still

+	// in some nested beginTasks

+	if (nestedBeginTasks == 0 || --nestedBeginTasks > 0)

+		return;

+	// Send any remaining ticks and clear out the subtask text

+	double remaining = (double) parentTicks - sentToParent;

+	if (remaining > 0) 

+		super.internalWorked(remaining);

+	subTask("");

+	sentToParent = 0;

+}

+/* (Intentionally not javadoc'd)

+ * Implements the internal method <code>IProgressMonitor.internalWorked</code>.

+ */

+public void internalWorked(double work) {

+	if (usedUp || nestedBeginTasks != 1) {

+		return;

+	}

+

+	double realWork = scale * work;

+	// System.out.println("Sub monitor: " + realWork);

+	super.internalWorked(realWork);

+	sentToParent += realWork;

+	if (sentToParent >= parentTicks) {

+		usedUp = true;

+	}

+}

+/* (Intentionally not javadoc'd)

+ * Implements the method <code>IProgressMonitor.subTask</code>.

+ */

+public void subTask(String name) {

+	if ((style & SUPPRESS_SUBTASK_LABEL) != 0) {

+		return;

+	}

+

+	String label = name;

+	if ((style & PREPEND_MAIN_LABEL_TO_SUBTASK) != 0 && mainTaskLabel != null && mainTaskLabel.length() > 0) {

+		label = mainTaskLabel + " " + label;

+	}

+	super.subTask(label);

+}

+/* (Intentionally not javadoc'd)

+ * Implements the method <code>IProgressMonitor.worked</code>.

+ */

+public void worked(int work) {

+	internalWorked(work);

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ComponentModel.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ComponentModel.java
new file mode 100644
index 0000000..754514f
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ComponentModel.java
@@ -0,0 +1,122 @@
+package org.eclipse.core.runtime.model;
+

+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved.
+ */
+
+import org.eclipse.core.runtime.PluginVersionIdentifier;
+

+/**

+ * An object which represents the user-defined contents of a component model

+ * in a component manifest.

+ * <p>

+ * This class may be instantiated and further subclassed.

+ * </p>

+ */

+

+public class ComponentModel extends InstallModel {

+

+	// DTD properties (included in install manifest)

+	private boolean allowUpgrade = false;

+	private boolean optional = false;

+	private PluginDescriptorModel[] plugins = new PluginDescriptorModel[0];

+	private PluginFragmentModel[] fragments = new PluginFragmentModel[0];

+

+/**

+ * Returns whether this component can be upgraded within its configuration.

+ *

+ * @return whether this component is upgradeable

+ */

+public boolean getAllowUpgrade() {

+	return allowUpgrade;

+}

+

+/**

+ * Returns whether this component is optional within its configuration.

+ *

+ * @return whether this component is optional

+ */

+public boolean getOptional() {

+	return optional;

+}

+

+/**

+ * Returns the list of plug-ins managed by this component.

+ *

+ * @return the plug-ins in this component

+ */

+public PluginDescriptorModel[] getPlugins() {

+	return plugins;

+}

+

+/**

+ * Returns the list of fragments managed by this component.

+ *

+ * @return the fragments in this component

+ */

+public PluginFragmentModel[] getFragments() {

+	return fragments;

+}

+

+/**

+ * Sets this model object and all of its descendents to be read-only.

+ * Subclasses may extend this implementation.

+ *

+ * @see #isReadOnly

+ */

+public void markReadOnly() {

+	super.markReadOnly();

+	if (plugins != null)

+		for (int i = 0; i < plugins.length; i++)

+			plugins[i].markReadOnly();

+	if (fragments != null)

+		for (int i = 0; i < fragments.length; i++)

+			fragments[i].markReadOnly();

+}

+

+/**

+ * Sets whether this component can be upgraded within its configuration.

+ * This object must not be read-only.

+ *

+ * @param value whether this component is upgradeable

+ */

+public void setAllowUpgrade(boolean value) {

+	assertIsWriteable();

+	allowUpgrade = value;

+}

+

+/**

+ * Sets whether this component is optional within its configuration.

+ * This object must not be read-only.

+ *

+ * @param value whether this component is optional

+ */

+public void setOptional(boolean value) {

+	assertIsWriteable();

+	optional = value;

+}

+

+/**

+ * Sets the list of plug-ins managed by this component.

+ * This object must not be read-only.

+ *

+ * @param value the plug-ins managed by this component

+ */

+public void setPlugins(PluginDescriptorModel[] value) {

+	assertIsWriteable();

+	plugins = value;

+}

+

+/**

+ * Sets the list of fragments managed by this component.

+ * This object must not be read-only.

+ *

+ * @param value the fragments managed by this component

+ */

+public void setFragments(PluginFragmentModel[] value) {

+	assertIsWriteable();

+	fragments = value;

+}

+

+}
diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ConfigurationElementModel.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ConfigurationElementModel.java
new file mode 100644
index 0000000..ee1841d
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ConfigurationElementModel.java
@@ -0,0 +1,138 @@
+package org.eclipse.core.runtime.model;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * An object which represents the user-defined contents of an extension

+ * in a plug-in manifest.

+ * <p>

+ * This class may be instantiated, or further subclassed.

+ * </p>

+ */

+

+public class ConfigurationElementModel extends PluginModelObject {

+

+	// DTD properties (included in plug-in manifest)

+	private String value = null;

+	private ConfigurationPropertyModel[] properties = null;

+	private ConfigurationElementModel[] children = null;

+

+	// transient properties (not included in plug-in manifest)

+	private Object parent = null; // parent element or declaring extension

+/**

+ * Creates a new configuration element model in which all fields

+ * are <code>null</code>.

+ */

+public ConfigurationElementModel() {}

+/**

+ * Returns the element which contains this element.  If this element

+ * is an immediate child of an extension, the

+ * returned value can be downcast to <code>ExtensionModel</code>.

+ * Otherwise the returned value can be downcast to 

+ * <code>ConfigurationElementModel</code>.

+ *

+ * @return the parent of this configuration element

+ *  or <code>null</code>

+ */

+public Object getParent() {

+	return parent;

+}

+/**

+ * Returns the extension in which this configuration element is declared.

+ * If this element is a top-level child of an extension, the returned value

+ * is equivalent to <code>getParent</code>.

+ *

+ * @return the extension in which this configuration element is declared

+ *  or <code>null</code>

+ */

+public ExtensionModel getParentExtension() {

+	Object p = getParent();

+	while (p != null && p instanceof ConfigurationElementModel)

+		p = ((ConfigurationElementModel) p).getParent();

+	return (ExtensionModel) p;

+}

+/**

+ * Returns the properties associated with this element.

+ *

+ * @return the properties associated with this element

+ *  or <code>null</code>

+ */

+public ConfigurationPropertyModel[] getProperties() {

+	return properties;

+}

+/**

+ * Returns this element's sub-elements.

+ *

+ * @return the sub-elements of this element or <code>null</code>

+ */

+public ConfigurationElementModel[] getSubElements() {

+	return children;

+}

+/**

+ * Returns the value of this element.

+ * 

+ * @return the value of this element or <code>null</code>

+ */

+public String getValue() {

+	return value;

+}

+/**

+ * Sets this model object and all of its descendents to be read-only.

+ * Subclasses may extend this implementation.

+ *

+ * @see #isReadOnly

+ */

+public void markReadOnly() {

+	super.markReadOnly();

+	if (children != null)

+		for (int i = 0; i < children.length; i++)

+			children[i].markReadOnly();

+	if (properties != null)

+		for (int i = 0; i < properties.length; i++)

+			properties[i].markReadOnly();

+}

+/**

+ * Sets the parent of this element.  The supplied parent is either

+ * an <code>ExtensionModel</code>, if this element is to be a 

+ * direct child of an extension, or another <code>ConfigurationElement</code>.

+ * This object must not be read-only.

+ *

+ * @param value the new parent of this element.  May be <code>null</code>.

+ */

+public void setParent(Object value) {

+	assertIsWriteable();

+	parent = value;

+}

+/**

+ * Sets the properties associated with this element.  This object must not be read-only.

+ *

+ * @param value the properties to associate with this element.  May be <code>null</code>.

+ */

+public void setProperties(ConfigurationPropertyModel[] value) {

+	assertIsWriteable();

+	properties = value;

+}

+/**

+ * Sets configuration elements contained by this element

+ * This object must not be read-only.

+ *

+ * @param value the configuration elements to be associated with this element.  

+ *		May be <code>null</code>.

+ */

+public void setSubElements(ConfigurationElementModel[] value) {

+	assertIsWriteable();

+	children = value;

+}

+/**

+ * Sets the value of this element.  This object must not be read-only.

+ * 

+ * @param value the new value of this element.  May be <code>null</code>.

+ */

+public void setValue(String value) {

+	assertIsWriteable();

+	this.value = value;

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ConfigurationModel.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ConfigurationModel.java
new file mode 100644
index 0000000..b7cc3ba
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ConfigurationModel.java
@@ -0,0 +1,77 @@
+package org.eclipse.core.runtime.model;
+

+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved.
+ */
+
+import org.eclipse.core.runtime.PluginVersionIdentifier;
+

+/**

+ * An object which represents the user-defined contents of a configuration model

+ * in a configuration manifest.

+ * <p>

+ * This class may be instantiated and further subclassed.

+ * </p>

+ */

+

+public class ConfigurationModel extends InstallModel {

+

+	// DTD properties (included in install manifest)

+	private String application = null;

+	private ComponentModel[] components = new ComponentModel[0];

+

+/**

+ * Returns the name of the application to be run for this configuration.

+ *

+ * @return the application to run for this configuration

+ */

+public String getApplication() {

+	return application;

+}

+

+/**

+ * Returns the list of components managed by this configuration.

+ *

+ * @return the components in this configuration

+ */

+public ComponentModel[] getComponents() {

+	return components;

+}

+

+/**

+ * Sets this model object and all of its descendents to be read-only.

+ * Subclasses may extend this implementation.

+ *

+ * @see #isReadOnly

+ */

+public void markReadOnly() {

+	super.markReadOnly();

+	if (components!= null)

+		for (int i = 0; i < components.length; i++)

+			components[i].markReadOnly();

+}

+

+/**

+ * Sets the application to run for this configuration.

+ * This object must not be read-only.

+ *

+ * @param value the application to run for this configuration

+ */

+public void setApplication(String value) {

+	assertIsWriteable();

+	application = value;

+}

+

+/**

+ * Sets the list of components managed by this configuration.

+ * This object must not be read-only.

+ *

+ * @param value the components managed by this configuration

+ */

+public void setComponents(ComponentModel[] value) {

+	assertIsWriteable();

+	components = value;

+}

+

+}
diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ConfigurationPropertyModel.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ConfigurationPropertyModel.java
new file mode 100644
index 0000000..c780813
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ConfigurationPropertyModel.java
@@ -0,0 +1,45 @@
+package org.eclipse.core.runtime.model;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * An object which represents the user-defined properties in a configuration

+ * element of a plug-in manifest.  Properties are <code>String</code>-based

+ * key/value pairs.

+ * <p>

+ * This class may be instantiated, or further subclassed.

+ * </p>

+ */

+public class ConfigurationPropertyModel extends PluginModelObject {

+

+	// DTD properties (included in plug-in manifest)

+	private String value = null;

+/**

+ * Creates a new configuration property model in which all fields

+ * are <code>null</code>.

+ */

+public ConfigurationPropertyModel() {

+}

+/**

+ * Returns the value of this property.

+ * 

+ * @return the value of this property

+ *  or <code>null</code>

+ */

+public String getValue() {

+	return value;

+}

+/**

+ * Sets the value of this property.

+ * This object must not be read-only.

+ * 

+ * @param value the new value of this property.  May be <code>null</code>.

+ */

+public void setValue(String value) {

+	assertIsWriteable();

+	this.value = value;

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ExtensionModel.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ExtensionModel.java
new file mode 100644
index 0000000..b27ada2
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ExtensionModel.java
@@ -0,0 +1,149 @@
+package org.eclipse.core.runtime.model;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * An object which represents the user-defined extension in a 

+ * plug-in manifest.  

+ * <p>

+ * This class may be instantiated, or further subclassed.

+ * </p>

+ */

+public class ExtensionModel extends PluginModelObject {

+

+	// DTD properties (included in plug-in manifest)

+	private String extensionPoint = null;

+	private String id = null;

+	private ConfigurationElementModel[] elements = null;

+

+	// transient properties (not included in plug-in manifest)

+	private PluginModel plugin = null; // declaring plugin

+/**

+ * Creates a new extension model in which all fields

+ * are <code>null</code>.

+ */

+public ExtensionModel() {}

+/**

+ * Returns the extension point with which this extension is associated.

+ *

+ * @return the extension point with which this extension is associated

+ *  or <code>null</code>

+ */

+public String getExtensionPoint() {

+	return extensionPoint;

+}

+/**

+ * Returns the simple identifier of this extension, or <code>null</code>

+ * if this extension does not have an identifier.

+ * This identifier is specified in the plug-in manifest as a non-empty

+ * string containing no period characters (<code>'.'</code>) and 

+ * must be unique within the defining plug-in.

+ *

+ * @return the simple identifier of the extension (e.g. <code>"main"</code>)

+ *  or <code>null</code>

+ */

+public String getId() {

+	return id;

+}

+/**

+ * Returns the plug-in model (descriptor or fragment) in which this extension is declared.

+ *

+ * @return the plug-in model in which this extension is declared

+ *  or <code>null</code>

+ */

+public PluginModel getParent() {

+	return plugin;

+}

+/**

+ * Returns the plug-in descriptor in which this extension is declared.

+ *

+ * @return the plug-in descriptor in which this extension is declared

+ *  or <code>null</code>

+ */

+public PluginDescriptorModel getParentPluginDescriptor() {

+	return (PluginDescriptorModel) plugin;

+}

+/**

+ * Returns the configuration element children of this extension.

+ *

+ * @return the configuration elements in this extension

+ *  or <code>null</code>

+ */

+public ConfigurationElementModel[] getSubElements() {

+	return elements;

+}

+/**

+ * Sets this model object and all of its descendents to be read-only.

+ * Subclasses may extend this implementation.

+ *

+ * @see #isReadOnly

+ */

+public void markReadOnly() {

+	super.markReadOnly();

+	if (elements != null)

+		for (int i = 0; i < elements.length; i++)

+			elements[i].markReadOnly();

+}

+/**

+ * Set the extension point with which this extension is associated.

+ * This object must not be read-only.

+ *

+ * @return the extension point with which this extension is associated.  

+ *		May be <code>null</code>.

+ */

+public void setExtensionPoint(String value) {

+	assertIsWriteable();

+	extensionPoint = value;

+}

+/**

+ * Sets the simple identifier of this extension, or <code>null</code>

+ * if this extension does not have an identifier.

+ * This identifier is specified in the plug-in manifest as a non-empty

+ * string containing no period characters (<code>'.'</code>) and 

+ * must be unique within the defining plug-in.

+ * This object must not be read-only.

+ *

+ * @param value the simple identifier of the extension (e.g. <code>"main"</code>).

+ *		May be <code>null</code>.

+ */

+public void setId(String value) {

+	assertIsWriteable();

+	id = value;

+}

+/**

+ * Sets the plug-in model in which this extension is declared.

+ * This object must not be read-only.

+ *

+ * @param value the plug-in model in which this extension is declared.  

+ *		May be <code>null</code>.

+ */

+public void setParent(PluginModel value) {

+	assertIsWriteable();

+	plugin = value;

+}

+/**

+ * Sets the plug-in descriptor in which this extension is declared.

+ * This object must not be read-only.

+ *

+ * @param value the plug-in descriptor in which this extension is declared.  

+ *		May be <code>null</code>.

+ */

+public void setParentPluginDescriptor(PluginDescriptorModel value) {

+	assertIsWriteable();

+	plugin = value;

+}

+/**

+ * Sets the configuration element children of this extension.

+ * This object must not be read-only.

+ *

+ * @param value the configuration elements in this extension.  

+ *		May be <code>null</code>.

+ */

+public void setSubElements(ConfigurationElementModel[] value) {

+	assertIsWriteable();

+	elements = value;

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ExtensionPointModel.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ExtensionPointModel.java
new file mode 100644
index 0000000..8c1752e
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/ExtensionPointModel.java
@@ -0,0 +1,135 @@
+package org.eclipse.core.runtime.model;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+/**

+ * An object which represents the user-defined extension point in a 

+ * plug-in manifest. 

+ * <p>

+ * This class may be instantiated, or further subclassed.

+ * </p>

+ */

+public class ExtensionPointModel extends PluginModelObject {

+

+	// DTD properties (included in plug-in manifest)

+	private String id = null;

+	private String schema = null;

+

+	// transient properties (not included in plug-in manifest)

+	private PluginModel plugin = null; // declaring plugin

+	private ExtensionModel[] extensions = null; // configured extensions

+/**

+ * Creates a new extension point model in which all fields

+ * are <code>null</code>.

+ */

+public ExtensionPointModel() {}

+/**

+ * Returns this extensions added to this extension point.

+ *

+ * @return the extensions in this extension point or <code>null</code>

+ */

+public ExtensionModel[] getDeclaredExtensions() {

+	return extensions;

+}

+/**

+ * Returns the simple identifier of this extension point, or <code>null</code>

+ * if this extension point does not have an identifier.

+ * This identifier is specified in the plug-in manifest as a non-empty

+ * string containing no period characters (<code>'.'</code>) and 

+ * must be unique within the defining plug-in.

+ *

+ * @return the simple identifier of the extension point (e.g. <code>"main"</code>)

+ *  or <code>null</code>

+ */

+public String getId() {

+	return id;

+}

+/**

+ * Returns the plug-in model (descriptor or fragment) in which this extension is declared.

+ *

+ * @return the plug-in model in which this extension is declared

+ *  or <code>null</code>

+ */

+public PluginModel getParent() {

+	return plugin;

+}

+/**

+ * Returns the plug-in descriptor in which this extension point is declared.

+ *

+ * @return the plug-in descriptor in which this extension point is declared

+ *  or <code>null</code>

+ */

+public PluginDescriptorModel getParentPluginDescriptor() {

+	return (PluginDescriptorModel) plugin;

+}

+/**

+ * Returns the schema specification for this extension point.

+ *

+ * @return the schema specification for this extension point or <code>null</code>

+ */

+public String getSchema() {

+	return schema;

+}

+/**

+ * Sets this extensions added to this extension point.

+ * This object must not be read-only.

+ *

+ * @param value the extensions in this extension point.

+ *		May be <code>null</code>.

+ */

+public void setDeclaredExtensions(ExtensionModel[] value) {

+	assertIsWriteable();

+	extensions = value;

+}

+/**

+ * Sets the simple identifier of this extension point, or <code>null</code>

+ * if this extension point does not have an identifier.

+ * This identifier is specified in the plug-in manifest as a non-empty

+ * string containing no period characters (<code>'.'</code>) and 

+ * must be unique within the defining plug-in.

+ * This object must not be read-only.

+ *

+ * @param value the simple identifier of the extension point (e.g. <code>"main"</code>).

+ *		May be <code>null</code>.

+ */

+public void setId(String value) {

+	assertIsWriteable();

+	id = value;

+}

+/**

+ * Sets the plug-in model in which this extension is declared.

+ * This object must not be read-only.

+ *

+ * @param value the plug-in model in which this extension is declared.  

+ *		May be <code>null</code>.

+ */

+public void setParent(PluginModel value) {

+	assertIsWriteable();

+	plugin = value;

+}

+/**

+ * Sets the plug-in descriptor in which this extension point is declared.

+ * This object must not be read-only.

+ *

+ * @param the plug-in descriptor in which this extension point is declared.  

+ * 		May be <code>null</code>.

+ */

+public void setParentPluginDescriptor(PluginDescriptorModel value) {

+	assertIsWriteable();

+	plugin = value;

+}

+/**

+ * Sets the schema specification for this extension point.

+ * This object must not be read-only.

+ *

+ * @param value the schema specification for this extension point.

+ *		May be <code>null</code>.

+ */

+public void setSchema(String value) {

+	assertIsWriteable();

+	schema = value;

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/Factory.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/Factory.java
new file mode 100644
index 0000000..db5e7b4
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/Factory.java
@@ -0,0 +1,156 @@
+package org.eclipse.core.runtime.model;

+

+/*

+ * (c) Copyright IBM Corp. 2000, 2001.

+ * All Rights Reserved.

+ */

+

+import org.eclipse.core.runtime.*;

+import org.eclipse.core.internal.runtime.InternalPlatform;

+import org.eclipse.core.runtime.model.*;

+import org.eclipse.core.internal.plugins.RegistryResolver;

+

+/**

+ * An object which can create plug-in related model objects (typically when

+ * parsing plug-in manifest files).

+ * <p>

+ * This class may be instantiated, or further subclassed.

+ * </p>

+ */

+

+public class Factory {

+	private MultiStatus status;

+/**

+ * Creates a factory which can be used to create plug-in model objects.

+ * Errors and warnings during parsing etc. can be logged to the given 

+ * status via the <code>error</code> method.

+ *

+ * @param status the status to which errors should be logged

+ */

+public Factory(MultiStatus status) {

+	super();

+	this.status = status;

+}

+

+/**

+ * Returns a new component model which is not initialized.

+ *

+ * @return a new component model

+ */

+public ComponentModel createComponentModel() {

+	return new ComponentModel();

+}

+

+/**

+ * Returns a new configuration model which is not initialized.

+ *

+ * @return a new configuration model

+ */

+public ConfigurationModel createConfiguration() {

+	return new ConfigurationModel();

+}

+

+/**

+ * Returns a new configuration element model which is not initialized.

+ *

+ * @return a new configuration element model

+ */

+public ConfigurationElementModel createConfigurationElement() {

+	return new ConfigurationElementModel();

+}

+/**

+ * Returns a new configuration property model which is not initialized.

+ *

+ * @return a new configuration property model

+ */

+public ConfigurationPropertyModel createConfigurationProperty() {

+	return new ConfigurationPropertyModel();

+}

+/**

+ * Returns a new extension model which is not initialized.

+ *

+ * @return a new extension model

+ */

+public ExtensionModel createExtension() {

+	return new ExtensionModel();

+}

+/**

+ * Returns a new extension point model which is not initialized.

+ *

+ * @return a new extension point model

+ */

+public ExtensionPointModel createExtensionPoint() {

+	return new ExtensionPointModel();

+}

+/**

+ * Returns a new library model which is initialized to not export any

+ * of its code.

+ *

+ * @return a new library model

+ */

+public LibraryModel createLibrary() {

+	return new LibraryModel();

+}

+/**

+ * Returns a new plug-in descriptor model which is not initialized.

+ *

+ * @return a new plug-in descriptor model

+ */

+public PluginDescriptorModel createPluginDescriptor() {

+	return new PluginDescriptorModel();

+}

+/**

+ * Returns a new plug-in fragment model which is not initialized.

+ *

+ * @return a new plug-in fragment model

+ */

+public PluginFragmentModel createPluginFragment() {

+	return new PluginFragmentModel();

+}

+/**

+ * Returns a new plug-in prerequisite model which is initialized to

+ * not export its code and to not require an exact match.

+ *

+ * @return a new plug-in prerequisite model

+ */

+public PluginPrerequisiteModel createPluginPrerequisite() {

+	return new PluginPrerequisiteModel();

+}

+/**

+ * Returns a new plug-in registry model with an empty plug-in table.

+ *

+ * @return a new plug-in registry model

+ */

+public PluginRegistryModel createPluginRegistry() {

+	return new PluginRegistryModel();

+}

+

+/**

+ * Returns a new URL model which is not initialized.

+ *

+ * @return a new URL model

+ */

+public URLModel createURL() {

+	return new URLModel();

+}

+

+/**

+ * Handles an error state specified by the status.  The collection of all logged status

+ * objects can be accessed using <code>getStatus()</code>.

+ *

+ * @param error a status detailing the error condition

+ */

+public void error(IStatus error) {

+	status.add(error);

+	if (InternalPlatform.DEBUG && InternalPlatform.DEBUG_PLUGINS)

+		System.out.println(error.toString());

+}

+/**

+ * Returns all of the status objects logged thus far by this factory.

+ *

+ * @return a multi-status containing all of the logged status objects

+ */

+public MultiStatus getStatus() {

+	return status;

+}

+}

diff --git a/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/InstallModel.java b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/InstallModel.java
new file mode 100644
index 0000000..2f3b913
--- /dev/null
+++ b/bundles/org.eclipse.core.runtime/src/org/eclipse/core/runtime/model/InstallModel.java
@@ -0,0 +1,201 @@
+package org.eclipse.core.runtime.model;
+

+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved.
+ */
+
+import org.eclipse.core.runtime.PluginVersionIdentifier;
+

+/**

+ * An abstract class representing the common parts of the various install

+ * manifest structures.

+ * <p>

+ * This class may not be instantiated but may be further subclassed.

+ * </p>

+ */

+

+public abstract class InstallModel extends PluginModelObject {

+

+	// DTD properties (included in install manifest)

+	private String id = null;

+	private String version = null;

+	private String providerName = null;

+	private String description = null;

+	private String location = null;

+	private URLModel[] updates = new URLModel[0];

+	private URLModel[] discoveries = new URLModel[0];

+

+/**

+ * Returns the unique identifier of this component model

+ * or <code>null</code>.

+ * This identifier is a non-empty string and is unique 

+ * across all components.

+ *

+ * @return the unique identifier of this component model

+ *		(e.g. <code>"com.example"</code>) or <code>null</code>. 

+ */

+public String getId() {

+	return id;

+}

+

+/**

+ * Returns the location of this component.

+ *

+ * @return the location of this component or <code>null</code>

+ */

+public String getLocation() {

+	return location;

+}

+

+/**

+ * Returns the version name of this component.

+ *

+ * @return the version name of this component or <code>null</code>

+ */

+public String getVersion() {

+	return version;

+}

+

+/**

+ * Returns the name of the provider who authored this component.

+ *

+ * @return name of the provider who authored this component or <code>null</code>

+ */

+public String getProviderName() {

+	return providerName;

+}

+

+/**

+ * Returns the description of this component.

+ *

+ * @return description of this component or <code>null</code>

+ */

+public String getDescription() {