<classpathentry kind="src" path="Eclipse UI/"/>

	<classpathentry kind="src" path="Eclipse UI">

	<classpathentry kind="src" path="Eclipse UI Editor Support/"/>

		<attributes>

	<classpathentry kind="src" path="Eclipse UI Components/"/>

		</attributes>

	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>

	</classpathentry>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>

	<classpathentry kind="src" path="Eclipse UI Editor Support">

		<attributes>

		</attributes>

	</classpathentry>

	<classpathentry kind="src" path="Eclipse UI Components">

		<attributes>

		</attributes>

	</classpathentry>

	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins">

		<attributes>

		</attributes>

	</classpathentry>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER">

		<attributes>

		</attributes>

	</classpathentry>

import java.io.IOException;

import java.io.*;

import java.io.Reader;

import java.util.*;

import java.io.Writer;

import javax.xml.parsers.*;

import java.util.ArrayList;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.transform.OutputKeys;

import javax.xml.transform.Result;

import javax.xml.transform.Source;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerConfigurationException;

import javax.xml.transform.TransformerException;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Attr;

import org.w3c.dom.*;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.w3c.dom.Text;

            throw new Error(e);

//            throw new Error(e);

            throw new Error(e.getMessage());

        Result result = new StreamResult(writer);

    	DOMWriter out = new DOMWriter(writer);

        Source source = new DOMSource(factory);

            Transformer transformer = TransformerFactory.newInstance()

    		save(element, out);

                    .newTransformer();

    	} finally {

            transformer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$

    		out.close();

            transformer.setOutputProperty(OutputKeys.METHOD, "xml"); //$NON-NLS-1$

    	}

            transformer.transform(source, result);

	}

        } catch (TransformerConfigurationException e) {

            throw (IOException) (new IOException().initCause(e));

    private void save(Element element, DOMWriter out) {

        } catch (TransformerException e) {

    	out.startTag(element);

            throw (IOException) (new IOException().initCause(e));

    	NodeList children = element.getChildNodes();

        }

		for (int i = 0; i < children.getLength(); i++) 

			save ((Element)children.item(i), out);

		out.endTag(element);

	}

	/**

     * A simple XML writer.

     */

    private static class DOMWriter extends PrintWriter {

    	protected int tab;

    	/* constants */

    	protected static final String XML_VERSION = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"; //$NON-NLS-1$

    	public DOMWriter(Writer output) throws UnsupportedEncodingException {

    		super(output);

    		tab = 0;

    		println(XML_VERSION);

    	}

    	public void endTag(Element element) {

    		tab--;

    		if (!element.hasChildNodes())

    			return;

    		StringBuffer sb = new StringBuffer();

    		sb.append("</"); //$NON-NLS-1$

    		sb.append(element.getNodeName());

    		sb.append(">"); //$NON-NLS-1$

   			printTabulation();

   			println(sb.toString());

    	}

    	public void printTabulation() {

    		for (int i = 0; i < tab; i++)

    			super.print("  "); //$NON-NLS-1$

    	}

    	public void printTag(Element element, boolean shouldTab, boolean newLine) {

    		StringBuffer sb = new StringBuffer();

    		sb.append("<"); //$NON-NLS-1$

    		sb.append(element.getTagName());

    		NamedNodeMap attributes = element.getAttributes();

   			for (int i = 0;  i < attributes.getLength(); i++) {

   				Attr attribute = (Attr)attributes.item(i);

				sb.append(" "); //$NON-NLS-1$

				sb.append(attribute.getName());

				sb.append("=\""); //$NON-NLS-1$

				sb.append(getEscaped(String.valueOf(attribute.getValue())));

				sb.append("\""); //$NON-NLS-1$

   			}

   			sb.append(element.hasChildNodes() ? ">" : "/>"); //$NON-NLS-1$ //$NON-NLS-2$

    		if (shouldTab)

    			printTabulation();

    		if (newLine)

    			println(sb.toString());

    		else

    			print(sb.toString());

    	}

    	public void startTag(Element element) {

    		printTag(element, true, true);

    		tab++;

    	}

    	private static void appendEscapedChar(StringBuffer buffer, char c) {

    		String replacement = getReplacement(c);

    		if (replacement != null) {

    			buffer.append('&');

    			buffer.append(replacement);

    			buffer.append(';');

    		} else {

    			buffer.append(c);

    		}

    	}

    	public static String getEscaped(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"; //$NON-NLS-1$

    			case '>' :

    				return "gt"; //$NON-NLS-1$

    			case '"' :

    				return "quot"; //$NON-NLS-1$

    			case '\'' :

    				return "apos"; //$NON-NLS-1$

    			case '&' :

    				return "amp"; //$NON-NLS-1$

    		}

    		return null;

    	}