lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [48/58] lucenenet git commit: QueryParser: Fixed documentation comments
Date Tue, 06 Dec 2016 15:12:23 GMT
QueryParser: Fixed documentation comments


Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/ced03f59
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/ced03f59
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/ced03f59

Branch: refs/heads/master
Commit: ced03f598dce960d323e3a0b3d9862bf1c648cef
Parents: 98a37e1
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Tue Dec 6 10:37:01 2016 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Tue Dec 6 10:37:01 2016 +0700

----------------------------------------------------------------------
 .../Analyzing/AnalyzingQueryParser.cs           |  32 ++---
 .../Classic/CharStream.cs                       |  78 +++++-----
 .../Classic/FastCharStream.cs                   |  12 +-
 .../Classic/MultiFieldQueryParser.cs            | 144 ++++++++-----------
 .../Classic/ParseException.cs                   |  29 ++--
 .../Classic/QueryParser.cs                      |  58 ++++----
 .../Classic/QueryParserBase.cs                  | 119 ++++++++-------
 .../Classic/QueryParserTokenManager.cs          |   4 +-
 .../ComplexPhrase/ComplexPhraseQueryParser.cs   |  14 +-
 .../Ext/ExtendableQueryParser.cs                |  21 ++-
 src/Lucene.Net.QueryParser/Ext/Extensions.cs    |  40 ++++--
 .../Ext/ParserExtension.cs                      |   7 +-
 .../Flexible/Standard/Parser/CharStream.cs      |   4 +-
 .../Flexible/Standard/Parser/FastCharStream.cs  |   4 +-
 .../Flexible/Standard/Parser/ParseException.cs  |   1 -
 .../Simple/SimpleQueryParser.cs                 | 132 +++++++----------
 .../Surround/Parser/CharStream.cs               |  22 ++-
 .../Surround/Parser/FastCharStream.cs           |   6 +-
 .../Surround/Parser/ParseException.cs           |  27 ++--
 .../Surround/Parser/QueryParser.cs              |  87 +++++------
 .../Surround/Parser/QueryParserTokenManager.cs  |  28 ++--
 .../Surround/Query/BasicQueryFactory.cs         |   2 -
 .../Surround/Query/DistanceSubQuery.cs          |   4 +-
 .../Surround/Query/RewriteQuery.cs              |   2 +-
 .../Surround/Query/SimpleTerm.cs                |   2 +-
 .../Surround/Query/SpanNearClauseFactory.cs     |  20 +--
 .../Surround/Query/SrndQuery.cs                 |  18 +--
 .../Surround/Query/SrndTruncQuery.cs            |   3 +
 28 files changed, 417 insertions(+), 503 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Analyzing/AnalyzingQueryParser.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Analyzing/AnalyzingQueryParser.cs b/src/Lucene.Net.QueryParser/Analyzing/AnalyzingQueryParser.cs
index 34c50db..300cd31 100644
--- a/src/Lucene.Net.QueryParser/Analyzing/AnalyzingQueryParser.cs
+++ b/src/Lucene.Net.QueryParser/Analyzing/AnalyzingQueryParser.cs
@@ -26,14 +26,14 @@ namespace Lucene.Net.QueryParsers.Analyzing
      */
 
     /// <summary>
-    /// Overrides Lucene's default QueryParser so that Fuzzy-, Prefix-, Range-, and WildcardQuerys
-    /// are also passed through the given analyzer, but wildcard characters <code>*</code> and
-    /// <code>?</code> don't get removed from the search terms.
-    /// 
-    /// <p><b>Warning:</b> This class should only be used with analyzers that do not use stopwords
-    /// or that add tokens. Also, several stemming analyzers are inappropriate: for example, GermanAnalyzer 
-    /// will turn <code>H&auml;user</code> into <code>hau</code>, but <code>H?user</code> will 
-    /// become <code>h?user</code> when using this parser and thus no match would be found (i.e.
+    /// Overrides Lucene's default <see cref="QueryParser"/> so that Fuzzy-, Prefix-, Range-, and WildcardQuerys
+    /// are also passed through the given analyzer, but wildcard characters <c>*</c> and
+    /// <c>?</c> don't get removed from the search terms.
+    /// <para/>
+    /// <b>Warning:</b> This class should only be used with analyzers that do not use stopwords
+    /// or that add tokens. Also, several stemming analyzers are inappropriate: for example, <see cref="Analysis.De.GermanAnalyzer"/>  
+    /// will turn <c>H&auml;user</c> into <c>hau</c>, but <c>H?user</c> will 
+    /// become <c>h?user</c> when using this parser and thus no match would be found (i.e.
     /// using this parser will be no improvement over QueryParser in such cases). 
     /// </summary>
     public class AnalyzingQueryParser : Classic.QueryParser
@@ -53,10 +53,10 @@ namespace Lucene.Net.QueryParsers.Analyzing
         /// character as its last character. Since this is a special case
         /// of generic wildcard term, and such a query can be optimized easily,
         /// this usually results in a different query object.
-        /// <p>
+        /// <para/>
         /// Depending on analyzer and settings, a prefix term may (most probably will)
         /// be lower-cased automatically. It <b>will</b> go through the default Analyzer.
-        /// <p>
+        /// <para/>
         /// Overrides super class, by passing terms through analyzer.
         /// </summary>
         /// <param name="field">Name of the field query will use.</param>
@@ -112,13 +112,13 @@ namespace Lucene.Net.QueryParsers.Analyzing
         /// <summary>
         /// Called when parser parses an input term
         /// that uses prefix notation; that is, contains a single '*' wildcard
-        /// character as its last character.Since this is a special case
+        /// character as its last character. Since this is a special case
         /// of generic wildcard term, and such a query can be optimized easily,
         /// this usually results in a different query object.
-        /// <p>
+        /// <para/>
         /// Depending on analyzer and settings, a prefix term may (most probably will)
         /// be lower-cased automatically. It <b>will</b> go through the default Analyzer.
-        /// <p>
+        /// <para/>
         /// Overrides super class, by passing terms through analyzer.
         /// </summary>
         /// <param name="field">Name of the field query will use.</param>
@@ -132,10 +132,10 @@ namespace Lucene.Net.QueryParsers.Analyzing
 
         /// <summary>
         /// Called when parser parses an input term that has the fuzzy suffix (~) appended.
-        /// <p>
+        /// <para/>
         /// Depending on analyzer and settings, a fuzzy term may (most probably will)
         /// be lower-cased automatically. It <b>will</b> go through the default Analyzer.
-        /// <p>
+        /// <para/>
         /// Overrides super class, by passing terms through analyzer.
         /// </summary>
         /// <param name="field">Name of the field query will use.</param>
@@ -149,7 +149,7 @@ namespace Lucene.Net.QueryParsers.Analyzing
         }
 
         /// <summary>
-        /// Returns the analyzed form for the given chunk
+        /// Returns the analyzed form for the given chunk.
         /// 
         /// If the analyzer produces more than one output token from the given chunk,
         /// a ParseException is thrown.

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Classic/CharStream.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Classic/CharStream.cs b/src/Lucene.Net.QueryParser/Classic/CharStream.cs
index 8f1783d..5ce3060 100644
--- a/src/Lucene.Net.QueryParser/Classic/CharStream.cs
+++ b/src/Lucene.Net.QueryParser/Classic/CharStream.cs
@@ -19,47 +19,41 @@ namespace Lucene.Net.QueryParsers.Classic
      * limitations under the License.
      */
 
-	
-	/// <summary> 
+
+    /// <summary> 
     /// This interface describes a character stream that maintains line and
-	/// column number positions of the characters.  It also has the capability
-	/// to backup the stream to some extent.  An implementation of this
-	/// interface is used in the TokenManager implementation generated by
-	/// JavaCCParser.
-	/// 
-	/// All the methods except backup can be implemented in any fashion. backup
-	/// needs to be implemented correctly for the correct operation of the lexer.
-	/// Rest of the methods are all used to get information like line number,
-	/// column number and the string that constitutes a token and are not used
-	/// by the lexer. Hence their implementation won't affect the generated lexer's
-	/// operation.
-	/// </summary>
-	public interface ICharStream
+    /// column number positions of the characters.  It also has the capability
+    /// to backup the stream to some extent.  An implementation of this
+    /// interface is used in the TokenManager implementation generated by
+    /// JavaCCParser.
+    /// 
+    /// All the methods except <see cref="BackUp(int)"/> can be implemented in any fashion. <see cref="BackUp(int)"/>
+    /// needs to be implemented correctly for the correct operation of the lexer.
+    /// Rest of the methods are all used to get information like line number,
+    /// column number and the string that constitutes a token and are not used
+    /// by the lexer. Hence their implementation won't affect the generated lexer's
+    /// operation.
+    /// </summary>
+    public interface ICharStream
 	{
 		/// <summary> 
         /// Returns the next character from the selected input.  The method
 		/// of selecting the input is the responsibility of the class
-		/// implementing this interface.  Can throw any java.io.IOException.
+		/// implementing this interface.  Can throw any <see cref="System.IO.IOException"/>.
 		/// </summary>
 		char ReadChar();
 
 	    /// <summary>
         /// Returns the column position of the character last read.
         /// </summary>
-	    /// <deprecated>
-	    /// </deprecated>
-	    /// <seealso cref="EndColumn">
-	    /// </seealso>
+	    /// <seealso cref="EndColumn"/>
 	    [Obsolete]
 	    int Column { get; }
 
 	    /// <summary>
         /// Returns the line number of the character last read.
         /// </summary>
-	    /// <deprecated>
-	    /// </deprecated>
-	    /// <seealso cref="EndLine">
-	    /// </seealso>
+	    /// <seealso cref="EndLine"/>
 	    [Obsolete]
 	    int Line { get; }
 
@@ -94,13 +88,13 @@ namespace Lucene.Net.QueryParsers.Classic
 		/// token and it is the implemetation's responsibility to do this right.
 		/// </summary>
 		void BackUp(int amount);
-		
-		/// <summary> 
+
+        /// <summary> 
         /// Returns the next character that marks the beginning of the next token.
-		/// All characters must remain in the buffer between two successive calls
-		/// to this method to implement backup correctly.
-		/// </summary>
-		char BeginToken();
+        /// All characters must remain in the buffer between two successive calls
+        /// to this method to implement <see cref="BackUp(int)"/> correctly.
+        /// </summary>
+        char BeginToken();
 
 	    /// <summary> 
         /// Returns a string made up of characters from the marked token beginning
@@ -110,18 +104,20 @@ namespace Lucene.Net.QueryParsers.Classic
 	    /// </summary>
 	    string Image { get; }
 
-	    /// <summary> 
+        /// <summary> 
         /// Returns an array of characters that make up the suffix of length 'len' for
-		/// the currently matched token. This is used to build up the matched string
-		/// for use in actions in the case of MORE. A simple and inefficient
-		/// implementation of this is as follows :
-		/// 
-		/// {
-		/// string t = GetImage();
-		/// return t.substring(t.length() - len, t.length()).toCharArray();
-		/// }
-		/// </summary>
-		char[] GetSuffix(int len);
+        /// the currently matched token. This is used to build up the matched string
+        /// for use in actions in the case of MORE. A simple and inefficient
+        /// implementation of this is as follows :
+        /// 
+        /// <code>
+        /// {
+        ///     string t = Image;
+        ///     return t.Substring(t.Length - len, len).ToCharArray();
+        /// }
+        /// </code>
+        /// </summary>
+        char[] GetSuffix(int len);
 		
 		/// <summary> 
         /// The lexer calls this function to indicate that it is done with the stream

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Classic/FastCharStream.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Classic/FastCharStream.cs b/src/Lucene.Net.QueryParser/Classic/FastCharStream.cs
index 8f963ee..1a25b42 100644
--- a/src/Lucene.Net.QueryParser/Classic/FastCharStream.cs
+++ b/src/Lucene.Net.QueryParser/Classic/FastCharStream.cs
@@ -20,7 +20,9 @@ namespace Lucene.Net.QueryParsers.Classic
      */
 	
 	/// <summary>
-    /// An efficient implementation of JavaCC's CharStream interface.  <p/>Note that
+    /// An efficient implementation of JavaCC's <see cref="ICharStream"/> interface.  
+    /// <para/>
+    /// Note that
 	/// this does not do line-number counting, but instead keeps track of the
 	/// character position of the token in the input, as required by Lucene's <see cref="Lucene.Net.Analysis.Token" />
 	/// API.
@@ -36,11 +38,11 @@ namespace Lucene.Net.QueryParsers.Classic
 		internal int bufferStart = 0; // position in file of buffer
 		
 		internal System.IO.TextReader input; // source of chars
-		
-		/// <summary>
-        /// Constructs from a Reader. 
+
+        /// <summary>
+        /// Constructs from a <see cref="System.IO.TextReader"/>. 
         /// </summary>
-		public FastCharStream(System.IO.TextReader r)
+        public FastCharStream(System.IO.TextReader r)
 		{
 			input = r;
 		}

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Classic/MultiFieldQueryParser.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Classic/MultiFieldQueryParser.cs b/src/Lucene.Net.QueryParser/Classic/MultiFieldQueryParser.cs
index 291f44c..378f2b0 100644
--- a/src/Lucene.Net.QueryParser/Classic/MultiFieldQueryParser.cs
+++ b/src/Lucene.Net.QueryParser/Classic/MultiFieldQueryParser.cs
@@ -24,7 +24,7 @@ namespace Lucene.Net.QueryParsers.Classic
 
 
     /// <summary> 
-    /// A QueryParser which constructs queries to search multiple fields.
+    /// A <see cref="QueryParser"/> which constructs queries to search multiple fields.
     /// </summary>
     public class MultiFieldQueryParser : QueryParser
     {
@@ -32,39 +32,39 @@ namespace Lucene.Net.QueryParsers.Classic
         protected internal IDictionary<string, float> boosts;
 
         /// <summary> 
-        /// Creates a MultiFieldQueryParser. Allows passing of a map with term to
+        /// Creates a <see cref="MultiFieldQueryParser"/>. Allows passing of a map with term to
         /// Boost, and the boost to apply to each term.
         /// 
-        /// <p/>
-        /// It will, when parse(string query) is called, construct a query like this
+        /// <para/>
+        /// It will, when <see cref="QueryParserBase.Parse(string)"/> is called, construct a query like this
         /// (assuming the query consists of two terms and you specify the two fields
         /// <c>title</c> and <c>body</c>):
-        /// <p/>
+        /// <para/>
         /// 
         /// <code>
         /// (title:term1 body:term1) (title:term2 body:term2)
         /// </code>
         /// 
-        /// <p/>
-        /// When setDefaultOperator(AND_OPERATOR) is set, the result will be:
-        /// <p/>
+        /// <para/>
+        /// When <see cref="QueryParserBase.DefaultOperator"/> is set to <see cref="QueryParserBase.AND_OPERATOR"/>, the result will be:
+        /// <para/>
         /// 
         /// <code>
         /// +(title:term1 body:term1) +(title:term2 body:term2)
         /// </code>
         /// 
-        /// <p/>
+        /// <para/>
         /// When you pass a boost (title=>5 body=>10) you can get
-        /// <p/>
+        /// <para/>
         /// 
         /// <code>
         /// +(title:term1^5.0 body:term1^10.0) +(title:term2^5.0 body:term2^10.0)
         /// </code>
         /// 
-        /// <p/>
+        /// <para/>
         /// In other words, all the query's terms must appear, but it doesn't matter
         /// in what fields they appear.
-        /// <p/>
+        /// <para/>
         /// </summary>
         public MultiFieldQueryParser(LuceneVersion matchVersion, string[] fields, Analyzer analyzer, IDictionary<string, float> boosts)
             : this(matchVersion, fields, analyzer)
@@ -75,28 +75,28 @@ namespace Lucene.Net.QueryParsers.Classic
         /// <summary> 
         /// Creates a MultiFieldQueryParser.
         /// 
-        /// <p/>
-        /// It will, when parse(string query) is called, construct a query like this
+        /// <para/>
+        /// It will, when <see cref="QueryParserBase.Parse(string)"/> is called, construct a query like this
         /// (assuming the query consists of two terms and you specify the two fields
         /// <c>title</c> and <c>body</c>):
-        /// <p/>
+        /// <para/>
         /// 
         /// <code>
         /// (title:term1 body:term1) (title:term2 body:term2)
         /// </code>
         /// 
-        /// <p/>
-        /// When setDefaultOperator(AND_OPERATOR) is set, the result will be:
-        /// <p/>
+        /// <para/>
+        /// When <see cref="QueryParserBase.DefaultOperator"/> is set to <see cref="QueryParserBase.AND_OPERATOR"/>, the result will be:
+        /// <para/>
         /// 
         /// <code>
         /// +(title:term1 body:term1) +(title:term2 body:term2)
         /// </code>
         /// 
-        /// <p/>
+        /// <para/>
         /// In other words, all the query's terms must appear, but it doesn't matter
         /// in what fields they appear.
-        /// <p/>
+        /// <para/>
         /// </summary>
         public MultiFieldQueryParser(LuceneVersion matchVersion, string[] fields, Analyzer analyzer)
             : base(matchVersion, null, analyzer)
@@ -249,7 +249,7 @@ namespace Lucene.Net.QueryParsers.Classic
 
         /// <summary> 
         /// Parses a query which searches on the fields specified.
-        /// <p/>
+        /// <para/>
         /// If x fields are specified, this effectively constructs:
         /// 
         /// <code>
@@ -258,21 +258,15 @@ namespace Lucene.Net.QueryParsers.Classic
         /// 
         /// </summary>
         /// <param name="matchVersion">Lucene version to match; this is passed through to
-        /// QueryParser.
-        /// </param>
-        /// <param name="queries">Queries strings to parse
-        /// </param>
-        /// <param name="fields">Fields to search on
-        /// </param>
-        /// <param name="analyzer">Analyzer to use
-        /// </param>
-        /// <throws>  ParseException </throws>
-        /// <summary>             if query parsing fails
-        /// </summary>
-        /// <throws>  IllegalArgumentException </throws>
-        /// <summary>             if the length of the queries array differs from the length of
+        /// <see cref="QueryParser"/>.</param>
+        /// <param name="queries">Queries strings to parse</param>
+        /// <param name="fields">Fields to search on</param>
+        /// <param name="analyzer">Analyzer to use</param>
+        /// <exception cref="ParseException">if query parsing fails</exception>
+        /// <exception cref="System.ArgumentException">
+        /// if the length of the queries array differs from the length of
         /// the fields array
-        /// </summary>
+        /// </exception>
         public static Query Parse(LuceneVersion matchVersion, string[] queries, string[] fields, Analyzer analyzer)
         {
             if (queries.Length != fields.Length)
@@ -293,16 +287,16 @@ namespace Lucene.Net.QueryParsers.Classic
         /// <summary> 
         /// Parses a query, searching on the fields specified. Use this if you need
         /// to specify certain fields as required, and others as prohibited.
-        /// <p/>
-        /// Uasge:
+        /// <para/>
+        /// Usage:
         /// <code>
-        /// string[] fields = {&quot;filename&quot;, &quot;contents&quot;, &quot;description&quot;};
-        /// BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
-        /// BooleanClause.Occur.MUST,
-        /// BooleanClause.Occur.MUST_NOT};
-        /// MultiFieldQueryParser.parse(&quot;query&quot;, fields, flags, analyzer);
+        ///     string[] fields = {&quot;filename&quot;, &quot;contents&quot;, &quot;description&quot;};
+        ///     BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
+        ///         BooleanClause.Occur.MUST,
+        ///         BooleanClause.Occur.MUST_NOT};
+        ///     MultiFieldQueryParser.Parse(&quot;query&quot;, fields, flags, analyzer);
         /// </code>
-        /// <p/>
+        /// <para/>
         /// The code above would construct a query:
         /// 
         /// <code>
@@ -311,23 +305,16 @@ namespace Lucene.Net.QueryParsers.Classic
         /// 
         /// </summary>
         /// <param name="matchVersion">Lucene version to match; this is passed through to
-        /// QueryParser.
-        /// </param>
-        /// <param name="query">Query string to parse
-        /// </param>
-        /// <param name="fields">Fields to search on
-        /// </param>
-        /// <param name="flags">Flags describing the fields
-        /// </param>
-        /// <param name="analyzer">Analyzer to use
-        /// </param>
-        /// <throws>  ParseException </throws>
-        /// <summary>             if query parsing fails
-        /// </summary>
-        /// <throws>  IllegalArgumentException </throws>
-        /// <summary>             if the length of the fields array differs from the length of
+        /// <see cref="QueryParser"/>.</param>
+        /// <param name="query">Query string to parse</param>
+        /// <param name="fields">Fields to search on</param>
+        /// <param name="flags">Flags describing the fields</param>
+        /// <param name="analyzer">Analyzer to use</param>
+        /// <exception cref="ParseException">if query parsing fails</exception>
+        /// <exception cref="System.ArgumentException">
+        /// if the length of the fields array differs from the length of
         /// the flags array
-        /// </summary>
+        /// </exception>
         public static Query Parse(LuceneVersion matchVersion, string query, string[] fields, BooleanClause.Occur[] flags, Analyzer analyzer)
         {
             if (fields.Length != flags.Length)
@@ -348,17 +335,17 @@ namespace Lucene.Net.QueryParsers.Classic
         /// <summary> 
         /// Parses a query, searching on the fields specified. Use this if you need
         /// to specify certain fields as required, and others as prohibited.
-        /// <p/>
+        /// <para/>
         /// Usage:
         /// <code>
-        /// string[] query = {&quot;query1&quot;, &quot;query2&quot;, &quot;query3&quot;};
-        /// string[] fields = {&quot;filename&quot;, &quot;contents&quot;, &quot;description&quot;};
-        /// BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
-        /// BooleanClause.Occur.MUST,
-        /// BooleanClause.Occur.MUST_NOT};
-        /// MultiFieldQueryParser.parse(query, fields, flags, analyzer);
+        ///     string[] query = {&quot;query1&quot;, &quot;query2&quot;, &quot;query3&quot;};
+        ///     string[] fields = {&quot;filename&quot;, &quot;contents&quot;, &quot;description&quot;};
+        ///     BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
+        ///         BooleanClause.Occur.MUST,
+        ///         BooleanClause.Occur.MUST_NOT};
+        ///     MultiFieldQueryParser.Parse(query, fields, flags, analyzer);
         /// </code>
-        /// <p/>
+        /// <para/>
         /// The code above would construct a query:
         /// 
         /// <code>
@@ -367,22 +354,13 @@ namespace Lucene.Net.QueryParsers.Classic
         /// 
         /// </summary>
         /// <param name="matchVersion">Lucene version to match; this is passed through to
-        /// QueryParser.
-        /// </param>
-        /// <param name="queries">Queries string to parse
-        /// </param>
-        /// <param name="fields">Fields to search on
-        /// </param>
-        /// <param name="flags">Flags describing the fields
-        /// </param>
-        /// <param name="analyzer">Analyzer to use
-        /// </param>
-        /// <throws>  ParseException </throws>
-        /// <summary>             if query parsing fails
-        /// </summary>
-        /// <throws>  IllegalArgumentException </throws>
-        /// <summary>             if the length of the queries, fields, and flags array differ
-        /// </summary>
+        /// <see cref="QueryParser"/>.</param>
+        /// <param name="queries">Queries string to parse</param>
+        /// <param name="fields">Fields to search on</param>
+        /// <param name="flags">Flags describing the fields</param>
+        /// <param name="analyzer">Analyzer to use</param>
+        /// <exception cref="ParseException">if query parsing fails</exception>
+        /// <exception cref="System.ArgumentException">if the length of the queries, fields, and flags array differ</exception>
         public static Query Parse(LuceneVersion matchVersion, string[] queries, string[] fields, BooleanClause.Occur[] flags, Analyzer analyzer)
         {
             if (!(queries.Length == fields.Length && queries.Length == flags.Length))

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Classic/ParseException.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Classic/ParseException.cs b/src/Lucene.Net.QueryParser/Classic/ParseException.cs
index efd8c3f..fa54adc 100644
--- a/src/Lucene.Net.QueryParser/Classic/ParseException.cs
+++ b/src/Lucene.Net.QueryParser/Classic/ParseException.cs
@@ -33,22 +33,19 @@ namespace Lucene.Net.QueryParsers.Classic
 	public class ParseException : Exception
 	{
         /// <summary>
-        /// This constructor is used by the method "GenerateParseException"
+        /// This constructor is used by the method GenerateParseException()
         /// in the generated parser.  Calling this constructor generates
-        /// a new object of this type with the fields "currentToken",
-        /// "expectedTokenSequences", and "tokenImage" set.
+        /// a new object of this type with the fields <paramref name="currentToken"/>,
+        /// <paramref name="expectedTokenSequences"/>, and <paramref name="tokenImage"/> set.
         /// </summary>
-        /// <param name="currentTokenVal"></param>
-        /// <param name="expectedTokenSequencesVal"></param>
-        /// <param name="tokenImageVal"></param>
-        public ParseException(Token currentTokenVal,
-                        int[][] expectedTokenSequencesVal,
-                        string[] tokenImageVal)
-            : base(Initialize(currentTokenVal, expectedTokenSequencesVal, tokenImageVal))
+        public ParseException(Token currentToken,
+                        int[][] expectedTokenSequences,
+                        string[] tokenImage)
+            : base(Initialize(currentToken, expectedTokenSequences, tokenImage))
         {
-            currentToken = currentTokenVal;
-            expectedTokenSequences = expectedTokenSequencesVal;
-            tokenImage = tokenImageVal;
+            this.currentToken = currentToken;
+            this.expectedTokenSequences = expectedTokenSequences;
+            this.tokenImage = tokenImage;
         }
 
         /**
@@ -96,16 +93,12 @@ namespace Lucene.Net.QueryParsers.Classic
 
 
         /// <summary>
-        /// It uses "currentToken" and "expectedTokenSequences" to generate a parse
+        /// It uses <paramref name="currentToken"/> and <paramref name="expectedTokenSequences"/> to generate a parse
         /// error message and returns it.  If this object has been created
         /// due to a parse error, and you do not catch it (it gets thrown
         /// from the parser) the correct error message
         /// gets displayed.
         /// </summary>
-        /// <param name="currentToken"></param>
-        /// <param name="expectedTokenSequences"></param>
-        /// <param name="tokenImage"></param>
-        /// <returns></returns>
         private static string Initialize(Token currentToken,
             int[][] expectedTokenSequences,
             string[] tokenImage)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Classic/QueryParser.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Classic/QueryParser.cs b/src/Lucene.Net.QueryParser/Classic/QueryParser.cs
index 9781516..39e1f8f 100644
--- a/src/Lucene.Net.QueryParser/Classic/QueryParser.cs
+++ b/src/Lucene.Net.QueryParser/Classic/QueryParser.cs
@@ -25,8 +25,8 @@ namespace Lucene.Net.QueryParsers.Classic
      */
 
     /// <summary> This class is generated by JavaCC.  The most important method is
-    /// <see cref="Parse(string)" />.
-    /// 
+    /// <see cref="QueryParserBase.Parse(string)" />.
+    /// <para/>
     /// The syntax for query strings is as follows:
     /// A Query is a series of clauses.
     /// A clause may be prefixed by:
@@ -37,6 +37,7 @@ namespace Lucene.Net.QueryParsers.Classic
     /// This enables one to construct queries which search multiple fields.</item>
     /// </list>
     /// 
+    /// <para/>
     /// A clause may be either:
     /// <list type="bullet">
     /// <item> a term, indicating all the documents that contain this term; or</item>
@@ -45,50 +46,53 @@ namespace Lucene.Net.QueryParsers.Classic
     /// terms.</item>
     /// </list>
     /// 
+    /// <para/>
     /// Thus, in BNF, the query grammar is:
     /// <code>
-    /// Query  ::= ( Clause )*
-    /// Clause ::= ["+", "-"] [&lt;TERM&gt; ":"] ( &lt;TERM&gt; | "(" Query ")" )
+    ///     Query  ::= ( Clause )*
+    ///     Clause ::= ["+", "-"] [&lt;TERM&gt; ":"] ( &lt;TERM&gt; | "(" Query ")" )
     /// </code>
     /// 
-    /// <p/>
+    /// <para>
     /// Examples of appropriately formatted queries can be found in the <a
     /// href="../../../../../../queryparsersyntax.html">query syntax
     /// documentation</a>.
-    /// <p/>
+    /// </para>
     /// 
-    /// <p/>
+    /// <para>
     /// In <see cref="TermRangeQuery" />s, QueryParser tries to detect date values, e.g.
     /// <tt>date:[6/1/2005 TO 6/4/2005]</tt> produces a range query that searches
     /// for "date" fields between 2005-06-01 and 2005-06-04. Note that the format
     /// of the accepted input depends on the <see cref="Locale" />.
-    /// A <see cref="Lucene.Net.Documents.DateTools.Resolution" /> has to be set,
-    /// if you want to use <see cref="DateTools"/> for date conversion.<p/>
-    /// <p/>
+    /// A <see cref="Documents.DateTools.Resolution" /> has to be set,
+    /// if you want to use <see cref="Documents.DateTools"/> for date conversion.<p/>
+    /// </para>
+    /// <para>
     /// The date resolution that shall be used for RangeQueries can be set
-    /// using <see cref="SetDateResolution(DateTools.Resolution)" />
-    /// or <see cref="SetDateResolution(string, DateTools.Resolution)" />. The former
+    /// using <see cref="QueryParserBase.SetDateResolution(Documents.DateTools.Resolution)" />
+    /// or <see cref="QueryParserBase.SetDateResolution(string, Documents.DateTools.Resolution)" />. The former
     /// sets the default date resolution for all fields, whereas the latter can
     /// be used to set field specific date resolutions. Field specific date
     /// resolutions take, if set, precedence over the default date resolution.
-    /// <p/>
-    /// <p/>
-    /// If you don't use <see cref="DateTools" /> in your index, you can create your own
-    /// query parser that inherits QueryParser and overwrites
-    /// <see cref="GetRangeQuery(string, string, string, bool)" /> to
+    /// </para>
+    /// <para>
+    /// If you don't use <see cref="Documents.DateTools" /> in your index, you can create your own
+    /// query parser that inherits <see cref="QueryParser"/> and overwrites
+    /// <see cref="QueryParserBase.GetRangeQuery(string, string, string, bool, bool)" /> to
     /// use a different method for date conversion.
-    /// <p/>
+    /// </para>
     /// 
-    /// <p/>Note that QueryParser is <em>not</em> thread-safe.<p/> 
+    /// <para>Note that <see cref="QueryParser"/> is <em>not</em> thread-safe.</para>
     /// 
-    /// <p/><b>NOTE</b>: there is a new QueryParser in contrib, which matches
+    /// <para><b>NOTE</b>: there is a new QueryParser in contrib, which matches
     /// the same syntax as this class, but is more modular,
     /// enabling substantial customization to how a query is created.
+    /// </para>
     /// 
     /// <b>NOTE</b>: You must specify the required <see cref="LuceneVersion" /> compatibility when
     /// creating QueryParser:
     /// <list type="bullet">
-    /// <item>As of 3.1, <see cref="AutoGeneratePhraseQueries"/> is false by default.</item>
+    /// <item>As of 3.1, <see cref="QueryParserBase.AutoGeneratePhraseQueries"/> is false by default.</item>
     /// </list>
     /// </summary>
     public class QueryParser : QueryParserBase
@@ -577,11 +581,11 @@ namespace Lucene.Net.QueryParsers.Classic
             return false;
         }
 
-        /* Generated Token Manager. */
+        /// <summary>Generated Token Manager.</summary>
         public QueryParserTokenManager token_source;
-        /* Current token. */
+        /// <summary>Current token.</summary>
         public Token token;
-        /* Next token. */
+        /// <summary>Next token.</summary>
         public Token jj_nt;
         private int jj_ntk;
         private Token jj_scanpos, jj_lastpos;
@@ -622,7 +626,7 @@ namespace Lucene.Net.QueryParsers.Classic
         private bool jj_rescan = false;
         private int jj_gc = 0;
 
-        /// <summary>Constructor with user supplied CharStream. </summary>
+        /// <summary>Constructor with user supplied <see cref="ICharStream"/>. </summary>
         protected internal QueryParser(ICharStream stream)
         {
             token_source = new QueryParserTokenManager(stream);
@@ -633,7 +637,7 @@ namespace Lucene.Net.QueryParsers.Classic
             for (int i = 0; i < jj_2_rtns.Length; i++) jj_2_rtns[i] = new JJCalls();
         }
 
-        /// <summary>Reinitialise. </summary>
+        /// <summary>Reinitialize. </summary>
         public override void ReInit(ICharStream stream)
         {
             token_source.ReInit(stream);
@@ -655,7 +659,7 @@ namespace Lucene.Net.QueryParsers.Classic
             for (int i = 0; i < jj_2_rtns.Length; i++) jj_2_rtns[i] = new JJCalls();
         }
 
-        /// <summary>Reinitialise. </summary>
+        /// <summary>Reinitialize. </summary>
         public virtual void ReInit(QueryParserTokenManager tm)
         {
             token_source = tm;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Classic/QueryParserBase.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Classic/QueryParserBase.cs b/src/Lucene.Net.QueryParser/Classic/QueryParserBase.cs
index ca10e89..b0b7b07 100644
--- a/src/Lucene.Net.QueryParser/Classic/QueryParserBase.cs
+++ b/src/Lucene.Net.QueryParser/Classic/QueryParserBase.cs
@@ -31,6 +31,9 @@ namespace Lucene.Net.QueryParsers.Classic
      * limitations under the License.
      */
 
+    /// <summary>
+    /// This class is overridden by <see cref="QueryParser"/>.
+    /// </summary>
     public abstract class QueryParserBase : QueryBuilder, ICommonQueryParserConfiguration
     {
         /// <summary>
@@ -51,11 +54,11 @@ namespace Lucene.Net.QueryParsers.Classic
         // the nested class:
         
         /// <summary>
-        /// Alternative form of QueryParser.Operator.AND
+        /// Alternative form of <see cref="QueryParserBase.Operator.AND"/> 
         /// </summary>
         public const Operator AND_OPERATOR = Operator.AND;
         /// <summary>
-        /// Alternative form of QueryParser.Operator.OR
+        /// Alternative form of <see cref="QueryParserBase.Operator.OR"/> 
         /// </summary>
         public const Operator OR_OPERATOR = Operator.OR;
 
@@ -71,7 +74,7 @@ namespace Lucene.Net.QueryParsers.Classic
 
         /// <summary>
         /// The default operator for parsing queries. 
-        /// Use <see cref="QueryParserBase.SetDefaultOperator"/> to change it.
+        /// Use <see cref="QueryParserBase.DefaultOperator"/> to change it.
         /// </summary>
         public enum Operator
         {
@@ -160,13 +163,10 @@ namespace Lucene.Net.QueryParsers.Classic
         public abstract Query TopLevelQuery(string field);
 
         /// <summary>
-        /// Parses a query string, returning a <see cref="T:Query"/>.
+        /// Parses a query string, returning a <see cref="Query"/>.
         /// </summary>
-        /// <remarks>
-        /// throws ParseException if the parsing fails
-        /// </remarks>
         /// <param name="query">the query string to be parsed.</param>
-        /// <returns></returns>
+        /// <exception cref="ParseException">if the parsing fails</exception>
         public virtual Query Parse(string query)
         {
             ReInit(new FastCharStream(new StringReader(query)));
@@ -230,30 +230,31 @@ namespace Lucene.Net.QueryParsers.Classic
         public virtual int PhraseSlop { get; set; }
 
         /// <summary>
-        /// Set to <code>true</code> to allow leading wildcard characters.
-        /// <p>
-        /// When set, <code>*</code> or <code>?</code> are allowed as
+        /// Set to <c>true</c> to allow leading wildcard characters.
+        /// <para/>
+        /// When set, <c>*</c> or <c>?</c> are allowed as
         /// the first character of a PrefixQuery and WildcardQuery.
         /// Note that this can produce very slow
         /// queries on big indexes.
-        /// <p>
+        /// <para/>
         /// Default: false.
         /// </summary>
         public virtual bool AllowLeadingWildcard { get; set; }
 
         /// <summary>
         /// Gets or Sets the boolean operator of the QueryParser.
-        /// In default mode (<code>OR_OPERATOR</code>) terms without any modifiers
-        /// are considered optional: for example <code>capital of Hungary</code> is equal to
-        /// <code>capital OR of OR Hungary</code>.<br/>
-        /// In <code>AND_OPERATOR</code> mode terms are considered to be in conjunction: the
-        /// above mentioned query is parsed as <code>capital AND of AND Hungary
+        /// In default mode (<see cref="OR_OPERATOR"/>) terms without any modifiers
+        /// are considered optional: for example <c>capital of Hungary</c> is equal to
+        /// <c>capital OR of OR Hungary</c>.
+        /// <para/>
+        /// In <see cref="AND_OPERATOR"/> mode terms are considered to be in conjunction: the
+        /// above mentioned query is parsed as <c>capital AND of AND Hungary</c>
         /// </summary>
         public virtual Operator DefaultOperator { get; set; }
 
         /// <summary>
         /// Whether terms of wildcard, prefix, fuzzy and range queries are to be automatically
-        //  lower-cased or not.  Default is <code>true</code>.
+        //  lower-cased or not.  Default is <c>true</c>.
         /// </summary>
         public virtual bool LowercaseExpandedTerms { get; set; }
 
@@ -261,7 +262,7 @@ namespace Lucene.Net.QueryParsers.Classic
         /// By default QueryParser uses <see cref="MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT"/>
         /// when creating a <see cref="PrefixQuery"/>, <see cref="WildcardQuery"/> or <see cref="TermRangeQuery"/>. This implementation is generally preferable because it
         /// a) Runs faster b) Does not have the scarcity of terms unduly influence score
-        /// c) avoids any <see cref="TooManyClauses"/> exception.
+        /// c) avoids any <see cref="BooleanQuery.TooManyClauses"/> exception.
         /// However, if your application really needs to use the
         /// old-fashioned <see cref="BooleanQuery"/> expansion rewriting and the above
         /// points are not relevant then use this to change
@@ -313,8 +314,6 @@ namespace Lucene.Net.QueryParsers.Classic
         /// Returns null, if no default or field specific date resolution has been set 
         /// for the given field.
         /// </summary>
-        /// <param name="fieldName"></param>
-        /// <returns></returns>
         public virtual DateTools.Resolution GetDateResolution(string fieldName)
         {
             if (string.IsNullOrEmpty(fieldName))
@@ -417,13 +416,9 @@ namespace Lucene.Net.QueryParsers.Classic
         /// <summary>
         /// Base implementation delegates to <see cref="GetFieldQuery(string,string,bool)"/>.
         /// This method may be overridden, for example, to return
-        /// a SpanNearQuery instead of a PhraseQuery.
+        /// a <see cref="Search.Spans.SpanNearQuery"/> instead of a <see cref="PhraseQuery"/>.
         /// </summary>
-        /// <param name="field"></param>
-        /// <param name="queryText"></param>
-        /// <param name="slop"></param>
         /// <exception cref="ParseException">throw in overridden method to disallow</exception>
-        /// <returns></returns>
         protected internal virtual Query GetFieldQuery(string field, string queryText, int slop)
         {
             Query query = GetFieldQuery(field, queryText, true);
@@ -502,20 +497,20 @@ namespace Lucene.Net.QueryParsers.Classic
             return NewRangeQuery(field, part1, part2, startInclusive, endInclusive);
         }
 
-        /// <summary>Builds a new BooleanClause instance</summary>
+        /// <summary>Builds a new <see cref="BooleanClause"/> instance</summary>
         /// <param name="q">sub query</param>
         /// <param name="occur">how this clause should occur when matching documents</param>
-        /// <returns> new BooleanClause instance</returns>
+        /// <returns> new <see cref="BooleanClause"/> instance</returns>
         protected internal virtual BooleanClause NewBooleanClause(Query q, BooleanClause.Occur occur)
         {
             return new BooleanClause(q, occur);
         }
 
         /// <summary>
-        /// Builds a new PrefixQuery instance
+        /// Builds a new <see cref="PrefixQuery"/> instance
         /// </summary>
         /// <param name="prefix">Prefix term</param>
-        /// <returns>new PrefixQuery instance</returns>
+        /// <returns>new <see cref="PrefixQuery"/> instance</returns>
         protected internal virtual Query NewPrefixQuery(Term prefix)
         {
             PrefixQuery query = new PrefixQuery(prefix);
@@ -524,10 +519,10 @@ namespace Lucene.Net.QueryParsers.Classic
         }
 
         /// <summary>
-        /// Builds a new RegexpQuery instance
+        /// Builds a new <see cref="RegexpQuery"/> instance
         /// </summary>
         /// <param name="regexp">Regexp term</param>
-        /// <returns>new RegexpQuery instance</returns>
+        /// <returns>new <see cref="RegexpQuery"/> instance</returns>
         protected internal virtual Query NewRegexpQuery(Term regexp)
         {
             RegexpQuery query = new RegexpQuery(regexp);
@@ -536,12 +531,12 @@ namespace Lucene.Net.QueryParsers.Classic
         }
 
         /// <summary>
-        /// Builds a new FuzzyQuery instance
+        /// Builds a new <see cref="FuzzyQuery"/> instance
         /// </summary>
         /// <param name="term">Term</param>
         /// <param name="minimumSimilarity">minimum similarity</param>
         /// <param name="prefixLength">prefix length</param>
-        /// <returns>new FuzzyQuery Instance</returns>
+        /// <returns>new <see cref="FuzzyQuery"/> Instance</returns>
         protected internal virtual Query NewFuzzyQuery(Term term, float minimumSimilarity, int prefixLength)
         {
             // FuzzyQuery doesn't yet allow constant score rewrite
@@ -591,14 +586,14 @@ namespace Lucene.Net.QueryParsers.Classic
         }
 
         /// <summary>
-        /// Builds a new {@link TermRangeQuery} instance
+        /// Builds a new <see cref="TermRangeQuery"/> instance
         /// </summary>
         /// <param name="field">Field</param>
         /// <param name="part1">min</param>
         /// <param name="part2">max</param>
         /// <param name="startInclusive">true if the start of the range is inclusive</param>
         /// <param name="endInclusive">true if the end of the range is inclusive</param>
-        /// <returns>new <see cref="T:TermRangeQuery"/> instance</returns>
+        /// <returns>new <see cref="TermRangeQuery"/> instance</returns>
         protected internal virtual Query NewRangeQuery(string field, string part1, string part2, bool startInclusive, bool endInclusive)
         {
             BytesRef start;
@@ -629,19 +624,19 @@ namespace Lucene.Net.QueryParsers.Classic
         }
 
         /// <summary>
-        /// Builds a new MatchAllDocsQuery instance
+        /// Builds a new <see cref="MatchAllDocsQuery"/> instance
         /// </summary>
-        /// <returns>new MatchAllDocsQuery instance</returns>
+        /// <returns>new <see cref="MatchAllDocsQuery"/> instance</returns>
         protected internal virtual Query NewMatchAllDocsQuery()
         {
             return new MatchAllDocsQuery();
         }
 
         /// <summary>
-        /// Builds a new WildcardQuery instance
+        /// Builds a new <see cref="WildcardQuery"/> instance
         /// </summary>
         /// <param name="t">wildcard term</param>
-        /// <returns>new WildcardQuery instance</returns>
+        /// <returns>new <see cref="WildcardQuery"/> instance</returns>
         protected internal virtual Query NewWildcardQuery(Term t)
         {
             WildcardQuery query = new WildcardQuery(t);
@@ -652,14 +647,14 @@ namespace Lucene.Net.QueryParsers.Classic
         /// <summary>
         /// Factory method for generating query, given a set of clauses.
         /// By default creates a boolean query composed of clauses passed in.
-        ///
+        /// <para/>
         /// Can be overridden by extending classes, to modify query being
         /// returned.
         /// </summary>
-        /// <param name="clauses">List that contains {@link org.apache.lucene.search.BooleanClause} instances 
+        /// <param name="clauses">List that contains <see cref="BooleanClause"/> instances 
         /// to join.</param>
-        /// <exception cref="T:ParseException">throw in overridden method to disallow</exception>
-        /// <returns>Resulting <see cref="T:Query"/> object.</returns>
+        /// <exception cref="ParseException">throw in overridden method to disallow</exception>
+        /// <returns>Resulting <see cref="Query"/> object.</returns>
         protected internal virtual Query GetBooleanQuery(IList<BooleanClause> clauses)
         {
             return GetBooleanQuery(clauses, false);
@@ -668,15 +663,15 @@ namespace Lucene.Net.QueryParsers.Classic
         /// <summary>
         /// Factory method for generating query, given a set of clauses.
         /// By default creates a boolean query composed of clauses passed in.
-        /// 
+        /// <para/>
         /// Can be overridden by extending classes, to modify query being
         /// returned.
         /// </summary>
-        /// <param name="clauses">List that contains <see cref="T:BooleanClause"/> instances
+        /// <param name="clauses">List that contains <see cref="BooleanClause"/> instances
         /// to join.</param>
         /// <param name="disableCoord">true if coord scoring should be disabled.</param>
         /// <exception cref="ParseException">throw in overridden method to disallow</exception>
-        /// <returns>Resulting <see cref="T:Query"/> object.</returns>
+        /// <returns>Resulting <see cref="Query"/> object.</returns>
         protected internal virtual Query GetBooleanQuery(IList<BooleanClause> clauses, bool disableCoord)
         {
             if (clauses.Count == 0)
@@ -696,12 +691,12 @@ namespace Lucene.Net.QueryParsers.Classic
         /// parses an input term token that contains one or more wildcard
         /// characters (? and *), but is not a prefix term token (one
         /// that has just a single * character at the end)
-        /// <p>
+        /// <para/>
         /// Depending on settings, prefix term may be lower-cased
         /// automatically. It will not go through the default Analyzer,
         /// however, since normal Analyzers are unlikely to work properly
         /// with wildcard templates.
-        /// <p>
+        /// <para/>
         /// Can be overridden by extending classes, to provide custom handling for
         /// wildcard queries, which may be necessary due to missing analyzer calls.
         /// </summary>
@@ -709,7 +704,7 @@ namespace Lucene.Net.QueryParsers.Classic
         /// <param name="termStr">Term token that contains one or more wild card
         /// characters (? or *), but is not simple prefix term</param>
         /// <exception cref="ParseException">throw in overridden method to disallow</exception>
-        /// <returns>Resulting <see cref="T:Query"/> built for the term</returns>
+        /// <returns>Resulting <see cref="Query"/> built for the term</returns>
         protected internal virtual Query GetWildcardQuery(string field, string termStr)
         {
             if ("*".Equals(field))
@@ -730,12 +725,12 @@ namespace Lucene.Net.QueryParsers.Classic
         /// Factory method for generating a query. Called when parser
         /// parses an input term token that contains a regular expression
         /// query.
-        /// <p>
+        /// <para/>
         /// Depending on settings, pattern term may be lower-cased
         /// automatically. It will not go through the default Analyzer,
         /// however, since normal Analyzers are unlikely to work properly
         /// with regular expression templates.
-        /// <p>
+        /// <para/>
         /// Can be overridden by extending classes, to provide custom handling for
         /// regular expression queries, which may be necessary due to missing analyzer
         /// calls.
@@ -743,7 +738,7 @@ namespace Lucene.Net.QueryParsers.Classic
         /// <param name="field">Name of the field query will use.</param>
         /// <param name="termStr">Term token that contains a regular expression</param>
         /// <exception cref="ParseException">throw in overridden method to disallow</exception>
-        /// <returns>Resulting <see cref="T:Query"/> built for the term</returns>
+        /// <returns>Resulting <see cref="Query"/> built for the term</returns>
         protected internal virtual Query GetRegexpQuery(string field, string termStr)
         {
             if (LowercaseExpandedTerms)
@@ -756,24 +751,24 @@ namespace Lucene.Net.QueryParsers.Classic
 
         /// <summary>
         /// Factory method for generating a query (similar to
-        /// <see cref="M:GetWildcardQuery"/>). Called when parser parses an input term
+        /// <see cref="GetWildcardQuery(string, string)"/>). Called when parser parses an input term
         /// token that uses prefix notation; that is, contains a single '*' wildcard
         /// character as its last character. Since this is a special case
         /// of generic wildcard term, and such a query can be optimized easily,
         /// this usually results in a different query object.
-        /// <p>
+        /// <para/>
         /// Depending on settings, a prefix term may be lower-cased
         /// automatically. It will not go through the default Analyzer,
         /// however, since normal Analyzers are unlikely to work properly
         /// with wildcard templates.
-        /// <p>
+        /// <para/>
         /// Can be overridden by extending classes, to provide custom handling for
         /// wild card queries, which may be necessary due to missing analyzer calls.
         /// </summary>
         /// <param name="field">Name of the field query will use.</param>
         /// <param name="termStr">Term token to use for building term for the query</param>
         /// <exception cref="ParseException">throw in overridden method to disallow</exception>
-        /// <returns>Resulting <see cref="T:Query"/> built for the term</returns>
+        /// <returns>Resulting <see cref="Query"/> built for the term</returns>
         protected internal virtual Query GetPrefixQuery(string field, string termStr)
         {
             if (!AllowLeadingWildcard && termStr.StartsWith("*"))
@@ -788,14 +783,14 @@ namespace Lucene.Net.QueryParsers.Classic
 
         /// <summary>
         /// Factory method for generating a query (similar to
-        /// <see cref="M:GetWildcardQuery"/>). Called when parser parses
+        /// <see cref="GetWildcardQuery(string, string)"/>). Called when parser parses
         /// an input term token that has the fuzzy suffix (~) appended.
         /// </summary>
         /// <param name="field">Name of the field query will use.</param>
         /// <param name="termStr">Term token to use for building term for the query</param>
         /// <param name="minSimilarity">minimum similarity</param>
         /// <exception cref="ParseException">throw in overridden method to disallow</exception>
-        /// <returns>Resulting <see cref="T:Query"/> built for the term</returns>
+        /// <returns>Resulting <see cref="Query"/> built for the term</returns>
         protected internal virtual Query GetFuzzyQuery(string field, string termStr, float minSimilarity)
         {
             if (LowercaseExpandedTerms)
@@ -900,12 +895,10 @@ namespace Lucene.Net.QueryParsers.Classic
         /// <summary>
         /// Returns a string where the escape char has been
         /// removed, or kept only once if there was a double escape.
-        /// 
+        /// <para/>
         /// Supports escaped unicode characters, e. g. translates 
-        /// <code>\\u0041</code> to <code>A</code>.
+        /// <c>\\u0041</c> to <c>A</c>.
         /// </summary>
-        /// <param name="input"></param>
-        /// <returns></returns>
         internal virtual string DiscardEscapeChar(string input)
         {
             // Create char array to hold unescaped char sequence

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Classic/QueryParserTokenManager.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Classic/QueryParserTokenManager.cs b/src/Lucene.Net.QueryParser/Classic/QueryParserTokenManager.cs
index a2f6010..840a39b 100644
--- a/src/Lucene.Net.QueryParser/Classic/QueryParserTokenManager.cs
+++ b/src/Lucene.Net.QueryParser/Classic/QueryParserTokenManager.cs
@@ -33,9 +33,9 @@ namespace Lucene.Net.QueryParsers.Classic
 		}
 		
 		/// <summary>Debug output. </summary>
-		public StreamWriter debugStream;
+		public TextWriter debugStream;
 		/// <summary>Set debug output. </summary>
-		public virtual void  SetDebugStream(StreamWriter ds)
+		public virtual void SetDebugStream(TextWriter ds)
 		{
 			debugStream = ds;
 		}

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/ComplexPhrase/ComplexPhraseQueryParser.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/ComplexPhrase/ComplexPhraseQueryParser.cs b/src/Lucene.Net.QueryParser/ComplexPhrase/ComplexPhraseQueryParser.cs
index 037dcd3..f727716 100644
--- a/src/Lucene.Net.QueryParser/ComplexPhrase/ComplexPhraseQueryParser.cs
+++ b/src/Lucene.Net.QueryParser/ComplexPhrase/ComplexPhraseQueryParser.cs
@@ -28,9 +28,9 @@ namespace Lucene.Net.QueryParsers.ComplexPhrase
      */
 
     /// <summary>
-    /// QueryParser which permits complex phrase query syntax eg "(john jon
+    /// <see cref="QueryParser"/> which permits complex phrase query syntax eg "(john jon
     /// jonathan~) peters*".
-    /// <p>
+    /// <para>
     /// Performs potentially multiple passes over Query text to parse any nested
     /// logic in PhraseQueries. - First pass takes any PhraseQuery content between
     /// quotes and stores for subsequent pass. All other query content is parsed as
@@ -38,14 +38,14 @@ namespace Lucene.Net.QueryParsers.ComplexPhrase
     /// embedded clauses are referring to the same field and therefore can be
     /// rewritten as Span queries. All PhraseQuery clauses are expressed as
     /// ComplexPhraseQuery objects
-    /// </p>
-    /// <p>
-    /// This could arguably be done in one pass using a new QueryParser but here I am
+    /// </para>
+    /// <para>
+    /// This could arguably be done in one pass using a new <see cref="QueryParser"/> but here I am
     /// working within the constraints of the existing parser as a base class. This
     /// currently simply feeds all phrase content through an analyzer to select
     /// phrase terms - any "special" syntax such as * ~ * etc are not given special
     /// status
-    /// </p>
+    /// </para>
     /// </summary>
     public class ComplexPhraseQueryParser : Classic.QueryParser
     {
@@ -54,7 +54,7 @@ namespace Lucene.Net.QueryParsers.ComplexPhrase
         private bool isPass2ResolvingPhrases;
 
         /// <summary>
-        /// When <code>inOrder</code> is true, the search terms must
+        /// When <see cref="InOrder"/> is true, the search terms must
         /// exists in the documents as the same order as in query.
         /// Choose between ordered (true) or un-ordered (false) proximity search.
         /// </summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Ext/ExtendableQueryParser.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Ext/ExtendableQueryParser.cs b/src/Lucene.Net.QueryParser/Ext/ExtendableQueryParser.cs
index ef37215..f7d0729 100644
--- a/src/Lucene.Net.QueryParser/Ext/ExtendableQueryParser.cs
+++ b/src/Lucene.Net.QueryParser/Ext/ExtendableQueryParser.cs
@@ -34,12 +34,12 @@ namespace Lucene.Net.QueryParsers.Ext
     /// extension key from the field symbol and tries to resolve the associated
     /// <see cref="ParserExtension"/>. If the parser can't resolve the key or the field
     /// token does not contain a separation character, <see cref="ExtendableQueryParser"/>
-    /// yields the same behavior as its super class <see cref="QueryParser"/>. Otherwise,
+    /// yields the same behavior as its super class <see cref="Classic.QueryParser"/>. Otherwise,
     /// if the key is associated with a <see cref="ParserExtension"/> instance, the parser
     /// builds an instance of <see cref="ExtensionQuery"/> to be processed by
     /// <see cref="ParserExtension.Parse(ExtensionQuery)"/>.If a extension field does not
     /// contain a field part the default field for the query will be used.
-    /// <p>
+    /// <para>
     /// To guarantee that an extension field is processed with its associated
     /// extension, the extension query part must escape any special characters like
     /// '*' or '['. If the extension query contains any whitespace characters, the
@@ -53,22 +53,21 @@ namespace Lucene.Net.QueryParsers.Ext
     /// <pre>
     ///   _customExt:"Apache Lucene\?" OR _customExt:prefix\*
     /// </pre>
-    /// </p>
-    /// <p>
+    /// </para>
+    /// <para>
     /// The <see cref="ExtendableQueryParser"/> itself does not implement the logic how
     /// field and extension key are separated or ordered. All logic regarding the
     /// extension key and field symbol parsing is located in <see cref="Extensions"/>.
     /// Customized extension schemes should be implemented by sub-classing
     /// <see cref="Extensions"/>.
-    /// </p>
-    /// <p>
+    /// </para>
+    /// <para>
     /// For details about the default encoding scheme see <see cref="Extensions"/>.
-    /// </p>
-    /// 
-    /// <see cref="Extensions"/>
-    /// <see cref="ParserExtension"/>
-    /// <see cref="ExtensionQuery"/>
+    /// </para>
     /// </summary>
+    /// <seealso cref="Extensions"/>
+    /// <seealso cref="ParserExtension"/>
+    /// <seealso cref="ExtensionQuery"/>
     public class ExtendableQueryParser : Classic.QueryParser
     {
         private readonly string defaultField;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Ext/Extensions.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Ext/Extensions.cs b/src/Lucene.Net.QueryParser/Ext/Extensions.cs
index e64c809..b231166 100644
--- a/src/Lucene.Net.QueryParser/Ext/Extensions.cs
+++ b/src/Lucene.Net.QueryParser/Ext/Extensions.cs
@@ -22,6 +22,23 @@ namespace Lucene.Net.QueryParsers.Ext
      * limitations under the License.
      */
 
+    /// <summary>
+    /// The <see cref="Extensions"/> class represents an extension mapping to associate
+    /// <see cref="ParserExtension"/> instances with extension keys. An extension key is a
+    /// string encoded into a Lucene standard query parser field symbol recognized by
+    /// <see cref="ExtendableQueryParser"/>. The query parser passes each extension field
+    /// token to <see cref="SplitExtensionField(string, string)"/> to separate the
+    /// extension key from the field identifier.
+    /// <para/>
+    /// In addition to the key to extension mapping this class also defines the field
+    /// name overloading scheme. <see cref="ExtendableQueryParser"/> uses the given
+    /// extension to split the actual field name and extension key by calling
+    /// <see cref="SplitExtensionField(string, string)"/>. To change the order or the key
+    /// / field name encoding scheme users can subclass <see cref="Extensions"/> to
+    /// implement their own.
+    /// </summary>
+    /// <seealso cref="ExtendableQueryParser"/>
+    /// <seealso cref="ParserExtension"/>
     public class Extensions
     {
         private readonly IDictionary<string, ParserExtension> extensions = new Dictionary<string, ParserExtension>();
@@ -34,7 +51,7 @@ namespace Lucene.Net.QueryParsers.Ext
 
         /// <summary>
         /// Creates a new <see cref="Extensions"/> instance with the
-        /// <see cref="#DEFAULT_EXTENSION_FIELD_DELIMITER"/> as a delimiter character.
+        /// <see cref="DEFAULT_EXTENSION_FIELD_DELIMITER"/> as a delimiter character.
         /// </summary>
         public Extensions()
             : this(DEFAULT_EXTENSION_FIELD_DELIMITER)
@@ -106,7 +123,7 @@ namespace Lucene.Net.QueryParsers.Ext
 
         /// <summary>
         /// Escapes an extension field. The default implementation is equivalent to
-        /// <see cref="QueryParser.Escape(string)"/>.
+        /// <see cref="QueryParserBase.Escape(string)"/>.
         /// </summary>
         /// <param name="extfield">the extension field identifier</param>
         /// <returns>the extension field identifier with all special chars escaped with
@@ -123,12 +140,12 @@ namespace Lucene.Net.QueryParsers.Ext
         /// of the extension key and the field. By default the extension key is
         /// appended to the end of the returned string while the field is added to the
         /// beginning. Special Query characters are escaped in the result.
-        /// <p>
+        /// <para>
         /// Note: <see cref="Extensions"/> subclasses must maintain the contract between
-        /// <see cref="M:BuildExtensionField(string)"/> and
-        /// <see cref="M:BuildExtensionField(string, string)"/> where the latter inverts the
+        /// <see cref="BuildExtensionField(string)"/> and
+        /// <see cref="BuildExtensionField(string, string)"/> where the latter inverts the
         /// former.
-        /// </p>
+        /// </para>
         /// </summary>
         /// <param name="extensionKey">the extension key</param>
         /// <returns>escaped extension field identifier</returns>
@@ -144,16 +161,17 @@ namespace Lucene.Net.QueryParsers.Ext
         /// of the extension key and the field. By default the extension key is
         /// appended to the end of the returned string while the field is added to the
         /// beginning. Special Query characters are escaped in the result.
-        /// <p>
+        /// <para>
         /// Note: <see cref="Extensions"/> subclasses must maintain the contract between
-        /// <see cref="M:BuildExtensionField(string)"/> and
-        /// <see cref="M:BuildExtensionField(string, string)"/> where the latter inverts the
+        /// <see cref="BuildExtensionField(string)"/> and
+        /// <see cref="BuildExtensionField(string, string)"/> where the latter inverts the
         /// former.
+        /// </para>
         /// </summary>
         /// <param name="extensionKey">the extension key</param>
         /// <param name="field">the field to apply the extension on.</param>
         /// <returns>escaped extension field identifier</returns>
-        /// <remarks>See <see cref="M:BuildExtensionField(string)"/> to use the default query field</remarks>
+        /// <remarks>See <see cref="BuildExtensionField(string)"/> to use the default query field</remarks>
         public virtual string BuildExtensionField(string extensionKey, string field)
         {
             StringBuilder builder = new StringBuilder(field);
@@ -162,6 +180,6 @@ namespace Lucene.Net.QueryParsers.Ext
             return EscapeExtensionField(builder.ToString());
         }
 
-        // NOTE: Pair<T, T> was eliminated in favor of the built in Tuple<T, T> type.
+        // LUCENENET NOTE: Pair<T, T> was eliminated in favor of the built in Tuple<T, T> type.
     }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Ext/ParserExtension.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Ext/ParserExtension.cs b/src/Lucene.Net.QueryParser/Ext/ParserExtension.cs
index b617059..2e6650d 100644
--- a/src/Lucene.Net.QueryParser/Ext/ParserExtension.cs
+++ b/src/Lucene.Net.QueryParser/Ext/ParserExtension.cs
@@ -30,17 +30,16 @@ namespace Lucene.Net.QueryParsers.Ext
     /// the parser the <see cref="ParserExtension"/> can be customized and plugged into an
     /// instance of <see cref="ExtendableQueryParser"/>, a direct subclass of
     /// <see cref="Classic.QueryParser"/>.
-    ///  
-    /// <see cref="Extensions"/>
-    /// <see cref="ExtendableQueryParser"/>
     /// </summary>
+    /// <seealso cref="Extensions"/>
+    /// <seealso cref="ExtendableQueryParser"/>
     public abstract class ParserExtension
     {
         /// <summary>
         /// Processes the given <see cref="ExtensionQuery"/> and returns a corresponding
         /// <see cref="Query"/> instance. Subclasses must either return a <see cref="Query"/>
         /// instance or raise a <see cref="ParseException"/>. This method must not return
-        /// <code>null</code>.
+        /// <c>null</c>.
         /// </summary>
         /// <param name="query">the extension query</param>
         /// <returns>a new query instance</returns>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/CharStream.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/CharStream.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/CharStream.cs
index f4c15d6..fb03a4b 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/CharStream.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/CharStream.cs
@@ -92,7 +92,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
         /// <summary>
         /// Returns the next character that marks the beginning of the next token.
         /// All characters must remain in the buffer between two successive calls
-        /// to this method to implement backup correctly.
+        /// to this method to implement <see cref="BackUp(int)"/> correctly.
         /// </summary>
         char BeginToken();
 
@@ -112,7 +112,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
         /// <code>
         /// {
         ///     string t = GetImage();
-        ///     return t.Substring(t.Length - len, t.Length - (t.Length - len)).ToCharArray();
+        ///     return t.Substring(t.Length - len, len).ToCharArray();
         /// }
         /// </code>
         /// </summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/FastCharStream.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/FastCharStream.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/FastCharStream.cs
index 6f6d27d..89d0f1c 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/FastCharStream.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/FastCharStream.cs
@@ -20,7 +20,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
      */
 
     /// <summary>
-    /// An efficient implementation of JavaCC's CharStream interface.  <p>Note that
+    /// An efficient implementation of JavaCC's <see cref="ICharStream"/> interface.  
+    /// <para/>
+    /// Note that
     /// this does not do line-number counting, but instead keeps track of the
     /// character position of the token in the input, as required by Lucene's
     /// <see cref="Token"/> API. 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/ParseException.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/ParseException.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/ParseException.cs
index f1b4ea9..f2274d2 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/ParseException.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/ParseException.cs
@@ -206,7 +206,6 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
                     default:
                         if ((ch = str[i]) < 0x20 || ch > 0x7e)
                         {
-                            //string s = "0000" + Integer.toString(ch, 16);
                             string s = "0000" + Convert.ToString(ch, 16);
                             retval.Append("\\u" + s.Substring(s.Length - 4, s.Length - (s.Length - 4)));
                         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs b/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs
index 3c8c694..8dea702 100644
--- a/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs
+++ b/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs
@@ -29,70 +29,70 @@ namespace Lucene.Net.QueryParsers.Simple
      */
 
     /// <summary>
-    /// SimpleQueryParser is used to parse human readable query syntax.
-    /// <p>
+    /// <see cref="SimpleQueryParser"/> is used to parse human readable query syntax.
+    /// <para/>
     /// The main idea behind this parser is that a person should be able to type
     /// whatever they want to represent a query, and this parser will do its best
     /// to interpret what to search for no matter how poorly composed the request
     /// may be. Tokens are considered to be any of a term, phrase, or subquery for the
     /// operations described below.  Whitespace including ' ' '\n' '\r' and '\t'
     /// and certain operators may be used to delimit tokens ( ) + | " .
-    /// <p>
+    /// <para/>
     /// Any errors in query syntax will be ignored and the parser will attempt
     /// to decipher what it can; however, this may mean odd or unexpected results.
     /// <h4>Query Operators</h4>
-    /// <ul>
-    ///  <li>'{@code +}' specifies {@code AND} operation: <tt>token1+token2</tt>
-    ///  <li>'{@code |}' specifies {@code OR} operation: <tt>token1|token2</tt>
-    ///  <li>'{@code -}' negates a single token: <tt>-token0</tt>
-    ///  <li>'{@code "}' creates phrases of terms: <tt>"term1 term2 ..."</tt>
-    ///  <li>'{@code *}' at the end of terms specifies prefix query: <tt>term*</tt>
-    ///  <li>'{@code ~}N' at the end of terms specifies fuzzy query: <tt>term~1</tt>
-    ///  <li>'{@code ~}N' at the end of phrases specifies near query: <tt>"term1 term2"~5</tt>
-    ///  <li>'{@code (}' and '{@code )}' specifies precedence: <tt>token1 + (token2 | token3)</tt>
-    /// </ul>
-    /// <p>
-    /// The {@link #setDefaultOperator default operator} is {@code OR} if no other operator is specified.
-    /// For example, the following will {@code OR} {@code token1} and {@code token2} together:
-    /// <tt>token1 token2</tt>
-    /// <p>
+    /// <list type="bullet">
+    ///  <item>'<c>+</c>' specifies <c>AND</c> operation: <c>token1+token2</c></item>
+    ///  <item>'<c>|</c>' specifies <c>OR</c> operation: <c>token1|token2</c></item>
+    ///  <item>'<c>-</c>' negates a single token: <c>-token0</c></item>
+    ///  <item>'<c>"</c>' creates phrases of terms: <c>"term1 term2 ..."</c></item>
+    ///  <item>'<c>*</c>' at the end of terms specifies prefix query: <c>term*</c></item>
+    ///  <item>'<c>~</c>N' at the end of terms specifies fuzzy query: <c>term~1</c></item>
+    ///  <item>'<c>~</c>N' at the end of phrases specifies near query: <c>"term1 term2"~5</c></item>
+    ///  <item>'<c>(</c>' and '<c>)</c>' specifies precedence: <c>token1 + (token2 | token3)</c></item>
+    /// </list>
+    /// <para/>
+    /// The default operator is <c>OR</c> if no other operator is specified.
+    /// For example, the following will <c>OR</c> <c>token1</c> and <c>token2</c> together:
+    /// <c>token1 token2</c>
+    /// <para/>
     /// Normal operator precedence will be simple order from right to left.
-    /// For example, the following will evaluate {@code token1 OR token2} first,
-    /// then {@code AND} with {@code token3}:
-    /// <blockquote>token1 | token2 + token3</blockquote>
+    /// For example, the following will evaluate <c>token1 OR token2</c> first,
+    /// then <c>AND</c> with <c>token3</c>:
+    /// <code>token1 | token2 + token3</code>
     /// <h4>Escaping</h4>
-    /// <p>
+    /// <para/>
     /// An individual term may contain any possible character with certain characters
-    /// requiring escaping using a '{@code \}'.  The following characters will need to be escaped in
+    /// requiring escaping using a '<c>\</c>'.  The following characters will need to be escaped in
     /// terms and phrases:
-    /// {@code + | " ( ) ' \}
-    /// <p>
-    /// The '{@code -}' operator is a special case.  On individual terms (not phrases) the first
-    /// character of a term that is {@code -} must be escaped; however, any '{@code -}' characters
+    /// <c>+ | " ( ) ' \</c>
+    /// <para/>
+    /// The '<c>-</c>' operator is a special case.  On individual terms (not phrases) the first
+    /// character of a term that is <c>-</c> must be escaped; however, any '<c>-</c>' characters
     /// beyond the first character do not need to be escaped.
     /// For example:
-    /// <ul>
-    ///   <li>{@code -term1}   -- Specifies {@code NOT} operation against {@code term1}
-    ///   <li>{@code \-term1}  -- Searches for the term {@code -term1}.
-    ///   <li>{@code term-1}   -- Searches for the term {@code term-1}.
-    ///   <li>{@code term\-1}  -- Searches for the term {@code term-1}.
-    /// </ul>
-    /// <p>
-    /// The '{@code *}' operator is a special case. On individual terms (not phrases) the last
-    /// character of a term that is '{@code *}' must be escaped; however, any '{@code *}' characters
+    /// <list type="bullet">
+    ///   <item><c>-term1</c>   -- Specifies <c>NOT</c> operation against <c>term1</c></item>
+    ///   <item><c>\-term1</c>  -- Searches for the term <c>-term1</c>.</item>
+    ///   <item><c>term-1</c>   -- Searches for the term <c>term-1</c>.</item>
+    ///   <item><c>term\-1</c>  -- Searches for the term <c>term-1</c>.</item>
+    /// </list>
+    /// <para/>
+    /// The '<c>*</c>' operator is a special case. On individual terms (not phrases) the last
+    /// character of a term that is '<c>*</c>' must be escaped; however, any '<c>*</c>' characters
     /// before the last character do not need to be escaped:
-    /// <ul>
-    ///   <li>{@code term1*}  --  Searches for the prefix {@code term1}
-    ///   <li>{@code term1\*} --  Searches for the term {@code term1*}
-    ///   <li>{@code term*1}  --  Searches for the term {@code term*1}
-    ///   <li>{@code term\*1} --  Searches for the term {@code term*1}
-    /// </ul>
-    /// <p>
+    /// <list type="bullet">
+    ///   <item><c>term1*</c>  --  Searches for the prefix <c>term1</c></item>
+    ///   <item><c>term1\*</c> --  Searches for the term <c>term1*</c></item>
+    ///   <item><c>term*1</c>  --  Searches for the term <c>term*1</c></item>
+    ///   <item><c>term\*1</c> --  Searches for the term <c>term*1</c></item>
+    /// </list>
+    /// <para/>
     /// Note that above examples consider the terms before text processing.
     /// </summary>
     public class SimpleQueryParser : QueryBuilder
     {
-        /** Map of fields to query against with their weights */
+        /// <summary>Map of fields to query against with their weights</summary>
         protected readonly IDictionary<string, float> weights;
 
         // TODO: Make these into a [Flags] enum in .NET??
@@ -122,32 +122,19 @@ namespace Lucene.Net.QueryParsers.Simple
 
         private BooleanClause.Occur defaultOperator = BooleanClause.Occur.SHOULD;
 
-        /// <summary>
-        /// Creates a new parser searching over a single field.
-        /// </summary>
-        /// <param name="analyzer"></param>
-        /// <param name="field"></param>
+        /// <summary>Creates a new parser searching over a single field.</summary>
         public SimpleQueryParser(Analyzer analyzer, string field)
             : this(analyzer, new HashMap<string, float>() { { field, 1.0F } })
         {
         }
 
-        /// <summary>
-        /// Creates a new parser searching over multiple fields with different weights.
-        /// </summary>
-        /// <param name="analyzer"></param>
-        /// <param name="weights"></param>
+        /// <summary>Creates a new parser searching over multiple fields with different weights.</summary>
         public SimpleQueryParser(Analyzer analyzer, IDictionary<string, float> weights)
             : this(analyzer, weights, -1)
         {
         }
 
-        /// <summary>
-        /// Creates a new parser with custom flags used to enable/disable certain features.
-        /// </summary>
-        /// <param name="analyzer"></param>
-        /// <param name="weights"></param>
-        /// <param name="flags"></param>
+        /// <summary>Creates a new parser with custom flags used to enable/disable certain features.</summary>
         public SimpleQueryParser(Analyzer analyzer, IDictionary<string, float> weights, int flags)
             : base(analyzer)
         {
@@ -155,11 +142,7 @@ namespace Lucene.Net.QueryParsers.Simple
             this.flags = flags;
         }
 
-        /// <summary>
-        /// Parses the query text and returns parsed query (or null if empty)
-        /// </summary>
-        /// <param name="queryText"></param>
-        /// <returns></returns>
+        /// <summary>Parses the query text and returns parsed query (or null if empty)</summary>
         public Query Parse(string queryText)
         {
             char[] data = queryText.ToCharArray();
@@ -501,8 +484,6 @@ namespace Lucene.Net.QueryParsers.Simple
         /// is consumed to be added to our existing query tree
         /// this method will only add to the existing tree if the branch contained in state is not null
         /// </summary>
-        /// <param name="state"></param>
-        /// <param name="branch"></param>
         private void BuildQueryTree(State state, Query branch)
         {
             if (branch != null)
@@ -557,7 +538,6 @@ namespace Lucene.Net.QueryParsers.Simple
         /// <summary>
         /// Helper parsing fuzziness from parsing state
         /// </summary>
-        /// <param name="state"></param>
         /// <returns>slop/edit distance, 0 in the case of non-parsing slop/edit string</returns>
         private int ParseFuzziness(State state)
         {
@@ -596,8 +576,6 @@ namespace Lucene.Net.QueryParsers.Simple
         /// <summary>
         /// Helper returning true if the state has reached the end of token.
         /// </summary>
-        /// <param name="state"></param>
-        /// <returns></returns>
         private bool TokenFinished(State state)
         {
             if ((state.Data[state.Index] == '"' && (flags & PHRASE_OPERATOR) != 0)
@@ -618,8 +596,6 @@ namespace Lucene.Net.QueryParsers.Simple
         /// <summary>
         /// Factory method to generate a standard query (no phrase or prefix operators).
         /// </summary>
-        /// <param name="text"></param>
-        /// <returns></returns>
         protected virtual Query NewDefaultQuery(string text)
         {
             BooleanQuery bq = new BooleanQuery(true);
@@ -638,9 +614,6 @@ namespace Lucene.Net.QueryParsers.Simple
         /// <summary>
         /// Factory method to generate a fuzzy query.
         /// </summary>
-        /// <param name="text"></param>
-        /// <param name="fuzziness"></param>
-        /// <returns></returns>
         protected virtual Query NewFuzzyQuery(string text, int fuzziness)
         {
             BooleanQuery bq = new BooleanQuery(true);
@@ -659,9 +632,6 @@ namespace Lucene.Net.QueryParsers.Simple
         /// <summary>
         /// Factory method to generate a phrase query with slop.
         /// </summary>
-        /// <param name="text"></param>
-        /// <param name="slop"></param>
-        /// <returns></returns>
         protected virtual Query NewPhraseQuery(string text, int slop)
         {
             BooleanQuery bq = new BooleanQuery(true);
@@ -680,8 +650,6 @@ namespace Lucene.Net.QueryParsers.Simple
         /// <summary>
         /// Factory method to generate a prefix query.
         /// </summary>
-        /// <param name="text"></param>
-        /// <returns></returns>
         protected virtual Query NewPrefixQuery(string text)
         {
             BooleanQuery bq = new BooleanQuery(true);
@@ -697,8 +665,6 @@ namespace Lucene.Net.QueryParsers.Simple
         /// <summary>
         /// Helper to simplify boolean queries with 0 or 1 clause
         /// </summary>
-        /// <param name="bq"></param>
-        /// <returns></returns>
         protected virtual Query Simplify(BooleanQuery bq)
         {
             if (!bq.Clauses.Any())
@@ -717,7 +683,7 @@ namespace Lucene.Net.QueryParsers.Simple
 
         /// <summary>
         /// Gets or Sets the implicit operator setting, which will be
-        /// either {@code SHOULD} or {@code MUST}.
+        /// either <see cref="BooleanClause.Occur.SHOULD"/> or <see cref="BooleanClause.Occur.MUST"/>.
         /// </summary>
         public virtual BooleanClause.Occur DefaultOperator
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Surround/Parser/CharStream.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Surround/Parser/CharStream.cs b/src/Lucene.Net.QueryParser/Surround/Parser/CharStream.cs
index f4d7326..021d24e 100644
--- a/src/Lucene.Net.QueryParser/Surround/Parser/CharStream.cs
+++ b/src/Lucene.Net.QueryParser/Surround/Parser/CharStream.cs
@@ -27,7 +27,7 @@ namespace Lucene.Net.QueryParsers.Surround.Parser
     /// interface is used in the TokenManager implementation generated by
     /// JavaCCParser.
     /// 
-    /// All the methods except backup can be implemented in any fashion. backup
+    /// All the methods except <see cref="BackUp(int)"/> can be implemented in any fashion. <see cref="BackUp(int)"/>
     /// needs to be implemented correctly for the correct operation of the lexer.
     /// Rest of the methods are all used to get information like line number,
     /// column number and the string that constitutes a token and are not used
@@ -39,27 +39,21 @@ namespace Lucene.Net.QueryParsers.Surround.Parser
         /// <summary> 
         /// Returns the next character from the selected input.  The method
         /// of selecting the input is the responsibility of the class
-        /// implementing this interface.  Can throw any java.io.IOException.
+        /// implementing this interface.  Can throw any <see cref="System.IO.IOException"/>.
         /// </summary>
         char ReadChar();
 
         /// <summary>
         /// Returns the column position of the character last read.
         /// </summary>
-        /// <deprecated>
-        /// </deprecated>
-        /// <seealso cref="EndColumn">
-        /// </seealso>
+        /// <seealso cref="EndColumn"/>
         [Obsolete]
         int Column { get; }
 
         /// <summary>
         /// Returns the line number of the character last read.
         /// </summary>
-        /// <deprecated>
-        /// </deprecated>
-        /// <seealso cref="EndLine">
-        /// </seealso>
+        /// <seealso cref="EndLine"/>
         [Obsolete]
         int Line { get; }
 
@@ -98,7 +92,7 @@ namespace Lucene.Net.QueryParsers.Surround.Parser
         /// <summary> 
         /// Returns the next character that marks the beginning of the next token.
         /// All characters must remain in the buffer between two successive calls
-        /// to this method to implement backup correctly.
+        /// to this method to implement <see cref="BackUp(int)"/> correctly.
         /// </summary>
         char BeginToken();
 
@@ -116,10 +110,12 @@ namespace Lucene.Net.QueryParsers.Surround.Parser
         /// for use in actions in the case of MORE. A simple and inefficient
         /// implementation of this is as follows :
         /// 
+        /// <code>
         /// {
-        /// string t = GetImage();
-        /// return t.substring(t.length() - len, t.length()).toCharArray();
+        ///     string t = Image;
+        ///     return t.Substring(t.Length - len, len).ToCharArray();
         /// }
+        /// </code>
         /// </summary>
         char[] GetSuffix(int len);
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ced03f59/src/Lucene.Net.QueryParser/Surround/Parser/FastCharStream.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Surround/Parser/FastCharStream.cs b/src/Lucene.Net.QueryParser/Surround/Parser/FastCharStream.cs
index 26eba8e..a64a5ab 100644
--- a/src/Lucene.Net.QueryParser/Surround/Parser/FastCharStream.cs
+++ b/src/Lucene.Net.QueryParser/Surround/Parser/FastCharStream.cs
@@ -20,7 +20,9 @@ namespace Lucene.Net.QueryParsers.Surround.Parser
      */
 
     /// <summary>
-    /// An efficient implementation of JavaCC's CharStream interface.  <p/>Note that
+    /// An efficient implementation of JavaCC's <see cref="ICharStream"/> interface.  
+    /// <para/>
+    /// Note that
     /// this does not do line-number counting, but instead keeps track of the
     /// character position of the token in the input, as required by Lucene's <see cref="Lucene.Net.Analysis.Token" />
     /// API.
@@ -38,7 +40,7 @@ namespace Lucene.Net.QueryParsers.Surround.Parser
         internal System.IO.TextReader input; // source of chars
 
         /// <summary>
-        /// Constructs from a Reader. 
+        /// Constructs from a <see cref="System.IO.TextReader"/>. 
         /// </summary>
         public FastCharStream(System.IO.TextReader r)
         {


Mime
View raw message