first commit

rus/WEB-INF/lib/jsr173_api_src/META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Created-By: 1.4.2_01 (Sun Microsystems Inc.)
+

rus/WEB-INF/lib/jsr173_api_src/javax/xml/XMLConstants.java

@@ -0,0 +1,13 @@
+package javax.xml;
+
+public class XMLConstants {
+  public static final String DEFAULT_NS_PREFIX = "";
+  
+  public static final String XML_NS_PREFIX = "xml";
+  
+  public static final String XML_NS_URI = "http://www.w3.org/XML/1998/namespace";
+  
+  public static final String XMLNS_ATTRIBUTE = "xmlns";
+  
+  public static final String XMLNS_ATTRIBUTE_NS_URI = "http://www.w3.org/2000/xmlns/";
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/namespace/NamespaceContext.java

@@ -0,0 +1,11 @@
+package javax.xml.namespace;
+
+import java.util.Iterator;
+
+public interface NamespaceContext {
+  String getNamespaceURI(String paramString);
+  
+  String getPrefix(String paramString);
+  
+  Iterator getPrefixes(String paramString);
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/namespace/QName.java

@@ -0,0 +1,76 @@
+package javax.xml.namespace;
+
+import java.io.Serializable;
+
+public class QName implements Serializable {
+  private String namespaceURI;
+  
+  private String localPart;
+  
+  private String prefix;
+  
+  public QName(String localPart) {
+    this("", localPart);
+  }
+  
+  public QName(String namespaceURI, String localPart) {
+    this(namespaceURI, localPart, "");
+  }
+  
+  public QName(String namespaceURI, String localPart, String prefix) {
+    if (localPart == null)
+      throw new IllegalArgumentException("Local part not allowed to be null"); 
+    if (namespaceURI == null)
+      namespaceURI = ""; 
+    if (prefix == null)
+      prefix = ""; 
+    this.namespaceURI = namespaceURI;
+    this.localPart = localPart;
+    this.prefix = prefix;
+  }
+  
+  public String getNamespaceURI() {
+    return this.namespaceURI;
+  }
+  
+  public String getLocalPart() {
+    return this.localPart;
+  }
+  
+  public String getPrefix() {
+    return this.prefix;
+  }
+  
+  public String toString() {
+    if (this.namespaceURI.equals(""))
+      return this.localPart; 
+    return "{" + this.namespaceURI + "}" + this.localPart;
+  }
+  
+  public static QName valueOf(String s) {
+    if (s == null || s.equals(""))
+      throw new IllegalArgumentException("invalid QName literal"); 
+    if (s.charAt(0) == '{') {
+      int i = s.indexOf('}');
+      if (i == -1)
+        throw new IllegalArgumentException("invalid QName literal"); 
+      if (i == s.length() - 1)
+        throw new IllegalArgumentException("invalid QName literal"); 
+      return new QName(s.substring(1, i), s.substring(i + 1));
+    } 
+    return new QName(s);
+  }
+  
+  public final int hashCode() {
+    return this.namespaceURI.hashCode() ^ this.localPart.hashCode();
+  }
+  
+  public final boolean equals(Object obj) {
+    if (obj == null)
+      return false; 
+    if (!(obj instanceof QName))
+      return false; 
+    QName qname = (QName)obj;
+    return (this.localPart.equals(qname.localPart) && this.namespaceURI.equals(qname.namespaceURI));
+  }
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/EventFilter.java

@@ -0,0 +1,7 @@
+package javax.xml.stream;
+
+import javax.xml.stream.events.XMLEvent;
+
+public interface EventFilter {
+  boolean accept(XMLEvent paramXMLEvent);
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/FactoryConfigurationError.java

@@ -0,0 +1,41 @@
+package javax.xml.stream;
+
+public class FactoryConfigurationError extends Error {
+  Exception nested;
+  
+  public FactoryConfigurationError() {}
+  
+  public FactoryConfigurationError(Exception e) {
+    this.nested = e;
+  }
+  
+  public FactoryConfigurationError(Exception e, String msg) {
+    super(msg);
+    this.nested = e;
+  }
+  
+  public FactoryConfigurationError(String msg, Exception e) {
+    super(msg);
+    this.nested = e;
+  }
+  
+  public FactoryConfigurationError(String msg) {
+    super(msg);
+  }
+  
+  public Exception getException() {
+    return this.nested;
+  }
+  
+  public String getMessage() {
+    String msg = super.getMessage();
+    if (msg != null)
+      return msg; 
+    if (this.nested != null) {
+      msg = this.nested.getMessage();
+      if (msg == null)
+        msg = this.nested.getClass().toString(); 
+    } 
+    return msg;
+  }
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/FactoryFinder.java

@@ -0,0 +1,131 @@
+package javax.xml.stream;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.Properties;
+
+class FactoryFinder {
+  private static boolean debug = false;
+  
+  static {
+    try {
+      debug = (System.getProperty("xml.stream.debug") != null);
+    } catch (Exception x) {}
+  }
+  
+  private static void debugPrintln(String msg) {
+    if (debug)
+      System.err.println("STREAM: " + msg); 
+  }
+  
+  private static ClassLoader findClassLoader() throws FactoryConfigurationError {
+    ClassLoader classLoader;
+    try {
+      Class clazz = Class.forName(FactoryFinder.class.getName() + "$ClassLoaderFinderConcrete");
+      ClassLoaderFinder clf = (ClassLoaderFinder)clazz.newInstance();
+      classLoader = clf.getContextClassLoader();
+    } catch (LinkageError le) {
+      classLoader = FactoryFinder.class.getClassLoader();
+    } catch (ClassNotFoundException x) {
+      classLoader = FactoryFinder.class.getClassLoader();
+    } catch (Exception x) {
+      throw new FactoryConfigurationError(x.toString(), x);
+    } 
+    return classLoader;
+  }
+  
+  private static Object newInstance(String className, ClassLoader classLoader) throws FactoryConfigurationError {
+    try {
+      Class clazz;
+      if (classLoader == null) {
+        clazz = Class.forName(className);
+      } else {
+        clazz = classLoader.loadClass(className);
+      } 
+      return clazz.newInstance();
+    } catch (ClassNotFoundException x) {
+      throw new FactoryConfigurationError("Provider " + className + " not found", x);
+    } catch (Exception x) {
+      throw new FactoryConfigurationError("Provider " + className + " could not be instantiated: " + x, x);
+    } 
+  }
+  
+  static Object find(String factoryId) throws FactoryConfigurationError {
+    return find(factoryId, null);
+  }
+  
+  static Object find(String factoryId, String fallbackClassName) throws FactoryConfigurationError {
+    ClassLoader classLoader = findClassLoader();
+    return find(factoryId, fallbackClassName, classLoader);
+  }
+  
+  static Object find(String factoryId, String fallbackClassName, ClassLoader classLoader) throws FactoryConfigurationError {
+    try {
+      String systemProp = System.getProperty(factoryId);
+      if (systemProp != null) {
+        debugPrintln("found system property" + systemProp);
+        return newInstance(systemProp, classLoader);
+      } 
+    } catch (SecurityException se) {}
+    try {
+      String javah = System.getProperty("java.home");
+      String configFile = javah + File.separator + "lib" + File.separator + "jaxp.properties";
+      File f = new File(configFile);
+      if (f.exists()) {
+        Properties props = new Properties();
+        props.load(new FileInputStream(f));
+        String factoryClassName = props.getProperty(factoryId);
+        debugPrintln("found java.home property " + factoryClassName);
+        return newInstance(factoryClassName, classLoader);
+      } 
+    } catch (Exception ex) {
+      if (debug)
+        ex.printStackTrace(); 
+    } 
+    String serviceId = "META-INF/services/" + factoryId;
+    try {
+      InputStream is = null;
+      if (classLoader == null) {
+        is = ClassLoader.getSystemResourceAsStream(serviceId);
+      } else {
+        is = classLoader.getResourceAsStream(serviceId);
+      } 
+      if (is != null) {
+        debugPrintln("found " + serviceId);
+        BufferedReader rd = new BufferedReader(new InputStreamReader(is, "UTF-8"));
+        String factoryClassName = rd.readLine();
+        rd.close();
+        if (factoryClassName != null && !"".equals(factoryClassName)) {
+          debugPrintln("loaded from services: " + factoryClassName);
+          return newInstance(factoryClassName, classLoader);
+        } 
+      } 
+    } catch (Exception ex) {
+      if (debug)
+        ex.printStackTrace(); 
+    } 
+    if (fallbackClassName == null)
+      throw new FactoryConfigurationError("Provider for " + factoryId + " cannot be found", null); 
+    debugPrintln("loaded from fallback value: " + fallbackClassName);
+    return newInstance(fallbackClassName, classLoader);
+  }
+  
+  private static abstract class ClassLoaderFinder {
+    private ClassLoaderFinder() {}
+    
+    abstract ClassLoader getContextClassLoader();
+    
+    ClassLoaderFinder(FactoryFinder.null x0) {
+      this();
+    }
+  }
+  
+  static class ClassLoaderFinderConcrete extends ClassLoaderFinder {
+    ClassLoader getContextClassLoader() {
+      return Thread.currentThread().getContextClassLoader();
+    }
+  }
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/Location.java

@@ -0,0 +1,13 @@
+package javax.xml.stream;
+
+public interface Location {
+  int getLineNumber();
+  
+  int getColumnNumber();
+  
+  int getCharacterOffset();
+  
+  String getPublicId();
+  
+  String getSystemId();
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/StreamFilter.java

@@ -0,0 +1,5 @@
+package javax.xml.stream;
+
+public interface StreamFilter {
+  boolean accept(XMLStreamReader paramXMLStreamReader);
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/XMLEventFactory.java

@@ -0,0 +1,79 @@
+package javax.xml.stream;
+
+import java.util.Iterator;
+import javax.xml.namespace.NamespaceContext;
+import javax.xml.namespace.QName;
+import javax.xml.stream.events.Attribute;
+import javax.xml.stream.events.Characters;
+import javax.xml.stream.events.Comment;
+import javax.xml.stream.events.DTD;
+import javax.xml.stream.events.EndDocument;
+import javax.xml.stream.events.EndElement;
+import javax.xml.stream.events.EntityDeclaration;
+import javax.xml.stream.events.EntityReference;
+import javax.xml.stream.events.Namespace;
+import javax.xml.stream.events.ProcessingInstruction;
+import javax.xml.stream.events.StartDocument;
+import javax.xml.stream.events.StartElement;
+
+public abstract class XMLEventFactory {
+  public static XMLEventFactory newInstance() throws FactoryConfigurationError {
+    return (XMLEventFactory)FactoryFinder.find("javax.xml.stream.XMLEventFactory", "com.bea.xml.stream.EventFactory");
+  }
+  
+  public static XMLEventFactory newInstance(String factoryId, ClassLoader classLoader) throws FactoryConfigurationError {
+    return (XMLEventFactory)FactoryFinder.find(factoryId, "com.bea.xml.stream.EventFactory", classLoader);
+  }
+  
+  public abstract void setLocation(Location paramLocation);
+  
+  public abstract Attribute createAttribute(String paramString1, String paramString2, String paramString3, String paramString4);
+  
+  public abstract Attribute createAttribute(String paramString1, String paramString2);
+  
+  public abstract Attribute createAttribute(QName paramQName, String paramString);
+  
+  public abstract Namespace createNamespace(String paramString);
+  
+  public abstract Namespace createNamespace(String paramString1, String paramString2);
+  
+  public abstract StartElement createStartElement(QName paramQName, Iterator paramIterator1, Iterator paramIterator2);
+  
+  public abstract StartElement createStartElement(String paramString1, String paramString2, String paramString3);
+  
+  public abstract StartElement createStartElement(String paramString1, String paramString2, String paramString3, Iterator paramIterator1, Iterator paramIterator2);
+  
+  public abstract StartElement createStartElement(String paramString1, String paramString2, String paramString3, Iterator paramIterator1, Iterator paramIterator2, NamespaceContext paramNamespaceContext);
+  
+  public abstract EndElement createEndElement(QName paramQName, Iterator paramIterator);
+  
+  public abstract EndElement createEndElement(String paramString1, String paramString2, String paramString3);
+  
+  public abstract EndElement createEndElement(String paramString1, String paramString2, String paramString3, Iterator paramIterator);
+  
+  public abstract Characters createCharacters(String paramString);
+  
+  public abstract Characters createCData(String paramString);
+  
+  public abstract Characters createSpace(String paramString);
+  
+  public abstract Characters createIgnorableSpace(String paramString);
+  
+  public abstract StartDocument createStartDocument();
+  
+  public abstract StartDocument createStartDocument(String paramString1, String paramString2, boolean paramBoolean);
+  
+  public abstract StartDocument createStartDocument(String paramString1, String paramString2);
+  
+  public abstract StartDocument createStartDocument(String paramString);
+  
+  public abstract EndDocument createEndDocument();
+  
+  public abstract EntityReference createEntityReference(String paramString, EntityDeclaration paramEntityDeclaration);
+  
+  public abstract Comment createComment(String paramString);
+  
+  public abstract ProcessingInstruction createProcessingInstruction(String paramString1, String paramString2);
+  
+  public abstract DTD createDTD(String paramString);
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/XMLEventReader.java

@@ -0,0 +1,20 @@
+package javax.xml.stream;
+
+import java.util.Iterator;
+import javax.xml.stream.events.XMLEvent;
+
+public interface XMLEventReader extends Iterator {
+  XMLEvent nextEvent() throws XMLStreamException;
+  
+  boolean hasNext();
+  
+  XMLEvent peek() throws XMLStreamException;
+  
+  String getElementText() throws XMLStreamException;
+  
+  XMLEvent nextTag() throws XMLStreamException;
+  
+  Object getProperty(String paramString) throws IllegalArgumentException;
+  
+  void close() throws XMLStreamException;
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/XMLEventWriter.java

@@ -0,0 +1,25 @@
+package javax.xml.stream;
+
+import javax.xml.namespace.NamespaceContext;
+import javax.xml.stream.events.XMLEvent;
+import javax.xml.stream.util.XMLEventConsumer;
+
+public interface XMLEventWriter extends XMLEventConsumer {
+  void flush() throws XMLStreamException;
+  
+  void close() throws XMLStreamException;
+  
+  void add(XMLEvent paramXMLEvent) throws XMLStreamException;
+  
+  void add(XMLEventReader paramXMLEventReader) throws XMLStreamException;
+  
+  String getPrefix(String paramString) throws XMLStreamException;
+  
+  void setPrefix(String paramString1, String paramString2) throws XMLStreamException;
+  
+  void setDefaultNamespace(String paramString) throws XMLStreamException;
+  
+  void setNamespaceContext(NamespaceContext paramNamespaceContext) throws XMLStreamException;
+  
+  NamespaceContext getNamespaceContext();
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/XMLInputFactory.java

@@ -0,0 +1,82 @@
+package javax.xml.stream;
+
+import java.io.InputStream;
+import java.io.Reader;
+import javax.xml.stream.util.XMLEventAllocator;
+import javax.xml.transform.Source;
+
+public abstract class XMLInputFactory {
+  public static final String IS_NAMESPACE_AWARE = "javax.xml.stream.isNamespaceAware";
+  
+  public static final String IS_VALIDATING = "javax.xml.stream.isValidating";
+  
+  public static final String IS_COALESCING = "javax.xml.stream.isCoalescing";
+  
+  public static final String IS_REPLACING_ENTITY_REFERENCES = "javax.xml.stream.isReplacingEntityReferences";
+  
+  public static final String IS_SUPPORTING_EXTERNAL_ENTITIES = "javax.xml.stream.isSupportingExternalEntities";
+  
+  public static final String SUPPORT_DTD = "javax.xml.stream.supportDTD";
+  
+  public static final String REPORTER = "javax.xml.stream.reporter";
+  
+  public static final String RESOLVER = "javax.xml.stream.resolver";
+  
+  public static final String ALLOCATOR = "javax.xml.stream.allocator";
+  
+  public static XMLInputFactory newInstance() throws FactoryConfigurationError {
+    return (XMLInputFactory)FactoryFinder.find("javax.xml.stream.XMLInputFactory", "com.bea.xml.stream.MXParserFactory");
+  }
+  
+  public static XMLInputFactory newInstance(String factoryId, ClassLoader classLoader) throws FactoryConfigurationError {
+    return (XMLInputFactory)FactoryFinder.find(factoryId, "com.bea.xml.stream.MXParserFactory", classLoader);
+  }
+  
+  public abstract XMLStreamReader createXMLStreamReader(Reader paramReader) throws XMLStreamException;
+  
+  public abstract XMLStreamReader createXMLStreamReader(Source paramSource) throws XMLStreamException;
+  
+  public abstract XMLStreamReader createXMLStreamReader(InputStream paramInputStream) throws XMLStreamException;
+  
+  public abstract XMLStreamReader createXMLStreamReader(InputStream paramInputStream, String paramString) throws XMLStreamException;
+  
+  public abstract XMLStreamReader createXMLStreamReader(String paramString, InputStream paramInputStream) throws XMLStreamException;
+  
+  public abstract XMLStreamReader createXMLStreamReader(String paramString, Reader paramReader) throws XMLStreamException;
+  
+  public abstract XMLEventReader createXMLEventReader(Reader paramReader) throws XMLStreamException;
+  
+  public abstract XMLEventReader createXMLEventReader(String paramString, Reader paramReader) throws XMLStreamException;
+  
+  public abstract XMLEventReader createXMLEventReader(XMLStreamReader paramXMLStreamReader) throws XMLStreamException;
+  
+  public abstract XMLEventReader createXMLEventReader(Source paramSource) throws XMLStreamException;
+  
+  public abstract XMLEventReader createXMLEventReader(InputStream paramInputStream) throws XMLStreamException;
+  
+  public abstract XMLEventReader createXMLEventReader(InputStream paramInputStream, String paramString) throws XMLStreamException;
+  
+  public abstract XMLEventReader createXMLEventReader(String paramString, InputStream paramInputStream) throws XMLStreamException;
+  
+  public abstract XMLStreamReader createFilteredReader(XMLStreamReader paramXMLStreamReader, StreamFilter paramStreamFilter) throws XMLStreamException;
+  
+  public abstract XMLEventReader createFilteredReader(XMLEventReader paramXMLEventReader, EventFilter paramEventFilter) throws XMLStreamException;
+  
+  public abstract XMLResolver getXMLResolver();
+  
+  public abstract void setXMLResolver(XMLResolver paramXMLResolver);
+  
+  public abstract XMLReporter getXMLReporter();
+  
+  public abstract void setXMLReporter(XMLReporter paramXMLReporter);
+  
+  public abstract void setProperty(String paramString, Object paramObject) throws IllegalArgumentException;
+  
+  public abstract Object getProperty(String paramString) throws IllegalArgumentException;
+  
+  public abstract boolean isPropertySupported(String paramString);
+  
+  public abstract void setEventAllocator(XMLEventAllocator paramXMLEventAllocator);
+  
+  public abstract XMLEventAllocator getEventAllocator();
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/XMLOutputFactory.java

@@ -0,0 +1,39 @@
+package javax.xml.stream;
+
+import java.io.OutputStream;
+import java.io.Writer;
+import javax.xml.transform.Result;
+
+public abstract class XMLOutputFactory {
+  public static final String IS_REPAIRING_NAMESPACES = "javax.xml.stream.isRepairingNamespaces";
+  
+  public static XMLOutputFactory newInstance() throws FactoryConfigurationError {
+    return (XMLOutputFactory)FactoryFinder.find("javax.xml.stream.XMLOutputFactory", "com.bea.xml.stream.XMLOutputFactoryBase");
+  }
+  
+  public static XMLInputFactory newInstance(String factoryId, ClassLoader classLoader) throws FactoryConfigurationError {
+    return (XMLInputFactory)FactoryFinder.find(factoryId, "com.bea.xml.stream.XMLOutputFactoryBase", classLoader);
+  }
+  
+  public abstract XMLStreamWriter createXMLStreamWriter(Writer paramWriter) throws XMLStreamException;
+  
+  public abstract XMLStreamWriter createXMLStreamWriter(OutputStream paramOutputStream) throws XMLStreamException;
+  
+  public abstract XMLStreamWriter createXMLStreamWriter(OutputStream paramOutputStream, String paramString) throws XMLStreamException;
+  
+  public abstract XMLStreamWriter createXMLStreamWriter(Result paramResult) throws XMLStreamException;
+  
+  public abstract XMLEventWriter createXMLEventWriter(Result paramResult) throws XMLStreamException;
+  
+  public abstract XMLEventWriter createXMLEventWriter(OutputStream paramOutputStream) throws XMLStreamException;
+  
+  public abstract XMLEventWriter createXMLEventWriter(OutputStream paramOutputStream, String paramString) throws XMLStreamException;
+  
+  public abstract XMLEventWriter createXMLEventWriter(Writer paramWriter) throws XMLStreamException;
+  
+  public abstract void setProperty(String paramString, Object paramObject) throws IllegalArgumentException;
+  
+  public abstract Object getProperty(String paramString) throws IllegalArgumentException;
+  
+  public abstract boolean isPropertySupported(String paramString);
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/XMLReporter.java

@@ -0,0 +1,5 @@
+package javax.xml.stream;
+
+public interface XMLReporter {
+  void report(String paramString1, String paramString2, Object paramObject, Location paramLocation) throws XMLStreamException;
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/XMLResolver.java

@@ -0,0 +1,5 @@
+package javax.xml.stream;
+
+public interface XMLResolver {
+  Object resolveEntity(String paramString1, String paramString2, String paramString3, String paramString4) throws XMLStreamException;
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/XMLStreamConstants.java

@@ -0,0 +1,33 @@
+package javax.xml.stream;
+
+public interface XMLStreamConstants {
+  public static final int START_ELEMENT = 1;
+  
+  public static final int END_ELEMENT = 2;
+  
+  public static final int PROCESSING_INSTRUCTION = 3;
+  
+  public static final int CHARACTERS = 4;
+  
+  public static final int COMMENT = 5;
+  
+  public static final int SPACE = 6;
+  
+  public static final int START_DOCUMENT = 7;
+  
+  public static final int END_DOCUMENT = 8;
+  
+  public static final int ENTITY_REFERENCE = 9;
+  
+  public static final int ATTRIBUTE = 10;
+  
+  public static final int DTD = 11;
+  
+  public static final int CDATA = 12;
+  
+  public static final int NAMESPACE = 13;
+  
+  public static final int NOTATION_DECLARATION = 14;
+  
+  public static final int ENTITY_DECLARATION = 15;
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/XMLStreamException.java

@@ -0,0 +1,41 @@
+package javax.xml.stream;
+
+public class XMLStreamException extends Exception {
+  protected Throwable nested;
+  
+  protected Location location;
+  
+  public XMLStreamException() {}
+  
+  public XMLStreamException(String msg) {
+    super(msg);
+  }
+  
+  public XMLStreamException(Throwable th) {
+    this.nested = th;
+  }
+  
+  public XMLStreamException(String msg, Throwable th) {
+    super(msg);
+    this.nested = th;
+  }
+  
+  public XMLStreamException(String msg, Location location, Throwable th) {
+    super("ParseError at [row,col]:[" + location.getLineNumber() + "," + location.getColumnNumber() + "]\n" + "Message: " + msg);
+    this.nested = th;
+    this.location = location;
+  }
+  
+  public XMLStreamException(String msg, Location location) {
+    super("ParseError at [row,col]:[" + location.getLineNumber() + "," + location.getColumnNumber() + "]\n" + "Message: " + msg);
+    this.location = location;
+  }
+  
+  public Throwable getNestedException() {
+    return this.nested;
+  }
+  
+  public Location getLocation() {
+    return this.location;
+  }
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/XMLStreamReader.java

@@ -0,0 +1,96 @@
+package javax.xml.stream;
+
+import javax.xml.namespace.NamespaceContext;
+import javax.xml.namespace.QName;
+
+public interface XMLStreamReader extends XMLStreamConstants {
+  Object getProperty(String paramString) throws IllegalArgumentException;
+  
+  int next() throws XMLStreamException;
+  
+  void require(int paramInt, String paramString1, String paramString2) throws XMLStreamException;
+  
+  String getElementText() throws XMLStreamException;
+  
+  int nextTag() throws XMLStreamException;
+  
+  boolean hasNext() throws XMLStreamException;
+  
+  void close() throws XMLStreamException;
+  
+  String getNamespaceURI(String paramString);
+  
+  boolean isStartElement();
+  
+  boolean isEndElement();
+  
+  boolean isCharacters();
+  
+  boolean isWhiteSpace();
+  
+  String getAttributeValue(String paramString1, String paramString2);
+  
+  int getAttributeCount();
+  
+  QName getAttributeName(int paramInt);
+  
+  String getAttributeNamespace(int paramInt);
+  
+  String getAttributeLocalName(int paramInt);
+  
+  String getAttributePrefix(int paramInt);
+  
+  String getAttributeType(int paramInt);
+  
+  String getAttributeValue(int paramInt);
+  
+  boolean isAttributeSpecified(int paramInt);
+  
+  int getNamespaceCount();
+  
+  String getNamespacePrefix(int paramInt);
+  
+  String getNamespaceURI(int paramInt);
+  
+  NamespaceContext getNamespaceContext();
+  
+  int getEventType();
+  
+  String getText();
+  
+  char[] getTextCharacters();
+  
+  int getTextCharacters(int paramInt1, char[] paramArrayOfchar, int paramInt2, int paramInt3) throws XMLStreamException;
+  
+  int getTextStart();
+  
+  int getTextLength();
+  
+  String getEncoding();
+  
+  boolean hasText();
+  
+  Location getLocation();
+  
+  QName getName();
+  
+  String getLocalName();
+  
+  boolean hasName();
+  
+  String getNamespaceURI();
+  
+  String getPrefix();
+  
+  String getVersion();
+  
+  boolean isStandalone();
+  
+  boolean standaloneSet();
+  
+  String getCharacterEncodingScheme();
+  
+  String getPITarget();
+  
+  String getPIData();
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/XMLStreamWriter.java

@@ -0,0 +1,69 @@
+package javax.xml.stream;
+
+import javax.xml.namespace.NamespaceContext;
+
+public interface XMLStreamWriter {
+  void writeStartElement(String paramString) throws XMLStreamException;
+  
+  void writeStartElement(String paramString1, String paramString2) throws XMLStreamException;
+  
+  void writeStartElement(String paramString1, String paramString2, String paramString3) throws XMLStreamException;
+  
+  void writeEmptyElement(String paramString1, String paramString2) throws XMLStreamException;
+  
+  void writeEmptyElement(String paramString1, String paramString2, String paramString3) throws XMLStreamException;
+  
+  void writeEmptyElement(String paramString) throws XMLStreamException;
+  
+  void writeEndElement() throws XMLStreamException;
+  
+  void writeEndDocument() throws XMLStreamException;
+  
+  void close() throws XMLStreamException;
+  
+  void flush() throws XMLStreamException;
+  
+  void writeAttribute(String paramString1, String paramString2) throws XMLStreamException;
+  
+  void writeAttribute(String paramString1, String paramString2, String paramString3, String paramString4) throws XMLStreamException;
+  
+  void writeAttribute(String paramString1, String paramString2, String paramString3) throws XMLStreamException;
+  
+  void writeNamespace(String paramString1, String paramString2) throws XMLStreamException;
+  
+  void writeDefaultNamespace(String paramString) throws XMLStreamException;
+  
+  void writeComment(String paramString) throws XMLStreamException;
+  
+  void writeProcessingInstruction(String paramString) throws XMLStreamException;
+  
+  void writeProcessingInstruction(String paramString1, String paramString2) throws XMLStreamException;
+  
+  void writeCData(String paramString) throws XMLStreamException;
+  
+  void writeDTD(String paramString) throws XMLStreamException;
+  
+  void writeEntityRef(String paramString) throws XMLStreamException;
+  
+  void writeStartDocument() throws XMLStreamException;
+  
+  void writeStartDocument(String paramString) throws XMLStreamException;
+  
+  void writeStartDocument(String paramString1, String paramString2) throws XMLStreamException;
+  
+  void writeCharacters(String paramString) throws XMLStreamException;
+  
+  void writeCharacters(char[] paramArrayOfchar, int paramInt1, int paramInt2) throws XMLStreamException;
+  
+  String getPrefix(String paramString) throws XMLStreamException;
+  
+  void setPrefix(String paramString1, String paramString2) throws XMLStreamException;
+  
+  void setDefaultNamespace(String paramString) throws XMLStreamException;
+  
+  void setNamespaceContext(NamespaceContext paramNamespaceContext) throws XMLStreamException;
+  
+  NamespaceContext getNamespaceContext();
+  
+  Object getProperty(String paramString) throws IllegalArgumentException;
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/events/Attribute.java

@@ -0,0 +1,13 @@
+package javax.xml.stream.events;
+
+import javax.xml.namespace.QName;
+
+public interface Attribute extends XMLEvent {
+  QName getName();
+  
+  String getValue();
+  
+  String getDTDType();
+  
+  boolean isSpecified();
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/events/Characters.java

@@ -0,0 +1,11 @@
+package javax.xml.stream.events;
+
+public interface Characters extends XMLEvent {
+  String getData();
+  
+  boolean isWhiteSpace();
+  
+  boolean isCData();
+  
+  boolean isIgnorableWhiteSpace();
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/events/Comment.java

@@ -0,0 +1,5 @@
+package javax.xml.stream.events;
+
+public interface Comment extends XMLEvent {
+  String getText();
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/events/DTD.java

@@ -0,0 +1,13 @@
+package javax.xml.stream.events;
+
+import java.util.List;
+
+public interface DTD extends XMLEvent {
+  String getDocumentTypeDeclaration();
+  
+  Object getProcessedDTD();
+  
+  List getNotations();
+  
+  List getEntities();
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/events/EndDocument.java

@@ -0,0 +1,3 @@
+package javax.xml.stream.events;
+
+public interface EndDocument extends XMLEvent {}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/events/EndElement.java

@@ -0,0 +1,10 @@
+package javax.xml.stream.events;
+
+import java.util.Iterator;
+import javax.xml.namespace.QName;
+
+public interface EndElement extends XMLEvent {
+  QName getName();
+  
+  Iterator getNamespaces();
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/events/EntityDeclaration.java

@@ -0,0 +1,15 @@
+package javax.xml.stream.events;
+
+public interface EntityDeclaration extends XMLEvent {
+  String getPublicId();
+  
+  String getSystemId();
+  
+  String getName();
+  
+  String getNotationName();
+  
+  String getReplacementText();
+  
+  String getBaseURI();
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/events/EntityReference.java

@@ -0,0 +1,7 @@
+package javax.xml.stream.events;
+
+public interface EntityReference extends XMLEvent {
+  EntityDeclaration getDeclaration();
+  
+  String getName();
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/events/Namespace.java

@@ -0,0 +1,9 @@
+package javax.xml.stream.events;
+
+public interface Namespace extends Attribute {
+  String getPrefix();
+  
+  String getNamespaceURI();
+  
+  boolean isDefaultNamespaceDeclaration();
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/events/NotationDeclaration.java

@@ -0,0 +1,9 @@
+package javax.xml.stream.events;
+
+public interface NotationDeclaration extends XMLEvent {
+  String getName();
+  
+  String getPublicId();
+  
+  String getSystemId();
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/events/ProcessingInstruction.java

@@ -0,0 +1,7 @@
+package javax.xml.stream.events;
+
+public interface ProcessingInstruction extends XMLEvent {
+  String getTarget();
+  
+  String getData();
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/events/StartDocument.java

@@ -0,0 +1,15 @@
+package javax.xml.stream.events;
+
+public interface StartDocument extends XMLEvent {
+  String getSystemId();
+  
+  String getCharacterEncodingScheme();
+  
+  boolean encodingSet();
+  
+  boolean isStandalone();
+  
+  boolean standaloneSet();
+  
+  String getVersion();
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/events/StartElement.java

@@ -0,0 +1,19 @@
+package javax.xml.stream.events;
+
+import java.util.Iterator;
+import javax.xml.namespace.NamespaceContext;
+import javax.xml.namespace.QName;
+
+public interface StartElement extends XMLEvent {
+  QName getName();
+  
+  Iterator getAttributes();
+  
+  Iterator getNamespaces();
+  
+  Attribute getAttributeByName(QName paramQName);
+  
+  NamespaceContext getNamespaceContext();
+  
+  String getNamespaceURI(String paramString);
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/events/XMLEvent.java

@@ -0,0 +1,41 @@
+package javax.xml.stream.events;
+
+import java.io.Writer;
+import javax.xml.namespace.QName;
+import javax.xml.stream.Location;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+
+public interface XMLEvent extends XMLStreamConstants {
+  int getEventType();
+  
+  Location getLocation();
+  
+  boolean isStartElement();
+  
+  boolean isAttribute();
+  
+  boolean isNamespace();
+  
+  boolean isEndElement();
+  
+  boolean isEntityReference();
+  
+  boolean isProcessingInstruction();
+  
+  boolean isCharacters();
+  
+  boolean isStartDocument();
+  
+  boolean isEndDocument();
+  
+  StartElement asStartElement();
+  
+  EndElement asEndElement();
+  
+  Characters asCharacters();
+  
+  QName getSchemaType();
+  
+  void writeAsEncodedUnicode(Writer paramWriter) throws XMLStreamException;
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/util/EventReaderDelegate.java

@@ -0,0 +1,59 @@
+package javax.xml.stream.util;
+
+import javax.xml.stream.XMLEventReader;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.events.XMLEvent;
+
+public class EventReaderDelegate implements XMLEventReader {
+  private XMLEventReader reader;
+  
+  public EventReaderDelegate() {}
+  
+  public EventReaderDelegate(XMLEventReader reader) {
+    this.reader = reader;
+  }
+  
+  public void setParent(XMLEventReader reader) {
+    this.reader = reader;
+  }
+  
+  public XMLEventReader getParent() {
+    return this.reader;
+  }
+  
+  public XMLEvent nextEvent() throws XMLStreamException {
+    return this.reader.nextEvent();
+  }
+  
+  public Object next() {
+    return this.reader.next();
+  }
+  
+  public boolean hasNext() {
+    return this.reader.hasNext();
+  }
+  
+  public XMLEvent peek() throws XMLStreamException {
+    return this.reader.peek();
+  }
+  
+  public void close() throws XMLStreamException {
+    this.reader.close();
+  }
+  
+  public String getElementText() throws XMLStreamException {
+    return this.reader.getElementText();
+  }
+  
+  public XMLEvent nextTag() throws XMLStreamException {
+    return this.reader.nextTag();
+  }
+  
+  public Object getProperty(String name) throws IllegalArgumentException {
+    return this.reader.getProperty(name);
+  }
+  
+  public void remove() {
+    this.reader.remove();
+  }
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/util/StreamReaderDelegate.java

@@ -0,0 +1,205 @@
+package javax.xml.stream.util;
+
+import javax.xml.namespace.NamespaceContext;
+import javax.xml.namespace.QName;
+import javax.xml.stream.Location;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+public class StreamReaderDelegate implements XMLStreamReader {
+  private XMLStreamReader reader;
+  
+  public StreamReaderDelegate() {}
+  
+  public StreamReaderDelegate(XMLStreamReader reader) {
+    this.reader = reader;
+  }
+  
+  public void setParent(XMLStreamReader reader) {
+    this.reader = reader;
+  }
+  
+  public XMLStreamReader getParent() {
+    return this.reader;
+  }
+  
+  public int next() throws XMLStreamException {
+    return this.reader.next();
+  }
+  
+  public int nextTag() throws XMLStreamException {
+    return this.reader.nextTag();
+  }
+  
+  public String getElementText() throws XMLStreamException {
+    return this.reader.getElementText();
+  }
+  
+  public void require(int type, String namespaceURI, String localName) throws XMLStreamException {
+    this.reader.require(type, namespaceURI, localName);
+  }
+  
+  public boolean hasNext() throws XMLStreamException {
+    return this.reader.hasNext();
+  }
+  
+  public void close() throws XMLStreamException {
+    this.reader.close();
+  }
+  
+  public String getNamespaceURI(String prefix) {
+    return this.reader.getNamespaceURI(prefix);
+  }
+  
+  public NamespaceContext getNamespaceContext() {
+    return this.reader.getNamespaceContext();
+  }
+  
+  public boolean isStartElement() {
+    return this.reader.isStartElement();
+  }
+  
+  public boolean isEndElement() {
+    return this.reader.isEndElement();
+  }
+  
+  public boolean isCharacters() {
+    return this.reader.isCharacters();
+  }
+  
+  public boolean isWhiteSpace() {
+    return this.reader.isWhiteSpace();
+  }
+  
+  public String getAttributeValue(String namespaceUri, String localName) {
+    return this.reader.getAttributeValue(namespaceUri, localName);
+  }
+  
+  public int getAttributeCount() {
+    return this.reader.getAttributeCount();
+  }
+  
+  public QName getAttributeName(int index) {
+    return this.reader.getAttributeName(index);
+  }
+  
+  public String getAttributePrefix(int index) {
+    return this.reader.getAttributePrefix(index);
+  }
+  
+  public String getAttributeNamespace(int index) {
+    return this.reader.getAttributeNamespace(index);
+  }
+  
+  public String getAttributeLocalName(int index) {
+    return this.reader.getAttributeLocalName(index);
+  }
+  
+  public String getAttributeType(int index) {
+    return this.reader.getAttributeType(index);
+  }
+  
+  public String getAttributeValue(int index) {
+    return this.reader.getAttributeValue(index);
+  }
+  
+  public boolean isAttributeSpecified(int index) {
+    return this.reader.isAttributeSpecified(index);
+  }
+  
+  public int getNamespaceCount() {
+    return this.reader.getNamespaceCount();
+  }
+  
+  public String getNamespacePrefix(int index) {
+    return this.reader.getNamespacePrefix(index);
+  }
+  
+  public String getNamespaceURI(int index) {
+    return this.reader.getNamespaceURI(index);
+  }
+  
+  public int getEventType() {
+    return this.reader.getEventType();
+  }
+  
+  public String getText() {
+    return this.reader.getText();
+  }
+  
+  public int getTextCharacters(int sourceStart, char[] target, int targetStart, int length) throws XMLStreamException {
+    return this.reader.getTextCharacters(sourceStart, target, targetStart, length);
+  }
+  
+  public char[] getTextCharacters() {
+    return this.reader.getTextCharacters();
+  }
+  
+  public int getTextStart() {
+    return this.reader.getTextStart();
+  }
+  
+  public int getTextLength() {
+    return this.reader.getTextLength();
+  }
+  
+  public String getEncoding() {
+    return this.reader.getEncoding();
+  }
+  
+  public boolean hasText() {
+    return this.reader.hasText();
+  }
+  
+  public Location getLocation() {
+    return this.reader.getLocation();
+  }
+  
+  public QName getName() {
+    return this.reader.getName();
+  }
+  
+  public String getLocalName() {
+    return this.reader.getLocalName();
+  }
+  
+  public boolean hasName() {
+    return this.reader.hasName();
+  }
+  
+  public String getNamespaceURI() {
+    return this.reader.getNamespaceURI();
+  }
+  
+  public String getPrefix() {
+    return this.reader.getPrefix();
+  }
+  
+  public String getVersion() {
+    return this.reader.getVersion();
+  }
+  
+  public boolean isStandalone() {
+    return this.reader.isStandalone();
+  }
+  
+  public boolean standaloneSet() {
+    return this.reader.standaloneSet();
+  }
+  
+  public String getCharacterEncodingScheme() {
+    return this.reader.getCharacterEncodingScheme();
+  }
+  
+  public String getPITarget() {
+    return this.reader.getPITarget();
+  }
+  
+  public String getPIData() {
+    return this.reader.getPIData();
+  }
+  
+  public Object getProperty(String name) {
+    return this.reader.getProperty(name);
+  }
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/util/XMLEventAllocator.java

@@ -0,0 +1,13 @@
+package javax.xml.stream.util;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.events.XMLEvent;
+
+public interface XMLEventAllocator {
+  XMLEventAllocator newInstance();
+  
+  XMLEvent allocate(XMLStreamReader paramXMLStreamReader) throws XMLStreamException;
+  
+  void allocate(XMLStreamReader paramXMLStreamReader, XMLEventConsumer paramXMLEventConsumer) throws XMLStreamException;
+}

rus/WEB-INF/lib/jsr173_api_src/javax/xml/stream/util/XMLEventConsumer.java

@@ -0,0 +1,8 @@
+package javax.xml.stream.util;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.events.XMLEvent;
+
+public interface XMLEventConsumer {
+  void add(XMLEvent paramXMLEvent) throws XMLStreamException;
+}