http://git-wip-us.apache.org/repos/asf/lucenenet/blob/198e5868/src/Lucene.Net.Benchmark/Support/Sax/SAXParseException.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Benchmark/Support/Sax/SAXParseException.cs b/src/Lucene.Net.Benchmark/Support/Sax/SAXParseException.cs new file mode 100644 index 0000000..b7cdf64 --- /dev/null +++ b/src/Lucene.Net.Benchmark/Support/Sax/SAXParseException.cs @@ -0,0 +1,269 @@ +// SAX exception class. +// http://www.saxproject.org +// No warranty; no copyright -- use this as you will. +// $Id: SAXParseException.java,v 1.11 2004/04/21 13:05:02 dmegginson Exp $ + +using System; +#if FEATURE_SERIALIZABLE +using System.Runtime.Serialization; +#endif + +namespace Sax +{ + /// <summary> + /// Encapsulate an XML parse error or warning. + /// </summary> + /// <remarks> + /// <em>This module, both source code and documentation, is in the + /// Public Domain, and comes with<strong> NO WARRANTY</strong>.</em> + /// See<a href='http://www.saxproject.org'>http://www.saxproject.org</a> + /// for further information. + /// <para/> + /// This exception may include information for locating the error + /// in the original XML document, as if it came from a <see cref="ILocator"/> + /// object. Note that although the application + /// will receive a SAXParseException as the argument to the handlers + /// in the <see cref="IErrorHandler"/> interface, + /// the application is not actually required to throw the exception; + /// instead, it can simply read the information in it and take a + /// different action. + /// <para/> + /// Since this exception is a subclass of <see cref="SAXException"/>, + /// it inherits the ability to wrap another exception. + /// </remarks> + /// <since>SAX 1.0</since> + /// <author>David Megginson</author> + /// <version>2.0.1 (sax2r2)</version> + /// <seealso cref="SAXException"/> + /// <seealso cref="ILocator"/> + /// <seealso cref="IErrorHandler"/> +#if FEATURE_SERIALIZABLE + [Serializable] +#endif + public class SAXParseException : SAXException + { + ////////////////////////////////////////////////////////////////////// + // Constructors. + ////////////////////////////////////////////////////////////////////// + + /// <summary> + /// Construct a new exception with no message. + /// </summary> + // LUCENENET specific for serialization + public SAXParseException() + : base() + { + } + + /// <summary> + /// Create a new <see cref="SAXParseException"/> from a message and a <see cref="ILocator"/>. + /// </summary> + /// <remarks> + /// This constructor is especially useful when an application is + /// creating its own exception from within a <see cref="IContentHandler"/> + /// callback. + /// </remarks> + /// <param name="message">The error or warning message.</param> + /// <param name="locator">The locator object for the error or warning (may be null).</param> + /// <seealso cref="ILocator"/> + public SAXParseException(string message, ILocator locator) + : base(message) + { + if (locator != null) + { + Init(locator.PublicId, locator.SystemId, + locator.LineNumber, locator.ColumnNumber); + } + else + { + Init(null, null, -1, -1); + } + } + + /// <summary> + /// Wrap an existing exception in a SAXParseException. + /// </summary> + /// <remarks> + /// This constructor is especially useful when an application is + /// creating its own exception from within a <see cref="IContentHandler"/> + /// callback, and needs to wrap an existing exception that is not a + /// subclass of <see cref="SAXException"/>. + /// </remarks> + /// <param name="message">The error or warning message, or null to + /// use the message from the embedded exception.</param> + /// <param name="locator">The locator object for the error or warning (may be + /// null).</param> + /// <param name="e">Any exception.</param> + /// <seealso cref="ILocator"/> + public SAXParseException(string message, ILocator locator, + Exception e) + : base(message, e) + { + if (locator != null) + { + Init(locator.PublicId, locator.SystemId, + locator.LineNumber, locator.ColumnNumber); + } + else + { + Init(null, null, -1, -1); + } + } + + /// <summary> + /// Create a new SAXParseException. + /// </summary> + /// <remarks> + /// This constructor is most useful for parser writers. + /// <para/> + /// All parameters except the message are as if + /// they were provided by a <see cref="ILocator"/>. For example, if the + /// system identifier is a URL (including relative filename), the + /// caller must resolve it fully before creating the exception. + /// </remarks> + /// <param name="message">The error or warning message.</param> + /// <param name="publicId">The public identifier of the entity that generated the error or warning.</param> + /// <param name="systemId">The system identifier of the entity that generated the error or warning.</param> + /// <param name="lineNumber">The line number of the end of the text that caused the error or warning.</param> + /// <param name="columnNumber">The column number of the end of the text that cause the error or warning.</param> + public SAXParseException(string message, string publicId, string systemId, + int lineNumber, int columnNumber) + : base(message) + { + Init(publicId, systemId, lineNumber, columnNumber); + } + + /// <summary> + /// Create a new <see cref="SAXParseException"/> with an embedded exception. + /// </summary> + /// <remarks> + /// This constructor is most useful for parser writers who + /// need to wrap an exception that is not a subclass of + /// <see cref="SAXException"/>. + /// <para/> + /// All parameters except the message and exception are as if + /// they were provided by a <see cref="ILocator"/>. For example, if the + /// system identifier is a URL (including relative filename), the + /// caller must resolve it fully before creating the exception. + /// </remarks> + /// <param name="message">The error or warning message, or null to use the message from the embedded exception.</param> + /// <param name="publicId">The public identifier of the entity that generated the error or warning.</param> + /// <param name="systemId">The system identifier of the entity that generated the error or warning.</param> + /// <param name="lineNumber">The line number of the end of the text that caused the error or warning.</param> + /// <param name="columnNumber">The column number of the end of the text that cause the error or warning.</param> + /// <param name="e">Another exception to embed in this one.</param> + public SAXParseException(string message, string publicId, string systemId, + int lineNumber, int columnNumber, Exception e) + : base(message, e) + { + Init(publicId, systemId, lineNumber, columnNumber); + } + +#if FEATURE_SERIALIZABLE + /// <summary> + /// Initializes a new instance of this class with serialized data. + /// </summary> + /// <param name="info">The <see cref="SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param> + /// <param name="context">The <see cref="StreamingContext"/> that contains contextual information about the source or destination.</param> + public SAXParseException(SerializationInfo info, StreamingContext context) + : base(info, context) + { + } +#endif + + /// <summary> + /// Internal initialization method. + /// </summary> + /// <param name="publicId">The public identifier of the entity which generated the exception, or null.</param> + /// <param name="systemId">The system identifier of the entity which generated the exception, or null.</param> + /// <param name="lineNumber">The line number of the error, or -1.</param> + /// <param name="columnNumber">The column number of the error, or -1.</param> + private void Init(string publicId, string systemId, + int lineNumber, int columnNumber) + { + this.publicId = publicId; + this.systemId = systemId; + this.lineNumber = lineNumber; + this.columnNumber = columnNumber; + } + + /// <summary> + /// Get the public identifier of the entity where the exception occurred. + /// Returns a string containing the public identifier, or null if none is available. + /// </summary> + /// <seealso cref="ILocator.PublicId"/> + public string PublicId + { + get { return this.publicId; } + } + + /// <summary> + /// Get the system identifier of the entity where the exception occurred. + /// <para/> + /// If the system identifier is a URL, it will have been resolved fully. + /// <para/> + /// A string containing the system identifier, or null if none is available. + /// </summary> + /// <seealso cref="ILocator.SystemId"/> + public string SystemId + { + get { return this.systemId; } + } + + /// <summary> + /// The line number of the end of the text where the exception occurred. + /// <para/> + /// The first line is line 1. + /// <para/> + /// An integer representing the line number, or -1 if none is available. + /// </summary> + /// <seealso cref="ILocator.LineNumber"/> + public int LineNumber + { + get { return this.lineNumber; } + } + + /// <summary> + /// The column number of the end of the text where the exception occurred. + /// <para/> + /// The first column in a line is position 1. + /// <para/> + /// An integer representing the column number, or -1 + /// if none is available. + /// </summary> + /// <seealso cref="ILocator.ColumnNumber"/> + public int ColumnNumber + { + get { return this.columnNumber; } + } + + + ////////////////////////////////////////////////////////////////////// + // Internal state. + ////////////////////////////////////////////////////////////////////// + + /// <summary> + /// The public identifier, or null. + /// </summary> + /// <seealso cref="PublicId"/> + private string publicId; + + /// <summary> + /// The system identifier, or null. + /// </summary> + /// <seealso cref="SystemId"/> + private string systemId; + + /// <summary> + /// The line number, or -1. + /// </summary> + /// <seealso cref="LineNumber"/> + private int lineNumber; + + /// <summary> + /// The column number, or -1. + /// </summary> + /// <seealso cref="ColumnNumber"/> + private int columnNumber; + } +}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/198e5868/src/Lucene.Net.Benchmark/Support/Sax/XMLFilter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Benchmark/Support/Sax/XMLFilter.cs b/src/Lucene.Net.Benchmark/Support/Sax/XMLFilter.cs new file mode 100644 index 0000000..f9350d3 --- /dev/null +++ b/src/Lucene.Net.Benchmark/Support/Sax/XMLFilter.cs @@ -0,0 +1,41 @@ +// XMLFilter.java - filter SAX2 events. +// http://www.saxproject.org +// Written by David Megginson +// NO WARRANTY! This class is in the Public Domain. +// $Id: XMLFilter.java,v 1.6 2002/01/30 21:13:48 dbrownell Exp $ + +namespace Sax +{ + /// <summary> + /// Interface for an XML filter. + /// </summary> + /// <remarks> + /// <em>This module, both source code and documentation, is in the + /// Public Domain, and comes with<strong> NO WARRANTY</strong>.</em> + /// See<a href='http://www.saxproject.org'>http://www.saxproject.org</a> + /// for further information. + /// <para/> + /// An XML filter is like an XML reader, except that it obtains its + /// events from another XML reader rather than a primary source like + /// an XML document or database.Filters can modify a stream of + /// events as they pass on to the final application. + /// <para/> + /// The XMLFilterImpl helper class provides a convenient base + /// for creating SAX2 filters, by passing on all <see cref="IEntityResolver"/>, <see cref="IDTDHandler"/>, + /// <see cref="IContentHandler"/> and <see cref="IErrorHandler"/> + /// events automatically. + /// </remarks> + public interface IXMLFilter : IXMLReader + { + /// <summary> + /// Gets or sets the parent reader. Returns the parent filter, or null if none has been set. + /// </summary> + /// <remarks> + /// This method allows the application to link or query the parent + /// reader (which may be another filter). It is generally a + /// bad idea to perform any operations on the parent reader + /// directly: they should all pass through this filter. + /// </remarks> + IXMLReader Parent { get; set; } + } +} http://git-wip-us.apache.org/repos/asf/lucenenet/blob/198e5868/src/Lucene.Net.Benchmark/Support/Sax/XMLReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Benchmark/Support/Sax/XMLReader.cs b/src/Lucene.Net.Benchmark/Support/Sax/XMLReader.cs new file mode 100644 index 0000000..71b690f --- /dev/null +++ b/src/Lucene.Net.Benchmark/Support/Sax/XMLReader.cs @@ -0,0 +1,305 @@ +// XMLFilter.java - filter SAX2 events. +// http://www.saxproject.org +// Written by David Megginson +// NO WARRANTY! This class is in the Public Domain. +// $Id: XMLFilter.java,v 1.6 2002/01/30 21:13:48 dbrownell Exp $ + +namespace Sax +{ + /// <summary> + /// Interface for an XML filter. + /// </summary> + /// <remarks> + /// <em>This module, both source code and documentation, is in the + /// Public Domain, and comes with<strong> NO WARRANTY</strong>.</em> + /// See<a href='http://www.saxproject.org'>http://www.saxproject.org</a> + /// for further information. + /// <para/> + /// An XML filter is like an XML reader, except that it obtains its + /// events from another XML reader rather than a primary source like + /// an XML document or database.Filters can modify a stream of + /// events as they pass on to the final application. + /// <para/> + /// The <see cref="IXMLFilter"/> helper class provides a convenient base + /// for creating SAX2 filters, by passing on all <see cref="IEntityResolver"/>, + /// <see cref="IDTDHandler"/>, + /// <see cref="IContentHandler"/> and <see cref="IErrorHandler"/> + /// events automatically. + /// </remarks> + /// <since>SAX 2.0</since> + /// <author>David Megginson</author> + /// <version>2.0.1 (sax2r2)</version> + /// <seealso cref="Helpers.XMLFilter"/> + public interface IXMLReader + { + //////////////////////////////////////////////////////////////////// + // Configuration. + //////////////////////////////////////////////////////////////////// + + + /// <summary> + /// Look up the value of a feature flag. + /// </summary> + /// <remarks> + /// The feature name is any fully-qualified URI. It is + /// possible for an XMLReader to recognize a feature name but + /// temporarily be unable to return its value. + /// Some feature values may be available only in specific + /// contexts, such as before, during, or after a parse. + /// Also, some feature values may not be programmatically accessible. + /// (In the case of an adapter for SAX1 {@link Parser}, there is no + /// implementation-independent way to expose whether the underlying + /// parser is performing validation, expanding external entities, + /// and so forth.) + /// <para/>All XMLReaders are required to recognize the + /// http://xml.org/sax/features/namespaces and the + /// http://xml.org/sax/features/namespace-prefixes feature names. + /// <para/>Typical usage is something like this: + /// <code> + /// XMLReader r = new MySAXDriver(); + /// // try to activate validation + /// try { + /// r.SetFeature("http://xml.org/sax/features/validation";, true); + /// } catch (SAXException e) { + /// Console.Error.WriteLine("Cannot activate validation."); + /// } + /// // register event handlers + /// r.ContentHandler = new MyContentHandler(); + /// r.ErrorHandler = new MyErrorHandler(); + /// // parse the first document + /// try { + /// r.Parse("http://www.foo.com/mydoc.xml";); + /// } catch (IOException e) { + /// Console.Error.WriteLine("I/O exception reading XML document"); + /// } catch (SAXException e) { + /// Console.Error.WriteLine("XML exception reading document."); + /// } + /// </code> + /// <para/>Implementors are free (and encouraged) to invent their own features, + /// using names built on their own URIs. + /// </remarks> + /// <param name="name">The feature name, which is a fully-qualified URI.</param> + /// <returns>The current value of the feature (true or false).</returns> + /// <exception cref="SAXNotRecognizedException">If the feature + /// value can't be assigned or retrieved.</exception> + /// <exception cref="SAXNotSupportedException">When the + /// <see cref="IXMLReader"/> recognizes the feature name but + /// cannot determine its value at this time.</exception> + /// <seealso cref="SetFeature(string, bool)"/> + bool GetFeature(string name); + + + /// <summary> + /// Set the value of a feature flag. + /// <para/> + /// The feature name is any fully-qualified URI. It is + /// possible for an XMLReader to expose a feature value but + /// to be unable to change the current value. + /// Some feature values may be immutable or mutable only + /// in specific contexts, such as before, during, or after + /// a parse. + /// <para/> + /// All XMLReaders are required to support setting + /// http://xml.org/sax/features/namespaces to true and + /// http://xml.org/sax/features/namespace-prefixes to false. + /// </summary> + /// <param name="name">The feature name, which is a fully-qualified URI.</param> + /// <param name="value">The requested value of the feature (true or false).</param> + /// <exception cref="SAXNotRecognizedException">If the feature + /// value can't be assigned or retrieved.</exception> + /// <exception cref="SAXNotSupportedException">When the + /// <see cref="IXMLReader"/> recognizes the feature name but + /// cannot set the requested value.</exception> + /// <seealso cref="GetFeature(string)"/> + void SetFeature(string name, bool value); + + + /// <summary> + /// Look up the value of a property. + /// </summary> + /// <remarks> + /// The property name is any fully-qualified URI. It is + /// possible for an XMLReader to recognize a property name but + /// temporarily be unable to return its value. + /// Some property values may be available only in specific + /// contexts, such as before, during, or after a parse. + /// <para/> + /// <see cref="IXMLReader"/>s are not required to recognize any specific + /// property names, though an initial core set is documented for + /// SAX2. + /// <para/> + /// Implementors are free (and encouraged) to invent their own properties, + /// using names built on their own URIs. + /// </remarks> + /// <param name="name">The property name, which is a fully-qualified URI.</param> + /// <returns>The current value of the property.</returns> + /// <exception cref="SAXNotRecognizedException">If the property + /// value can't be assigned or retrieved.</exception> + /// <exception cref="SAXNotSupportedException">When the + /// <see cref="IXMLReader"/> recognizes the property name but + /// cannot determine its value at this time.</exception> + /// <seealso cref="SetProperty(string, object)"/> + object GetProperty(string name); + + + /// <summary> + /// Set the value of a property. + /// </summary> + /// <remarks> + /// The property name is any fully-qualified URI. It is + /// possible for an <see cref="IXMLReader"/> to recognize a property name but + /// to be unable to change the current value. + /// Some property values may be immutable or mutable only + /// in specific contexts, such as before, during, or after + /// a parse. + /// <para/> + /// <see cref="IXMLReader"/>s are not required to recognize setting + /// any specific property names, though a core set is defined by + /// SAX2. + /// <para/> + /// This method is also the standard mechanism for setting + /// extended handlers. + /// </remarks> + /// <param name="name">The property name, which is a fully-qualified URI.</param> + /// <param name="value">The requested value for the property.</param> + /// <exception cref="SAXNotRecognizedException">If the property + /// value can't be assigned or retrieved.</exception> + /// <exception cref="SAXNotSupportedException">When the + /// <see cref="IXMLReader"/> recognizes the property name but + /// cannot set the requested value.</exception> + void SetProperty(string name, object value); + + + + //////////////////////////////////////////////////////////////////// + // Event handlers. + //////////////////////////////////////////////////////////////////// + + + /// <summary> + /// Gets or Sets an entity resolver. + /// </summary> + /// <remarks> + /// If the application does not register an entity resolver, + /// the <see cref="IXMLReader"/> will perform its own default resolution. + /// <para/> + /// Applications may register a new or different resolver in the + /// middle of a parse, and the SAX parser must begin using the new + /// resolver immediately. + /// </remarks> + IEntityResolver EntityResolver { get; set; } + + /// <summary> + /// Gets or Sets a DTD event handler. + /// </summary> + /// <remarks> + /// If the application does not register a DTD handler, all DTD + /// events reported by the SAX parser will be silently ignored. + /// <para/> + /// Applications may register a new or different handler in the + /// middle of a parse, and the SAX parser must begin using the new + /// handler immediately. + /// </remarks> + IDTDHandler DTDHandler { get; set; } + + /// <summary> + /// Gets or Sets a content event handler. + /// </summary> + /// <remarks> + /// <para/>If the application does not register a content handler, all + /// content events reported by the SAX parser will be silently + /// ignored. + /// <para/>Applications may register a new or different handler in the + /// middle of a parse, and the SAX parser must begin using the new + /// handler immediately. + /// </remarks> + IContentHandler ContentHandler { get; set; } + + + /// <summary> + /// Gets or Sets an error event handler. + /// </summary> + /// <remarks> + /// If the application does not register an error handler, all + /// error events reported by the SAX parser will be silently + /// ignored; however, normal processing may not continue. It is + /// highly recommended that all SAX applications implement an + /// error handler to avoid unexpected bugs. + /// <para/> + /// Applications may register a new or different handler in the + /// middle of a parse, and the SAX parser must begin using the new + /// handler immediately. + /// </remarks> + IErrorHandler ErrorHandler { get; set; } + + + //////////////////////////////////////////////////////////////////// + // Parsing. + //////////////////////////////////////////////////////////////////// + + /// <summary> + /// Parse an XML document. + /// </summary> + /// <remarks> + /// The application can use this method to instruct the XML + /// reader to begin parsing an XML document from any valid input + /// source (a character stream, a byte stream, or a URI). + /// <para/> + /// Applications may not invoke this method while a parse is in + /// progress (they should create a new XMLReader instead for each + /// nested XML document). Once a parse is complete, an + /// application may reuse the same XMLReader object, possibly with a + /// different input source. + /// Configuration of the <see cref="IXMLReader"/> object (such as handler bindings and + /// values established for feature flags and properties) is unchanged + /// by completion of a parse, unless the definition of that aspect of + /// the configuration explicitly specifies other behavior. + /// (For example, feature flags or properties exposing + /// characteristics of the document being parsed.) + /// <para/> + /// During the parse, the XMLReader will provide information + /// about the XML document through the registered event + /// handlers. + /// <para/> + /// This method is synchronous: it will not return until parsing + /// has ended. If a client application wants to terminate + /// parsing early, it should throw an exception. + /// </remarks> + /// <param name="input">The input source for the top-level of the + /// XML document.</param> + /// <exception cref="SAXException">Any SAX exception, possibly + /// wrapping another exception.</exception> + /// <exception cref="System.IO.IOException">An IO exception from the parser, + /// possibly from a byte stream or character stream + /// supplied by the application.</exception> + /// <seealso cref="InputSource"/> + /// <seealso cref="Parse(string)"/> + /// <seealso cref="EntityResolver"/> + /// <seealso cref="DTDHandler"/> + /// <seealso cref="ContentHandler"/> + /// <seealso cref="ErrorHandler"/> + void Parse(InputSource input); + + + /// <summary> + /// Parse an XML document from a system identifier (URI). + /// </summary> + /// <remarks> + /// This method is a shortcut for the common case of reading a + /// document from a system identifier. It is the exact + /// equivalent of the following: + /// <code> + /// Parse(new InputSource(systemId)); + /// </code> + /// <para/>If the system identifier is a URL, it must be fully resolved + /// by the application before it is passed to the parser. + /// </remarks> + /// <param name="input">The system identifier (URI).</param> + /// <exception cref="SAXException">Any SAX exception, possibly + /// wrapping another exception.</exception> + /// <exception cref="System.IO.IOException">An IO exception from the parser, + /// possibly from a byte stream or character stream + /// supplied by the application.</exception> + void Parse(string systemId); + } +} http://git-wip-us.apache.org/repos/asf/lucenenet/blob/198e5868/src/Lucene.Net.Benchmark/Support/StringExtensions.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Benchmark/Support/StringExtensions.cs b/src/Lucene.Net.Benchmark/Support/StringExtensions.cs new file mode 100644 index 0000000..2104fdb --- /dev/null +++ b/src/Lucene.Net.Benchmark/Support/StringExtensions.cs @@ -0,0 +1,14 @@ +namespace Lucene.Net.Support +{ + public static class StringExtensions + { + public static string Intern(this string value) + { +#if NETSTANDARD + return value; +#else + return string.Intern(value); +#endif + } + } +} http://git-wip-us.apache.org/repos/asf/lucenenet/blob/198e5868/src/Lucene.Net.Benchmark/Support/TagSoup/AutoDetector.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Benchmark/Support/TagSoup/AutoDetector.cs b/src/Lucene.Net.Benchmark/Support/TagSoup/AutoDetector.cs new file mode 100644 index 0000000..6fcb578 --- /dev/null +++ b/src/Lucene.Net.Benchmark/Support/TagSoup/AutoDetector.cs @@ -0,0 +1,41 @@ +// This file is part of TagSoup and is Copyright 2002-2008 by John Cowan. +// +// TagSoup is licensed under the Apache License, +// Version 2.0. You may obtain a copy of this license at +// http://www.apache.org/licenses/LICENSE-2.0 . You may also have +// additional legal rights not granted by this license. +// +// TagSoup is distributed in the hope that it will be useful, but +// unless required by applicable law or agreed to in writing, TagSoup +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS +// OF ANY KIND, either express or implied; not even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +// +// +// Interface to objects that translate InputStreams to Readers by auto-detection + +using System.IO; + +namespace TagSoup +{ + /// <summary> + /// Classes which accept an <see cref="Stream"/> and provide a <see cref="TextReader"/> which figures + /// out the encoding of the <see cref="Stream"/> and reads characters from it should + /// conform to this interface. + /// </summary> + /// <seealso cref="Stream" /> + /// <seealso cref="TextReader" /> + public interface IAutoDetector + { + /// <summary> + /// Given a <see cref="Stream"/>, return a suitable <see cref="TextReader"/> that understands + /// the presumed character encoding of that <see cref="Stream"/>. + /// If bytes are consumed from the <see cref="Stream"/> in the process, they + /// <i>must</i> be pushed back onto the InputStream so that they can be + /// reinterpreted as characters. + /// </summary> + /// <param name="stream">The <see cref="Stream"/></param> + /// <returns>A <see cref="TextReader"/> that reads from the <see cref="Stream"/></returns> + TextReader AutoDetectingReader(Stream stream); + } +} http://git-wip-us.apache.org/repos/asf/lucenenet/blob/198e5868/src/Lucene.Net.Benchmark/Support/TagSoup/Element.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Benchmark/Support/TagSoup/Element.cs b/src/Lucene.Net.Benchmark/Support/TagSoup/Element.cs new file mode 100644 index 0000000..dca7eed --- /dev/null +++ b/src/Lucene.Net.Benchmark/Support/TagSoup/Element.cs @@ -0,0 +1,215 @@ +// This file is part of TagSoup and is Copyright 2002-2008 by John Cowan. +// +// TagSoup is licensed under the Apache License, +// Version 2.0. You may obtain a copy of this license at +// http://www.apache.org/licenses/LICENSE-2.0 . You may also have +// additional legal rights not granted by this license. +// +// TagSoup is distributed in the hope that it will be useful, but +// unless required by applicable law or agreed to in writing, TagSoup +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS +// OF ANY KIND, either express or implied; not even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +using Sax.Helpers; + +namespace TagSoup +{ + /// <summary> + /// The internal representation of an actual element (not an element type). + /// An Element has an element type, attributes, and a successor Element + /// for use in constructing stacks and queues of Elements. + /// </summary> + /// <seealso cref="ElementType" /> + /// <seealso cref="Sax.Net.Helpers.Attributes" /> + public class Element + { + private readonly Attributes _atts; // attributes of element + private readonly ElementType _type; // type of element + private bool _preclosed; // this element has been preclosed + + /// <summary> + /// Return an Element from a specified ElementType. + /// </summary> + /// <param name="type"> + /// The element type of the newly constructed element + /// </param> + /// <param name="defaultAttributes"> + /// True if default attributes are wanted + /// </param> + public Element(ElementType type, bool defaultAttributes) + { + _type = type; + if (defaultAttributes) + { + _atts = new Attributes(type.Attributes); + } + else + { + _atts = new Attributes(); + } + Next = null; + _preclosed = false; + } + + /// <summary> + /// Gets the element type. + /// </summary> + public virtual ElementType Type + { + get { return _type; } + } + + /// <summary> + /// Gets the attributes as an Attributes object. + /// Returning an Attributes makes the attributes mutable. + /// </summary> + /// <seealso cref="Attributes" /> + public virtual Attributes Attributes + { + get { return _atts; } + } + + /// <summary> + /// Gets or sets the next element in an element stack or queue. + /// </summary> + public virtual Element Next { get; set; } + + /// <summary> + /// Gets the name of the element's type. + /// </summary> + public virtual string Name + { + get { return _type.Name; } + } + + /// <summary> + /// Gets the namespace name of the element's type. + /// </summary> + public virtual string Namespace + { + get { return _type.Namespace; } + } + + /// <summary> + /// Gets the local name of the element's type. + /// </summary> + public virtual string LocalName + { + get { return _type.LocalName; } + } + + /// <summary> + /// Gets the content model vector of the element's type. + /// </summary> + public virtual int Model + { + get { return _type.Model; } + } + + /// <summary> + /// Gets the member-of vector of the element's type. + /// </summary> + public virtual int MemberOf + { + get { return _type.MemberOf; } + } + + /// <summary> + /// Gets the flags vector of the element's type. + /// </summary> + public virtual int Flags + { + get { return _type.Flags; } + } + + /// <summary> + /// Gets the parent element type of the element's type. + /// </summary> + public virtual ElementType Parent + { + get { return _type.Parent; } + } + + /// <summary> + /// Return true if this element has been preclosed. + /// </summary> + public virtual bool IsPreclosed + { + get { return _preclosed; } + } + + /// <summary> + /// Return true if the type of this element can contain the type of + /// another element. + /// Convenience method. + /// </summary> + /// <param name="other"> + /// The other element + /// </param> + public virtual bool CanContain(Element other) + { + return _type.CanContain(other._type); + } + + /// <summary> + /// Set an attribute and its value into this element. + /// </summary> + /// <param name="name"> + /// The attribute name (Qname) + /// </param> + /// <param name="type"> + /// The attribute type + /// </param> + /// <param name="value"> + /// The attribute value + /// </param> + public virtual void SetAttribute(string name, string type, string value) + { + _type.SetAttribute(_atts, name, type, value); + } + + /// <summary> + /// Make this element anonymous. + /// Remove any <c>id</c> or <c>name</c> attribute present + /// in the element's attributes. + /// </summary> + public virtual void Anonymize() + { + for (int i = _atts.Length - 1; i >= 0; i--) + { + if (_atts.GetType(i).Equals("ID") || _atts.GetQName(i).Equals("name")) + { + _atts.RemoveAttribute(i); + } + } + } + + /// <summary> + /// Clean the attributes of this element. + /// Attributes with null name (the name was ill-formed) + /// or null value (the attribute was present in the element type but + /// not in this actual element) are removed. + /// </summary> + public virtual void Clean() + { + for (int i = _atts.Length - 1; i >= 0; i--) + { + string name = _atts.GetLocalName(i); + if (_atts.GetValue(i) == null || string.IsNullOrEmpty(name)) + { + _atts.RemoveAttribute(i); + } + } + } + + /// <summary> + /// Force this element to preclosed status, meaning that an end-tag has + /// been seen but the element cannot yet be closed for structural reasons. + /// </summary> + public virtual void Preclose() + { + _preclosed = true; + } + } +} http://git-wip-us.apache.org/repos/asf/lucenenet/blob/198e5868/src/Lucene.Net.Benchmark/Support/TagSoup/ElementType.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Benchmark/Support/TagSoup/ElementType.cs b/src/Lucene.Net.Benchmark/Support/TagSoup/ElementType.cs new file mode 100644 index 0000000..6d62a2f --- /dev/null +++ b/src/Lucene.Net.Benchmark/Support/TagSoup/ElementType.cs @@ -0,0 +1,269 @@ +// This file is part of TagSoup and is Copyright 2002-2008 by John Cowan. +// +// TagSoup is licensed under the Apache License, +// Version 2.0. You may obtain a copy of this license at +// http://www.apache.org/licenses/LICENSE-2.0 . You may also have +// additional legal rights not granted by this license. +// +// TagSoup is distributed in the hope that it will be useful, but +// unless required by applicable law or agreed to in writing, TagSoup +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS +// OF ANY KIND, either express or implied; not even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +using Sax.Helpers; +using System; +using System.Text; + +namespace TagSoup +{ + /// <summary> + /// This class represents an element type in the schema. + /// An element type has a name, a content model vector, a member-of vector, + /// a flags vector, default attributes, and a schema to which it belongs. + /// </summary> + /// <seealso cref="Schema" /> + public class ElementType + { + private readonly Attributes atts; // default attributes + private readonly string localName; // element type local name + private readonly string name; // element type name (Qname) + private readonly string @namespace; // element type namespace name + private readonly Schema schema; // schema to which this belongs + + /// <summary> + /// Construct an <see cref="ElementType"/>: + /// but it's better to use <see cref="Schema.Element()"/> instead. + /// The content model, member-of, and flags vectors are specified as ints. + /// </summary> + /// <param name="name">The element type name</param> + /// <param name="model">ORed-together bits representing the content + /// models allowed in the content of this element type</param> + /// <param name="memberOf">ORed-together bits representing the content models + /// to which this element type belongs</param> + /// <param name="flags">ORed-together bits representing the flags associated + /// with this element type</param> + /// <param name="schema"> + /// The schema with which this element type will be associated + /// </param> + public ElementType(string name, int model, int memberOf, int flags, Schema schema) + { + this.name = name; + Model = model; + MemberOf = memberOf; + Flags = flags; + atts = new Attributes(); + this.schema = schema; + @namespace = GetNamespace(name, false); + localName = GetLocalName(name); + } + + /// <summary> + /// Gets the name of this element type. + /// </summary> + public virtual string Name + { + get { return name; } + } + + /// <summary> + /// Gets the namespace name of this element type. + /// </summary> + public virtual string Namespace + { + get { return @namespace; } + } + + /// <summary> + /// Gets the local name of this element type. + /// </summary> + public virtual string LocalName + { + get { return localName; } + } + + /// <summary> + /// Gets or sets the content models of this element type as a vector of bits + /// </summary> + public virtual int Model { get; set; } + + /// <summary> + /// Gets or sets the content models to which this element type belongs as a vector of bits + /// </summary> + public virtual int MemberOf { get; set; } + + /// <summary> + /// Gets or sets the flags associated with this element type as a vector of bits + /// </summary> + public virtual int Flags { get; set; } + + /// <summary> + /// Returns the default attributes associated with this element type. + /// Attributes of type CDATA that don't have default values are + /// typically not included. Other attributes without default values + /// have an internal value of <c>null</c>. + /// The return value is an Attributes to allow the caller to mutate + /// the attributes. + /// </summary> + public virtual Attributes Attributes + { + get { return atts; } + } + + /// <summary> + /// Gets or sets the parent element type of this element type. + /// </summary> + public virtual ElementType Parent { get; set; } + + /// <summary> + /// Gets the schema which this element type is associated with. + /// </summary> + public virtual Schema Schema + { + get { return schema; } + } + + /// <summary> + /// Return a namespace name from a Qname. + /// The attribute flag tells us whether to return an empty namespace + /// name if there is no prefix, or use the schema default instead. + /// </summary> + /// <param name="name">The Qname</param> + /// <param name="attribute">True if name is an attribute name</param> + /// <returns>The namespace name</returns> + public virtual string GetNamespace(string name, bool attribute) + { + int colon = name.IndexOf(':'); + if (colon == -1) + { + return attribute ? "" : schema.Uri; + } + string prefix = name.Substring(0, colon); + if (prefix.Equals("xml")) + { + return "http://www.w3.org/XML/1998/namespace";; + } + return string.Intern("urn:x-prefix:" + prefix); + } + + /// <summary> + /// Return a local name from a Qname. + /// </summary> + /// <param name="name">The Qname</param> + /// <returns>The local name</returns> + public virtual string GetLocalName(string name) + { + int colon = name.IndexOf(':'); + if (colon == -1) + { + return name; + } + return string.Intern(name.Substring(colon + 1)); + } + + /// <summary> + /// Returns <c>true</c> if this element type can contain another element type. + /// That is, if any of the models in this element's model vector + /// match any of the models in the other element type's member-of + /// vector. + /// </summary> + /// <param name="other">The other element type</param> + public virtual bool CanContain(ElementType other) + { + return (Model & other.MemberOf) != 0; + } + + /// <summary> + /// Sets an attribute and its value into an <see cref="Sax.IAttributes"/> object. + /// Attempts to set a namespace declaration are ignored. + /// </summary> + /// <param name="atts">The <see cref="Sax.Helpers.Attributes"/> object</param> + /// <param name="name">The name (Qname) of the attribute</param> + /// <param name="type">The type of the attribute</param> + /// <param name="value">The value of the attribute</param> + public virtual void SetAttribute(Attributes atts, string name, string type, string value) + { + if (name.Equals("xmlns") || name.StartsWith("xmlns:")) + { + return; + } + + string ns = GetNamespace(name, true); + string localName = GetLocalName(name); + int i = atts.GetIndex(name); + if (i == -1) + { + name = string.Intern(name); + if (type == null) + { + type = "CDATA"; + } + if (!type.Equals("CDATA")) + { + value = Normalize(value); + } + atts.AddAttribute(ns, localName, name, type, value); + } + else + { + if (type == null) + { + type = atts.GetType(i); + } + if (!type.Equals("CDATA")) + { + value = Normalize(value); + } + atts.SetAttribute(i, ns, localName, name, type, value); + } + } + + /// <summary> + /// Normalize an attribute value (ID-style). + /// CDATA-style attribute normalization is already done. + /// </summary> + /// <param name="value">The value to normalize</param> + public static string Normalize(string value) + { + if (value == null) + { + return null; + } + value = value.Trim(); + if (value.IndexOf(" ", StringComparison.Ordinal) == -1) + { + return value; + } + bool space = false; + var b = new StringBuilder(value.Length); + foreach (char v in value) + { + if (v == ' ') + { + if (!space) + { + b.Append(v); + } + space = true; + } + else + { + b.Append(v); + space = false; + } + } + return b.ToString(); + } + + /// <summary> + /// Sets an attribute and its value into this element type. + /// </summary> + /// <param name="name">The name of the attribute</param> + /// <param name="type">The type of the attribute</param> + /// <param name="value">The value of the attribute</param> + public virtual void SetAttribute(string name, string type, string value) + { + SetAttribute(atts, name, type, value); + } + } +} http://git-wip-us.apache.org/repos/asf/lucenenet/blob/198e5868/src/Lucene.Net.Benchmark/Support/TagSoup/HTMLScanner.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Benchmark/Support/TagSoup/HTMLScanner.cs b/src/Lucene.Net.Benchmark/Support/TagSoup/HTMLScanner.cs new file mode 100644 index 0000000..ed41f84 --- /dev/null +++ b/src/Lucene.Net.Benchmark/Support/TagSoup/HTMLScanner.cs @@ -0,0 +1,745 @@ +// This file is part of TagSoup and is Copyright 2002-2008 by John Cowan. +// +// TagSoup is licensed under the Apache License, +// Version 2.0. You may obtain a copy of this license at +// http://www.apache.org/licenses/LICENSE-2.0 . You may also have +// additional legal rights not granted by this license. +// +// TagSoup is distributed in the hope that it will be useful, but +// unless required by applicable law or agreed to in writing, TagSoup +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS +// OF ANY KIND, either express or implied; not even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +// +// + +using Sax; +using System; +using System.IO; + +namespace TagSoup +{ + /// <summary> + /// This class implements a table-driven scanner for HTML, allowing for lots of + /// defects. It implements the Scanner interface, which accepts a Reader + /// object to fetch characters from and a ScanHandler object to report lexical + /// events to. + /// </summary> + public class HTMLScanner : IScanner, ILocator + { + // Start of state table + private const int S_ANAME = 1; + private const int S_APOS = 2; + private const int S_AVAL = 3; + private const int S_BB = 4; + private const int S_BBC = 5; + private const int S_BBCD = 6; + private const int S_BBCDA = 7; + private const int S_BBCDAT = 8; + private const int S_BBCDATA = 9; + private const int S_CDATA = 10; + private const int S_CDATA2 = 11; + private const int S_CDSECT = 12; + private const int S_CDSECT1 = 13; + private const int S_CDSECT2 = 14; + private const int S_COM = 15; + private const int S_COM2 = 16; + private const int S_COM3 = 17; + private const int S_COM4 = 18; + private const int S_DECL = 19; + private const int S_DECL2 = 20; + private const int S_DONE = 21; + private const int S_EMPTYTAG = 22; + private const int S_ENT = 23; + private const int S_EQ = 24; + private const int S_ETAG = 25; + private const int S_GI = 26; + private const int S_NCR = 27; + private const int S_PCDATA = 28; + private const int S_PI = 29; + private const int S_PITARGET = 30; + private const int S_QUOT = 31; + private const int S_STAGC = 32; + private const int S_TAG = 33; + private const int S_TAGWS = 34; + private const int S_XNCR = 35; + private const int A_ADUP = 1; + private const int A_ADUP_SAVE = 2; + private const int A_ADUP_STAGC = 3; + private const int A_ANAME = 4; + private const int A_ANAME_ADUP = 5; + private const int A_ANAME_ADUP_STAGC = 6; + private const int A_AVAL = 7; + private const int A_AVAL_STAGC = 8; + private const int A_CDATA = 9; + private const int A_CMNT = 10; + private const int A_DECL = 11; + private const int A_EMPTYTAG = 12; + private const int A_ENTITY = 13; + private const int A_ENTITY_START = 14; + private const int A_ETAG = 15; + private const int A_GI = 16; + private const int A_GI_STAGC = 17; + private const int A_LT = 18; + private const int A_LT_PCDATA = 19; + private const int A_MINUS = 20; + private const int A_MINUS2 = 21; + private const int A_MINUS3 = 22; + private const int A_PCDATA = 23; + private const int A_PI = 24; + private const int A_PITARGET = 25; + private const int A_PITARGET_PI = 26; + private const int A_SAVE = 27; + private const int A_SKIP = 28; + private const int A_SP = 29; + private const int A_STAGC = 30; + private const int A_UNGET = 31; + private const int A_UNSAVE_PCDATA = 32; + private static int[] statetable = { + S_ANAME, '/', A_ANAME_ADUP, S_EMPTYTAG, + S_ANAME, '=', A_ANAME, S_AVAL, + S_ANAME, '>', A_ANAME_ADUP_STAGC, S_PCDATA, + S_ANAME, 0, A_SAVE, S_ANAME, + S_ANAME, -1, A_ANAME_ADUP_STAGC, S_DONE, + S_ANAME, ' ', A_ANAME, S_EQ, + S_ANAME, '\n', A_ANAME, S_EQ, + S_ANAME, '\t', A_ANAME, S_EQ, + S_APOS, '\'', A_AVAL, S_TAGWS, + S_APOS, 0, A_SAVE, S_APOS, + S_APOS, -1, A_AVAL_STAGC, S_DONE, + S_APOS, ' ', A_SP, S_APOS, + S_APOS, '\n', A_SP, S_APOS, + S_APOS, '\t', A_SP, S_APOS, + S_AVAL, '\'', A_SKIP, S_APOS, + S_AVAL, '"', A_SKIP, S_QUOT, + S_AVAL, '>', A_AVAL_STAGC, S_PCDATA, + S_AVAL, 0, A_SAVE, S_STAGC, + S_AVAL, -1, A_AVAL_STAGC, S_DONE, + S_AVAL, ' ', A_SKIP, S_AVAL, + S_AVAL, '\n', A_SKIP, S_AVAL, + S_AVAL, '\t', A_SKIP, S_AVAL, + S_BB, 'C', A_SKIP, S_BBC, + S_BB, 0, A_SKIP, S_DECL, + S_BB, -1, A_SKIP, S_DONE, + S_BBC, 'D', A_SKIP, S_BBCD, + S_BBC, 0, A_SKIP, S_DECL, + S_BBC, -1, A_SKIP, S_DONE, + S_BBCD, 'A', A_SKIP, S_BBCDA, + S_BBCD, 0, A_SKIP, S_DECL, + S_BBCD, -1, A_SKIP, S_DONE, + S_BBCDA, 'T', A_SKIP, S_BBCDAT, + S_BBCDA, 0, A_SKIP, S_DECL, + S_BBCDA, -1, A_SKIP, S_DONE, + S_BBCDAT, 'A', A_SKIP, S_BBCDATA, + S_BBCDAT, 0, A_SKIP, S_DECL, + S_BBCDAT, -1, A_SKIP, S_DONE, + S_BBCDATA, '[', A_SKIP, S_CDSECT, + S_BBCDATA, 0, A_SKIP, S_DECL, + S_BBCDATA, -1, A_SKIP, S_DONE, + S_CDATA, '<', A_SAVE, S_CDATA2, + S_CDATA, 0, A_SAVE, S_CDATA, + S_CDATA, -1, A_PCDATA, S_DONE, + S_CDATA2, '/', A_UNSAVE_PCDATA, S_ETAG, + S_CDATA2, 0, A_SAVE, S_CDATA, + S_CDATA2, -1, A_UNSAVE_PCDATA, S_DONE, + S_CDSECT, ']', A_SAVE, S_CDSECT1, + S_CDSECT, 0, A_SAVE, S_CDSECT, + S_CDSECT, -1, A_SKIP, S_DONE, + S_CDSECT1, ']', A_SAVE, S_CDSECT2, + S_CDSECT1, 0, A_SAVE, S_CDSECT, + S_CDSECT1, -1, A_SKIP, S_DONE, + S_CDSECT2, '>', A_CDATA, S_PCDATA, + S_CDSECT2, 0, A_SAVE, S_CDSECT, + S_CDSECT2, -1, A_SKIP, S_DONE, + S_COM, '-', A_SKIP, S_COM2, + S_COM, 0, A_SAVE, S_COM2, + S_COM, -1, A_CMNT, S_DONE, + S_COM2, '-', A_SKIP, S_COM3, + S_COM2, 0, A_SAVE, S_COM2, + S_COM2, -1, A_CMNT, S_DONE, + S_COM3, '-', A_SKIP, S_COM4, + S_COM3, 0, A_MINUS, S_COM2, + S_COM3, -1, A_CMNT, S_DONE, + S_COM4, '-', A_MINUS3, S_COM4, + S_COM4, '>', A_CMNT, S_PCDATA, + S_COM4, 0, A_MINUS2, S_COM2, + S_COM4, -1, A_CMNT, S_DONE, + S_DECL, '-', A_SKIP, S_COM, + S_DECL, '[', A_SKIP, S_BB, + S_DECL, '>', A_SKIP, S_PCDATA, + S_DECL, 0, A_SAVE, S_DECL2, + S_DECL, -1, A_SKIP, S_DONE, + S_DECL2, '>', A_DECL, S_PCDATA, + S_DECL2, 0, A_SAVE, S_DECL2, + S_DECL2, -1, A_SKIP, S_DONE, + S_EMPTYTAG, '>', A_EMPTYTAG, S_PCDATA, + S_EMPTYTAG, 0, A_SAVE, S_ANAME, + S_EMPTYTAG, ' ', A_SKIP, S_TAGWS, + S_EMPTYTAG, '\n', A_SKIP, S_TAGWS, + S_EMPTYTAG, '\t', A_SKIP, S_TAGWS, + S_ENT, 0, A_ENTITY, S_ENT, + S_ENT, -1, A_ENTITY, S_DONE, + S_EQ, '=', A_SKIP, S_AVAL, + S_EQ, '>', A_ADUP_STAGC, S_PCDATA, + S_EQ, 0, A_ADUP_SAVE, S_ANAME, + S_EQ, -1, A_ADUP_STAGC, S_DONE, + S_EQ, ' ', A_SKIP, S_EQ, + S_EQ, '\n', A_SKIP, S_EQ, + S_EQ, '\t', A_SKIP, S_EQ, + S_ETAG, '>', A_ETAG, S_PCDATA, + S_ETAG, 0, A_SAVE, S_ETAG, + S_ETAG, -1, A_ETAG, S_DONE, + S_ETAG, ' ', A_SKIP, S_ETAG, + S_ETAG, '\n', A_SKIP, S_ETAG, + S_ETAG, '\t', A_SKIP, S_ETAG, + S_GI, '/', A_SKIP, S_EMPTYTAG, + S_GI, '>', A_GI_STAGC, S_PCDATA, + S_GI, 0, A_SAVE, S_GI, + S_GI, -1, A_SKIP, S_DONE, + S_GI, ' ', A_GI, S_TAGWS, + S_GI, '\n', A_GI, S_TAGWS, + S_GI, '\t', A_GI, S_TAGWS, + S_NCR, 0, A_ENTITY, S_NCR, + S_NCR, -1, A_ENTITY, S_DONE, + S_PCDATA, '&', A_ENTITY_START, S_ENT, + S_PCDATA, '<', A_PCDATA, S_TAG, + S_PCDATA, 0, A_SAVE, S_PCDATA, + S_PCDATA, -1, A_PCDATA, S_DONE, + S_PI, '>', A_PI, S_PCDATA, + S_PI, 0, A_SAVE, S_PI, + S_PI, -1, A_PI, S_DONE, + S_PITARGET, '>', A_PITARGET_PI, S_PCDATA, + S_PITARGET, 0, A_SAVE, S_PITARGET, + S_PITARGET, -1, A_PITARGET_PI, S_DONE, + S_PITARGET, ' ', A_PITARGET, S_PI, + S_PITARGET, '\n', A_PITARGET, S_PI, + S_PITARGET, '\t', A_PITARGET, S_PI, + S_QUOT, '"', A_AVAL, S_TAGWS, + S_QUOT, 0, A_SAVE, S_QUOT, + S_QUOT, -1, A_AVAL_STAGC, S_DONE, + S_QUOT, ' ', A_SP, S_QUOT, + S_QUOT, '\n', A_SP, S_QUOT, + S_QUOT, '\t', A_SP, S_QUOT, + S_STAGC, '>', A_AVAL_STAGC, S_PCDATA, + S_STAGC, 0, A_SAVE, S_STAGC, + S_STAGC, -1, A_AVAL_STAGC, S_DONE, + S_STAGC, ' ', A_AVAL, S_TAGWS, + S_STAGC, '\n', A_AVAL, S_TAGWS, + S_STAGC, '\t', A_AVAL, S_TAGWS, + S_TAG, '!', A_SKIP, S_DECL, + S_TAG, '/', A_SKIP, S_ETAG, + S_TAG, '?', A_SKIP, S_PITARGET, + S_TAG, '<', A_SAVE, S_TAG, + S_TAG, 0, A_SAVE, S_GI, + S_TAG, -1, A_LT_PCDATA, S_DONE, + S_TAG, ' ', A_LT, S_PCDATA, + S_TAG, '\n', A_LT, S_PCDATA, + S_TAG, '\t', A_LT, S_PCDATA, + S_TAGWS, '/', A_SKIP, S_EMPTYTAG, + S_TAGWS, '>', A_STAGC, S_PCDATA, + S_TAGWS, 0, A_SAVE, S_ANAME, + S_TAGWS, -1, A_STAGC, S_DONE, + S_TAGWS, ' ', A_SKIP, S_TAGWS, + S_TAGWS, '\n', A_SKIP, S_TAGWS, + S_TAGWS, '\t', A_SKIP, S_TAGWS, + S_XNCR, 0, A_ENTITY, S_XNCR, + S_XNCR, -1, A_ENTITY, S_DONE, + + }; + private static readonly string[] debug_actionnames = { "", "A_ADUP", "A_ADUP_SAVE", "A_ADUP_STAGC", "A_ANAME", "A_ANAME_ADUP", "A_ANAME_ADUP_STAGC", "A_AVAL", "A_AVAL_STAGC", "A_CDATA", "A_CMNT", "A_DECL", "A_EMPTYTAG", "A_ENTITY", "A_ENTITY_START", "A_ETAG", "A_GI", "A_GI_STAGC", "A_LT", "A_LT_PCDATA", "A_MINUS", "A_MINUS2", "A_MINUS3", "A_PCDATA", "A_PI", "A_PITARGET", "A_PITARGET_PI", "A_SAVE", "A_SKIP", "A_SP", "A_STAGC", "A_UNGET", "A_UNSAVE_PCDATA" }; + private static readonly string[] debug_statenames = { "", "S_ANAME", "S_APOS", "S_AVAL", "S_BB", "S_BBC", "S_BBCD", "S_BBCDA", "S_BBCDAT", "S_BBCDATA", "S_CDATA", "S_CDATA2", "S_CDSECT", "S_CDSECT1", "S_CDSECT2", "S_COM", "S_COM2", "S_COM3", "S_COM4", "S_DECL", "S_DECL2", "S_DONE", "S_EMPTYTAG", "S_ENT", "S_EQ", "S_ETAG", "S_GI", "S_NCR", "S_PCDATA", "S_PI", "S_PITARGET", "S_QUOT", "S_STAGC", "S_TAG", "S_TAGWS", "S_XNCR" }; + + // End of state table + + private string thePublicid; // Locator state + private string theSystemid; + private int theLastLine; + private int theLastColumn; + private int theCurrentLine; + private int theCurrentColumn; + + int theState; // Current state + int theNextState; // Next state + char[] theOutputBuffer = new char[200]; // Output buffer + int theSize; // Current buffer size + int[] theWinMap = { // Windows chars map + 0x20AC, 0xFFFD, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021, + 0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0xFFFD, 0x017D, 0xFFFD, + 0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, + 0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0xFFFD, 0x017E, 0x0178}; + + ///<summary> + /// Index into the state table for [state][input character - 2]. + /// The state table consists of 4-entry runs on the form + /// { current state, input character, action, next state }. + /// We precompute the index into the state table for all possible + /// { current state, input character } and store the result in + /// the statetableIndex array. Since only some input characters + /// are present in the state table, we only do the computation for + /// characters 0 to the highest character value in the state table. + /// An input character of -2 is used to cover all other characters + /// as -2 is guaranteed not to match any input character entry + /// in the state table. + /// <para>When doing lookups, the input character should first be tested + /// to be in the range [-1 (inclusive), statetableIndexMaxChar (exclusive)]. + /// if it isn't use -2 as the input character. + /// <para>Finally, add 2 to the input character to cover for the fact that + /// Java doesn't support negative array indexes. Then look up + /// the value in the statetableIndex. If the value is -1, then + /// no action or next state was found for the { state, input } that + /// you had. If it isn't -1, then action = statetable[value + 2] and + /// next state = statetable[value + 3]. That is, the value points + /// to the start of the answer 4-tuple in the statetable. + /// </summary> + static short[][] statetableIndex; + + ///<summary> + /// The highest character value seen in the statetable. + /// See the doc comment for statetableIndex to see how this + /// is used. + /// </summary> + static int statetableIndexMaxChar; + public HTMLScanner() + { + int maxState = -1; + int maxChar = -1; + for (int i = 0; i < statetable.Length; i += 4) + { + if (statetable[i] > maxState) + { + maxState = statetable[i]; + } + if (statetable[i + 1] > maxChar) + { + maxChar = statetable[i + 1]; + } + } + statetableIndexMaxChar = maxChar + 1; + + statetableIndex = new short[maxState + 1][]; + + for (int i = 0; i <= maxState; i++) + { + statetableIndex[i] = new short[maxChar + 3]; + } + for (int theState = 0; theState <= maxState; ++theState) + { + for (int ch = -2; ch <= maxChar; ++ch) + { + int hit = -1; + int action = 0; + for (int i = 0; i < statetable.Length; i += 4) + { + if (theState != statetable[i]) + { + if (action != 0) break; + continue; + } + if (statetable[i + 1] == 0) + { + hit = i; + action = statetable[i + 2]; + } + else if (statetable[i + 1] == ch) + { + hit = i; + action = statetable[i + 2]; + break; + } + } + statetableIndex[theState][ch + 2] = (short)hit; + } + } + } + + // Locator implementation + + public virtual int LineNumber + { + get { return theLastLine; } + } + public virtual int ColumnNumber + { + get { return theLastColumn; } + } + public virtual string PublicId + { + get { return thePublicid; } + } + public virtual string SystemId + { + get { return theSystemid; } + } + + + // Scanner implementation + + /// <summary> + /// Reset document locator, supplying systemid and publicid. + /// </summary> + /// <param name="systemid">System id</param> + /// <param name="publicid">Public id</param> + public virtual void ResetDocumentLocator(string publicid, string systemid) + { + thePublicid = publicid; + theSystemid = systemid; + theLastLine = theLastColumn = theCurrentLine = theCurrentColumn = 0; + } + + /// <summary> + /// Scan HTML source, reporting lexical events. + /// </summary> + /// <param name="r">Reader that provides characters</param> + /// <param name="h">ScanHandler that accepts lexical events.</param> + public virtual void Scan(TextReader r, IScanHandler h) + { + theState = S_PCDATA; + + int firstChar = r.Peek(); // Remove any leading BOM + if (firstChar == '\uFEFF') r.Read(); + + while (theState != S_DONE) + { + int ch = r.Peek(); + bool unread = false; + + // Process control characters + if (ch >= 0x80 && ch <= 0x9F) ch = theWinMap[ch - 0x80]; + + if (ch == '\r') + { + r.Read(); + ch = r.Peek(); // expect LF next + if (ch != '\n') + { + unread = true; + ch = '\n'; + } + } + + if (ch == '\n') + { + theCurrentLine++; + theCurrentColumn = 0; + } + else + { + theCurrentColumn++; + } + + if (!(ch >= 0x20 || ch == '\n' || ch == '\t' || ch == -1)) continue; + + // Search state table + int adjCh = (ch >= -1 && ch < statetableIndexMaxChar) ? ch : -2; + int statetableRow = statetableIndex[theState][adjCh + 2]; + int action = 0; + if (statetableRow != -1) + { + action = statetable[statetableRow + 2]; + theNextState = statetable[statetableRow + 3]; + } + + // System.err.println("In " + debug_statenames[theState] + " got " + nicechar(ch) + " doing " + debug_actionnames[action] + " then " + debug_statenames[theNextState]); + switch (action) + { + case 0: + throw new Exception( + "HTMLScanner can't cope with " + (int)ch + " in state " + + (int)theState); + case A_ADUP: + h.Adup(theOutputBuffer, 0, theSize); + theSize = 0; + break; + case A_ADUP_SAVE: + h.Adup(theOutputBuffer, 0, theSize); + theSize = 0; + Save(ch, h); + break; + case A_ADUP_STAGC: + h.Adup(theOutputBuffer, 0, theSize); + theSize = 0; + h.STagC(theOutputBuffer, 0, theSize); + break; + case A_ANAME: + h.Aname(theOutputBuffer, 0, theSize); + theSize = 0; + break; + case A_ANAME_ADUP: + h.Aname(theOutputBuffer, 0, theSize); + theSize = 0; + h.Adup(theOutputBuffer, 0, theSize); + break; + case A_ANAME_ADUP_STAGC: + h.Aname(theOutputBuffer, 0, theSize); + theSize = 0; + h.Adup(theOutputBuffer, 0, theSize); + h.STagC(theOutputBuffer, 0, theSize); + break; + case A_AVAL: + h.Aval(theOutputBuffer, 0, theSize); + theSize = 0; + break; + case A_AVAL_STAGC: + h.Aval(theOutputBuffer, 0, theSize); + theSize = 0; + h.STagC(theOutputBuffer, 0, theSize); + break; + case A_CDATA: + Mark(); + // suppress the final "]]" in the buffer + if (theSize > 1) theSize -= 2; + h.PCDATA(theOutputBuffer, 0, theSize); + theSize = 0; + break; + case A_ENTITY_START: + h.PCDATA(theOutputBuffer, 0, theSize); + theSize = 0; + Save(ch, h); + break; + case A_ENTITY: + Mark(); + char ch1 = (char)ch; + // System.out.println("Got " + ch1 + " in state " + ((theState == S_ENT) ? "S_ENT" : ((theState == S_NCR) ? "S_NCR" : "UNK"))); + if (theState == S_ENT && ch1 == '#') + { + theNextState = S_NCR; + Save(ch, h); + break; + } + else if (theState == S_NCR && (ch1 == 'x' || ch1 == 'X')) + { + theNextState = S_XNCR; + Save(ch, h); + break; + } + else if (theState == S_ENT && char.IsLetterOrDigit(ch1)) + { + Save(ch, h); + break; + } + else if (theState == S_NCR && char.IsDigit(ch1)) + { + Save(ch, h); + break; + } + else if (theState == S_XNCR && (char.IsDigit(ch1) || "abcdefABCDEF".IndexOf(ch1) != -1)) + { + Save(ch, h); + break; + } + + // The whole entity reference has been collected + // System.err.println("%%" + new String(theOutputBuffer, 0, theSize)); + h.Entity(theOutputBuffer, 1, theSize - 1); + int ent = h.GetEntity(); + // System.err.println("%% value = " + ent); + if (ent != 0) + { + theSize = 0; + if (ent >= 0x80 && ent <= 0x9F) + { + ent = theWinMap[ent - 0x80]; + } + if (ent < 0x20) + { + // Control becomes space + ent = 0x20; + } + else if (ent >= 0xD800 && ent <= 0xDFFF) + { + // Surrogates get dropped + ent = 0; + } + else if (ent <= 0xFFFF) + { + // BMP character + Save(ent, h); + } + else + { + // Astral converted to two surrogates + ent -= 0x10000; + Save((ent >> 10) + 0xD800, h); + Save((ent & 0x3FF) + 0xDC00, h); + } + if (ch != ';') + { + unread = true; + theCurrentColumn--; + } + } + else + { + unread = true; + theCurrentColumn--; + } + theNextState = S_PCDATA; + break; + case A_ETAG: + h.ETag(theOutputBuffer, 0, theSize); + theSize = 0; + break; + case A_DECL: + h.Decl(theOutputBuffer, 0, theSize); + theSize = 0; + break; + case A_GI: + h.GI(theOutputBuffer, 0, theSize); + theSize = 0; + break; + case A_GI_STAGC: + h.GI(theOutputBuffer, 0, theSize); + theSize = 0; + h.STagC(theOutputBuffer, 0, theSize); + break; + case A_LT: + Mark(); + Save('<', h); + Save(ch, h); + break; + case A_LT_PCDATA: + Mark(); + Save('<', h); + h.PCDATA(theOutputBuffer, 0, theSize); + theSize = 0; + break; + case A_PCDATA: + Mark(); + h.PCDATA(theOutputBuffer, 0, theSize); + theSize = 0; + break; + case A_CMNT: + Mark(); + h.Cmnt(theOutputBuffer, 0, theSize); + theSize = 0; + break; + case A_MINUS3: + Save('-', h); + Save(' ', h); + break; + case A_MINUS2: + Save('-', h); + Save(' ', h); + Save('-', h); + Save(ch, h); + // fall through into A_MINUS + break; + case A_MINUS: + Save('-', h); + Save(ch, h); + break; + case A_PI: + Mark(); + h.PI(theOutputBuffer, 0, theSize); + theSize = 0; + break; + case A_PITARGET: + h.PITarget(theOutputBuffer, 0, theSize); + theSize = 0; + break; + case A_PITARGET_PI: + h.PITarget(theOutputBuffer, 0, theSize); + theSize = 0; + h.PI(theOutputBuffer, 0, theSize); + break; + case A_SAVE: + Save(ch, h); + break; + case A_SKIP: + break; + case A_SP: + Save(' ', h); + break; + case A_STAGC: + h.STagC(theOutputBuffer, 0, theSize); + theSize = 0; + break; + case A_EMPTYTAG: + Mark(); + // System.err.println("%%% Empty tag seen"); + if (theSize > 0) h.GI(theOutputBuffer, 0, theSize); + theSize = 0; + h.STagE(theOutputBuffer, 0, theSize); + break; + case A_UNGET: + unread = true; + theCurrentColumn--; + break; + case A_UNSAVE_PCDATA: + if (theSize > 0) theSize--; + h.PCDATA(theOutputBuffer, 0, theSize); + theSize = 0; + break; + default: + throw new Exception("Can't process state " + action); + } + if (!unread) + { + r.Read(); + } + theState = theNextState; + } + h.EOF(theOutputBuffer, 0, 0); + } + + /// <summary> + /// Mark the current scan position as a "point of interest" - start of a tag, + /// cdata, processing instruction etc. + /// </summary> + private void Mark() + { + theLastColumn = theCurrentColumn; + theLastLine = theCurrentLine; + } + + /// <summary> + /// A callback for the ScanHandler that allows it to force + /// the lexer state to CDATA content (no markup is recognized except + /// the end of element. + /// </summary> + public virtual void StartCDATA() { theNextState = S_CDATA; } + + private void Save(int ch, IScanHandler h) + { + if (theSize >= theOutputBuffer.Length - 20) + { + if (theState == S_PCDATA || theState == S_CDATA) + { + // Return a buffer-sized chunk of PCDATA + h.PCDATA(theOutputBuffer, 0, theSize); + theSize = 0; + } + else + { + // Grow the buffer size + char[] newOutputBuffer = new char[theOutputBuffer.Length * 2]; + Array.Copy(theOutputBuffer, 0, newOutputBuffer, 0, theSize + 1); + theOutputBuffer = newOutputBuffer; + } + } + theOutputBuffer[theSize++] = (char)ch; + } + + /** + Test procedure. Reads HTML from the standard input and writes + PYX to the standard output. + */ + + // public static void main(string[] argv) { + // IScanner s = new HTMLScanner(); + // TextReader r = new StreamReader(System.in, "UTF-8"); + // TextWriter w = new StreamWriter(System.out, "UTF-8"); + // PYXWriter pw = new PYXWriter(w); + // s.scan(r, pw); + // w.close(); + // } + + + private static string NiceChar(int value) + { + if (value == '\n') return "\\n"; + if (value < 32) return "0x" + value.ToString("X"); + return "'" + ((char)value) + "'"; + } + } +}
