You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucy.apache.org by nw...@apache.org on 2014/12/02 18:49:05 UTC

[1/2] lucy git commit: Shorten clownfish URIs

Repository: lucy
Updated Branches:
  refs/heads/markdown 4a6f325ab -> 82d38667a


Shorten clownfish URIs


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

Branch: refs/heads/markdown
Commit: 60f2df8f4eae865b2d8da4de9c4aea728ec9c683
Parents: 4a6f325
Author: Nick Wellnhofer <we...@aevum.de>
Authored: Tue Dec 2 17:37:09 2014 +0100
Committer: Nick Wellnhofer <we...@aevum.de>
Committed: Tue Dec 2 17:37:09 2014 +0100

----------------------------------------------------------------------
 core/Lucy/Analysis/Analyzer.cfh         |  6 +++---
 core/Lucy/Analysis/CaseFolder.cfh       |  2 +-
 core/Lucy/Analysis/EasyAnalyzer.cfh     |  6 +++---
 core/Lucy/Analysis/Normalizer.cfh       |  2 +-
 core/Lucy/Analysis/PolyAnalyzer.cfh     | 12 ++++++------
 core/Lucy/Analysis/SnowballStemmer.cfh  |  2 +-
 core/Lucy/Analysis/Token.cfh            |  2 +-
 core/Lucy/Highlight/Highlighter.cfh     |  6 +++---
 core/Lucy/Index/BackgroundMerger.cfh    |  2 +-
 core/Lucy/Index/DataReader.cfh          |  2 +-
 core/Lucy/Index/DataWriter.cfh          |  4 ++--
 core/Lucy/Index/DeletionsWriter.cfh     |  2 +-
 core/Lucy/Index/DocReader.cfh           |  2 +-
 core/Lucy/Index/IndexManager.cfh        |  2 +-
 core/Lucy/Index/IndexReader.cfh         |  8 ++++----
 core/Lucy/Index/Indexer.cfh             |  6 +++---
 core/Lucy/Index/PolyReader.cfh          |  8 ++++----
 core/Lucy/Index/Posting.cfh             |  4 ++--
 core/Lucy/Index/Posting/RichPosting.cfh |  6 +++---
 core/Lucy/Index/PostingListReader.cfh   |  2 +-
 core/Lucy/Index/SegReader.cfh           |  2 +-
 core/Lucy/Index/SegWriter.cfh           |  8 ++++----
 core/Lucy/Index/Snapshot.cfh            |  2 +-
 core/Lucy/Plan/Architecture.cfh         |  4 ++--
 core/Lucy/Plan/FieldType.cfh            |  2 +-
 core/Lucy/Plan/FullTextType.cfh         |  8 ++++----
 core/Lucy/Search/ANDQuery.cfh           |  2 +-
 core/Lucy/Search/Collector.cfh          |  4 ++--
 core/Lucy/Search/Compiler.cfh           |  8 ++++----
 core/Lucy/Search/IndexSearcher.cfh      |  4 ++--
 core/Lucy/Search/LeafQuery.cfh          |  6 +++---
 core/Lucy/Search/NOTQuery.cfh           |  4 ++--
 core/Lucy/Search/NoMatchQuery.cfh       |  2 +-
 core/Lucy/Search/ORQuery.cfh            |  2 +-
 core/Lucy/Search/PhraseQuery.cfh        |  2 +-
 core/Lucy/Search/PolyQuery.cfh          |  8 ++++----
 core/Lucy/Search/Query.cfh              |  8 ++++----
 core/Lucy/Search/QueryParser.cfh        | 10 +++++-----
 core/Lucy/Search/Searcher.cfh           |  8 ++++----
 core/Lucy/Search/SortRule.cfh           |  2 +-
 core/Lucy/Search/SortSpec.cfh           |  2 +-
 core/Lucy/Search/TermQuery.cfh          |  2 +-
 core/Lucy/Store/FSFolder.cfh            |  2 +-
 core/Lucy/Store/Folder.cfh              |  2 +-
 core/Lucy/Store/LockFactory.cfh         |  2 +-
 core/Lucy/Store/RAMFolder.cfh           |  2 +-
 core/Lucy/Store/SharedLock.cfh          |  2 +-
 core/LucyX/Search/ProximityQuery.cfh    |  2 +-
 48 files changed, 99 insertions(+), 99 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Analysis/Analyzer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/Analyzer.cfh b/core/Lucy/Analysis/Analyzer.cfh
index 1c9136f..bbc9722 100644
--- a/core/Lucy/Analysis/Analyzer.cfh
+++ b/core/Lucy/Analysis/Analyzer.cfh
@@ -20,16 +20,16 @@ parcel Lucy;
  *
  * An Analyzer is a filter which processes text, transforming it from one form
  * into another.  For instance, an analyzer might break up a long text into
- * smaller pieces ([RegexTokenizer](clownfish:class:lucy:RegexTokenizer)), or it
+ * smaller pieces ([RegexTokenizer](clownfish:class:RegexTokenizer)), or it
  * might perform case folding to facilitate case-insensitive search
- * ([Normalizer](clownfish:class:lucy:Normalizer)).
+ * ([Normalizer](clownfish:class:Normalizer)).
  */
 public abstract class Lucy::Analysis::Analyzer inherits Clownfish::Obj {
 
     public inert Analyzer*
     init(Analyzer *self);
 
-    /** Take a single [Inversion](clownfish:class:lucy:Inversion) as input
+    /** Take a single [Inversion](clownfish:class:Inversion) as input
      * and returns an Inversion, either the same one (presumably transformed
      * in some way), or a new one.
      */

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Analysis/CaseFolder.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/CaseFolder.cfh b/core/Lucy/Analysis/CaseFolder.cfh
index 50b558d..d42cfa1 100644
--- a/core/Lucy/Analysis/CaseFolder.cfh
+++ b/core/Lucy/Analysis/CaseFolder.cfh
@@ -18,7 +18,7 @@ parcel Lucy;
 
 /** Normalize case, facilitating case-insensitive search.
  *
- * CaseFolder is DEPRECATED. Use [Normalizer](clownfish:class:lucy:Normalizer)
+ * CaseFolder is DEPRECATED. Use [Normalizer](clownfish:class:Normalizer)
  * instead.
  *
  * CaseFolder normalizes text according to Unicode case-folding rules, so that

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Analysis/EasyAnalyzer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/EasyAnalyzer.cfh b/core/Lucy/Analysis/EasyAnalyzer.cfh
index 34352ea..d138767 100644
--- a/core/Lucy/Analysis/EasyAnalyzer.cfh
+++ b/core/Lucy/Analysis/EasyAnalyzer.cfh
@@ -19,9 +19,9 @@ parcel Lucy;
 /** A simple analyzer chain.
  *
  * EasyAnalyzer is an analyzer chain consisting of a
- * [StandardTokenizer](clownfish:class:lucy:StandardTokenizer), a
- * [Normalizer](clownfish:class:lucy:Normalizer), and a
- * [SnowballStemmer](clownfish:class:lucy:SnowballStemmer).
+ * [StandardTokenizer](clownfish:class:StandardTokenizer), a
+ * [Normalizer](clownfish:class:Normalizer), and a
+ * [SnowballStemmer](clownfish:class:SnowballStemmer).
  *
  * Supported languages:
  *

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Analysis/Normalizer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/Normalizer.cfh b/core/Lucy/Analysis/Normalizer.cfh
index 53cf3f4..9f49e6a 100644
--- a/core/Lucy/Analysis/Normalizer.cfh
+++ b/core/Lucy/Analysis/Normalizer.cfh
@@ -18,7 +18,7 @@ parcel Lucy;
 
 /** Unicode normalization, case folding and accent stripping.
  *
- * Normalizer is an [Analyzer](clownfish:class:lucy:Analyzer) which normalizes
+ * Normalizer is an [Analyzer](clownfish:class:Analyzer) which normalizes
  * tokens to one of the Unicode normalization forms. Optionally, it
  * performs Unicode case folding and converts accented characters to their
  * base character.

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Analysis/PolyAnalyzer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/PolyAnalyzer.cfh b/core/Lucy/Analysis/PolyAnalyzer.cfh
index f962f42..e0946ae 100644
--- a/core/Lucy/Analysis/PolyAnalyzer.cfh
+++ b/core/Lucy/Analysis/PolyAnalyzer.cfh
@@ -18,16 +18,16 @@ parcel Lucy;
 
 /** Multiple Analyzers in series.
  *
- * A PolyAnalyzer is a series of [Analyzers](clownfish:class:lucy:Analyzer),
+ * A PolyAnalyzer is a series of [Analyzers](clownfish:class:Analyzer),
  * each of which will be called upon to "analyze" text in turn.  You can
  * either provide the Analyzers yourself, or you can specify a supported
  * language, in which case a PolyAnalyzer consisting of a
- * [CaseFolder](clownfish:class:lucy:CaseFolder), a
- * [RegexTokenizer](clownfish:class:lucy:RegexTokenizer), and a
- * [SnowballStemmer](clownfish:class:lucy:SnowballStemmer) will be generated for you.
+ * [CaseFolder](clownfish:class:CaseFolder), a
+ * [RegexTokenizer](clownfish:class:RegexTokenizer), and a
+ * [SnowballStemmer](clownfish:class:SnowballStemmer) will be generated for you.
  *
  * The language parameter is DEPRECATED. Use
- * [EasyAnalyzer](clownfish:class:lucy:EasyAnalyzer) instead.
+ * [EasyAnalyzer](clownfish:class:EasyAnalyzer) instead.
  *
  * Supported languages:
  *
@@ -56,7 +56,7 @@ public class Lucy::Analysis::PolyAnalyzer inherits Lucy::Analysis::Analyzer {
 
     /**
      * @param language An ISO code from the list of supported languages.
-     * DEPRECATED, use [EasyAnalyzer](clownfish:class:lucy:EasyAnalyzer) instead.
+     * DEPRECATED, use [EasyAnalyzer](clownfish:class:EasyAnalyzer) instead.
      * @param analyzers An array of Analyzers.  The order of the analyzers
      * matters.  Don't put a SnowballStemmer before a RegexTokenizer (can't stem whole
      * documents or paragraphs -- just individual words), or a SnowballStopFilter

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Analysis/SnowballStemmer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/SnowballStemmer.cfh b/core/Lucy/Analysis/SnowballStemmer.cfh
index cebb7a0..e3ea345 100644
--- a/core/Lucy/Analysis/SnowballStemmer.cfh
+++ b/core/Lucy/Analysis/SnowballStemmer.cfh
@@ -18,7 +18,7 @@ parcel Lucy;
 
 /** Reduce related words to a shared root.
  *
- * SnowballStemmer is an [Analyzer](clownfish:class:lucy:Analyzer) which reduces
+ * SnowballStemmer is an [Analyzer](clownfish:class:Analyzer) which reduces
  * related words to a root form (using the "Snowball" stemming library).  For
  * instance, "horse", "horses", and "horsing" all become "hors" -- so that a
  * search for 'horse' will also match documents containing 'horses' and

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Analysis/Token.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/Token.cfh b/core/Lucy/Analysis/Token.cfh
index f3058e8..4d6c60f 100644
--- a/core/Lucy/Analysis/Token.cfh
+++ b/core/Lucy/Analysis/Token.cfh
@@ -39,7 +39,7 @@ parcel Lucy;
  * more or less importance to a particular token, as you might for emboldened
  * text within an HTML document, for example.  (Note: The field this token
  * belongs to must be spec'd to use a posting of type
- * [RichPosting](clownfish:class:lucy:RichPosting).)
+ * [RichPosting](clownfish:class:RichPosting).)
  *
  * `pos_inc` is the POSition INCrement, measured in Tokens.  This
  * attribute, which defaults to 1, is a an advanced tool for manipulating

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Highlight/Highlighter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Highlight/Highlighter.cfh b/core/Lucy/Highlight/Highlighter.cfh
index edbe1cd..15b41ae 100644
--- a/core/Lucy/Highlight/Highlighter.cfh
+++ b/core/Lucy/Highlight/Highlighter.cfh
@@ -40,12 +40,12 @@ public class Lucy::Highlight::Highlighter inherits Clownfish::Obj {
 
     /**
      * @param searcher An object which inherits from
-     * [Searcher](clownfish:class:lucy:Searcher), such as an
-     * [IndexSearcher](clownfish:class:lucy:IndexSearcher).
+     * [Searcher](clownfish:class:Searcher), such as an
+     * [IndexSearcher](clownfish:class:IndexSearcher).
      * @param query Query object or a query string.
      * @param field The name of the field from which to draw the excerpt.  The
      * field must marked as be `highlightable` (see
-     * [FieldType](clownfish:class:lucy:FieldType)).
+     * [FieldType](clownfish:class:FieldType)).
      * @param excerpt_length Maximum length of the excerpt, in characters.
      */
     public inert Highlighter*

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Index/BackgroundMerger.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/BackgroundMerger.cfh b/core/Lucy/Index/BackgroundMerger.cfh
index 024a02d..4e1def8 100644
--- a/core/Lucy/Index/BackgroundMerger.cfh
+++ b/core/Lucy/Index/BackgroundMerger.cfh
@@ -23,7 +23,7 @@ parcel Lucy;
  * complete.  See L<Lucy::Docs::Cookbook::FastUpdates> for how to use
  * this class to control worst-case index update performance.
  *
- * As with [Indexer](clownfish:class:lucy:Indexer), see
+ * As with [Indexer](clownfish:class:Indexer), see
  * L<Lucy::Docs::FileLocking> if your index is on a shared volume.
  */
 public class Lucy::Index::BackgroundMerger nickname BGMerger

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Index/DataReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DataReader.cfh b/core/Lucy/Index/DataReader.cfh
index 721e876..b800702 100644
--- a/core/Lucy/Index/DataReader.cfh
+++ b/core/Lucy/Index/DataReader.cfh
@@ -19,7 +19,7 @@ parcel Lucy;
 /** Abstract base class for reading index data.
  *
  * DataReader is the companion class to
- * [DataWriter](clownfish:class:lucy:DataWriter).  Every index component will
+ * [DataWriter](clownfish:class:DataWriter).  Every index component will
  * implement one of each.
  */
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Index/DataWriter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DataWriter.cfh b/core/Lucy/Index/DataWriter.cfh
index daf62a5..2e7586f 100644
--- a/core/Lucy/Index/DataWriter.cfh
+++ b/core/Lucy/Index/DataWriter.cfh
@@ -21,10 +21,10 @@ parcel Lucy;
  * DataWriter is an abstract base class for writing index data, generally in
  * segment-sized chunks. Each component of an index -- e.g. stored fields,
  * lexicon, postings, deletions -- is represented by a
- * DataWriter/[DataReader](clownfish:class:lucy:DataReader) pair.
+ * DataWriter/[DataReader](clownfish:class:DataReader) pair.
  *
  * Components may be specified per index by subclassing
- * [Architecture](clownfish:class:lucy:Architecture).
+ * [Architecture](clownfish:class:Architecture).
  */
 
 public class Lucy::Index::DataWriter inherits Clownfish::Obj {

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Index/DeletionsWriter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DeletionsWriter.cfh b/core/Lucy/Index/DeletionsWriter.cfh
index 634d1fe..1da9aae 100644
--- a/core/Lucy/Index/DeletionsWriter.cfh
+++ b/core/Lucy/Index/DeletionsWriter.cfh
@@ -51,7 +51,7 @@ public abstract class Lucy::Index::DeletionsWriter nickname DelWriter
 
     /** Delete all documents in the index that match `query`.
      *
-     * @param query A [Query](clownfish:class:lucy:Query).
+     * @param query A [Query](clownfish:class:Query).
      */
     public abstract void
     Delete_By_Query(DeletionsWriter *self, Query *query);

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Index/DocReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DocReader.cfh b/core/Lucy/Index/DocReader.cfh
index 07ccf3c..917447d 100644
--- a/core/Lucy/Index/DocReader.cfh
+++ b/core/Lucy/Index/DocReader.cfh
@@ -20,7 +20,7 @@ parcel Lucy;
  *
  * DocReader defines the interface by which documents (with all stored fields)
  * are retrieved from the index.  The default implementation returns
- * [HitDoc](clownfish:class:lucy:HitDoc) objects.
+ * [HitDoc](clownfish:class:HitDoc) objects.
  */
 public class Lucy::Index::DocReader inherits Lucy::Index::DataReader {
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Index/IndexManager.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/IndexManager.cfh b/core/Lucy/Index/IndexManager.cfh
index 5c29a09..5d6672d 100644
--- a/core/Lucy/Index/IndexManager.cfh
+++ b/core/Lucy/Index/IndexManager.cfh
@@ -21,7 +21,7 @@ parcel Lucy;
  * IndexManager is an advanced-use class for controlling index locking,
  * updating, merging, and deletion behaviors.
  *
- * IndexManager and [Architecture](clownfish:class:lucy:Architecture) are
+ * IndexManager and [Architecture](clownfish:class:Architecture) are
  * complementary classes: Architecture is used to define traits and behaviors
  * which cannot change for the life of an index; IndexManager is used for
  * defining rules which may change from process to process.

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Index/IndexReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/IndexReader.cfh b/core/Lucy/Index/IndexReader.cfh
index 9997a32..aa08e2b 100644
--- a/core/Lucy/Index/IndexReader.cfh
+++ b/core/Lucy/Index/IndexReader.cfh
@@ -19,7 +19,7 @@ parcel Lucy;
 /** Read from an inverted index.
  *
  * IndexReader is the interface through which
- * [IndexSearcher](clownfish:class:lucy:IndexSearcher) objects access the
+ * [IndexSearcher](clownfish:class:IndexSearcher) objects access the
  * content of an index.
  *
  * IndexReader objects always represent a point-in-time view of an index as it
@@ -28,10 +28,10 @@ parcel Lucy;
  * after the update process completes.
  *
  * IndexReaders are composites; most of the work is done by individual
- * [DataReader](clownfish:class:lucy:DataReader) sub-components, which may be
+ * [DataReader](clownfish:class:DataReader) sub-components, which may be
  * accessed via Fetch() and Obtain().  The most efficient and powerful access
  * to index data happens at the segment level via
- * [SegReader](clownfish:class:lucy:SegReader)'s sub-components.
+ * [SegReader](clownfish:class:SegReader)'s sub-components.
  */
 
 public class Lucy::Index::IndexReader nickname IxReader
@@ -57,7 +57,7 @@ public class Lucy::Index::IndexReader nickname IxReader
      * @param index Either a string filepath or a Folder.
      * @param snapshot A Snapshot.  If not supplied, the most recent snapshot
      * file will be used.
-     * @param manager An [IndexManager](clownfish:class:lucy:IndexManager).
+     * @param manager An [IndexManager](clownfish:class:IndexManager).
      * Read-locking is off by default; supplying this argument turns it on.
      */
     public inert nullable IndexReader*

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Index/Indexer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/Indexer.cfh b/core/Lucy/Index/Indexer.cfh
index c5524f3..98eec00 100644
--- a/core/Lucy/Index/Indexer.cfh
+++ b/core/Lucy/Index/Indexer.cfh
@@ -20,14 +20,14 @@ parcel Lucy;
  *
  * The Indexer class is Apache Lucy's primary tool for managing the content of
  * inverted indexes, which may later be searched using
- * [IndexSearcher](clownfish:class:lucy:IndexSearcher).
+ * [IndexSearcher](clownfish:class:IndexSearcher).
  *
  * In general, only one Indexer at a time may write to an index safely.  If a
  * write lock cannot be secured, new() will throw an exception.
  *
  * If an index is located on a shared volume, each writer application must
  * identify itself by supplying an
- * [IndexManager](clownfish:class:lucy:IndexManager) with a unique
+ * [IndexManager](clownfish:class:IndexManager) with a unique
  * `host` id to Indexer's constructor or index corruption will
  * occur.  See L<Lucy::Docs::FileLocking> for a detailed discussion.
  *
@@ -107,7 +107,7 @@ public class Lucy::Index::Indexer inherits Clownfish::Obj {
 
     /** Mark documents which match the supplied Query as deleted.
      *
-     * @param query A [Query](clownfish:class:lucy:Query).
+     * @param query A [Query](clownfish:class:Query).
      */
     public void
     Delete_By_Query(Indexer *self, Query *query);

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Index/PolyReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/PolyReader.cfh b/core/Lucy/Index/PolyReader.cfh
index cd39c99..5eda742 100644
--- a/core/Lucy/Index/PolyReader.cfh
+++ b/core/Lucy/Index/PolyReader.cfh
@@ -22,9 +22,9 @@ parcel Lucy;
  * an index contains three segments with 10 documents each, PolyReader's
  * Doc_Max() method will return 30.
  *
- * Some of PolyReader's [DataReader](clownfish:class:lucy:DataReader) components
+ * Some of PolyReader's [DataReader](clownfish:class:DataReader) components
  * may be less efficient or complete than the single-segment implementations
- * accessed via [SegReader](clownfish:class:lucy:SegReader).
+ * accessed via [SegReader](clownfish:class:SegReader).
  */
 public class Lucy::Index::PolyReader inherits Lucy::Index::IndexReader {
 
@@ -37,10 +37,10 @@ public class Lucy::Index::PolyReader inherits Lucy::Index::IndexReader {
     open(Obj *index, Snapshot *snapshot = NULL, IndexManager *manager = NULL);
 
     /**
-     * @param index Either a string filepath or a [Folder](clownfish:class:lucy:Folder).
+     * @param index Either a string filepath or a [Folder](clownfish:class:Folder).
      * @param snapshot A Snapshot.  If not supplied, the most recent snapshot
      * file will be used.
-     * @param manager An [IndexManager](clownfish:class:lucy:IndexManager).
+     * @param manager An [IndexManager](clownfish:class:IndexManager).
      * Read-locking is off by default; supplying this argument turns it on.
      */
     public inert nullable PolyReader*

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Index/Posting.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/Posting.cfh b/core/Lucy/Index/Posting.cfh
index 0f5fe82..836e9c2 100644
--- a/core/Lucy/Index/Posting.cfh
+++ b/core/Lucy/Index/Posting.cfh
@@ -23,9 +23,9 @@ parcel Lucy;
  * academic definition of "posting".)
  *
  * Subclasses include
- * [MatchPosting](clownfish:class:lucy:MatchPosting), the simplest
+ * [MatchPosting](clownfish:class:MatchPosting), the simplest
  * posting format, and
- * [ScorePosting](clownfish:class:lucy:ScorePosting), the default.
+ * [ScorePosting](clownfish:class:ScorePosting), the default.
  */
 class Lucy::Index::Posting nickname Post inherits Lucy::Util::Stepper {
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Index/Posting/RichPosting.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/Posting/RichPosting.cfh b/core/Lucy/Index/Posting/RichPosting.cfh
index 3badbf5..0720e37 100644
--- a/core/Lucy/Index/Posting/RichPosting.cfh
+++ b/core/Lucy/Index/Posting/RichPosting.cfh
@@ -19,10 +19,10 @@ parcel Lucy;
 /** Posting with per-position boost.
  *
  * RichPosting is similar to
- * [ScorePosting](clownfish:class:lucy:ScorePosting), but weighting is
+ * [ScorePosting](clownfish:class:ScorePosting), but weighting is
  * per-position rather than per-field.  To exploit this, you need a custom
- * [Analyzer](clownfish:class:lucy:Analyzer) which assigns varying boosts to
- * individual [Token](clownfish:class:lucy:Token) objects.
+ * [Analyzer](clownfish:class:Analyzer) which assigns varying boosts to
+ * individual [Token](clownfish:class:Token) objects.
  *
  * A typical application for RichPosting is an HTMLAnalyzer which assigns
  * boost based on the visual size and weight of the marked up text: H1

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Index/PostingListReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/PostingListReader.cfh b/core/Lucy/Index/PostingListReader.cfh
index 28d6921..6474aeb 100644
--- a/core/Lucy/Index/PostingListReader.cfh
+++ b/core/Lucy/Index/PostingListReader.cfh
@@ -18,7 +18,7 @@ parcel Lucy;
 
 /** Read postings data.
  *
- * PostingListReaders produce [PostingList](clownfish:class:lucy:PostingList)
+ * PostingListReaders produce [PostingList](clownfish:class:PostingList)
  * objects which convey document matching information.
  */
 public class Lucy::Index::PostingListReader nickname PListReader

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Index/SegReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/SegReader.cfh b/core/Lucy/Index/SegReader.cfh
index 6582190..428de8d 100644
--- a/core/Lucy/Index/SegReader.cfh
+++ b/core/Lucy/Index/SegReader.cfh
@@ -24,7 +24,7 @@ parcel Lucy;
  * data at the segment level need to deal with the SegReader API directly.
  *
  * Nearly all of SegReader's functionality is implemented by pluggable
- * components spawned by [Architecture](clownfish:class:lucy:Architecture)'s
+ * components spawned by [Architecture](clownfish:class:Architecture)'s
  * factory methods.
  */
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Index/SegWriter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/SegWriter.cfh b/core/Lucy/Index/SegWriter.cfh
index 5825970..16f784b 100644
--- a/core/Lucy/Index/SegWriter.cfh
+++ b/core/Lucy/Index/SegWriter.cfh
@@ -20,13 +20,13 @@ parcel Lucy;
 /** Write one segment of an index.
  *
  * SegWriter is a conduit through which information fed to Indexer passes.  It
- * manages [Segment](clownfish:class:lucy:Segment) and Inverter, invokes the
- * [Analyzer](clownfish:class:lucy:Analyzer) chain, and feeds low
- * level [DataWriters](clownfish:class:lucy:DataWriter) such as
+ * manages [Segment](clownfish:class:Segment) and Inverter, invokes the
+ * [Analyzer](clownfish:class:Analyzer) chain, and feeds low
+ * level [DataWriters](clownfish:class:DataWriter) such as
  * PostingListWriter and DocWriter.
  *
  * The sub-components of a SegWriter are determined by
- * [Architecture](clownfish:class:lucy:Architecture).  DataWriter components
+ * [Architecture](clownfish:class:Architecture).  DataWriter components
  * which are added to the stack of writers via Add_Writer() have
  * Add_Inverted_Doc() invoked for each document supplied to SegWriter's
  * Add_Doc().

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Index/Snapshot.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/Snapshot.cfh b/core/Lucy/Index/Snapshot.cfh
index 2c744a0..634be2c 100644
--- a/core/Lucy/Index/Snapshot.cfh
+++ b/core/Lucy/Index/Snapshot.cfh
@@ -22,7 +22,7 @@ parcel Lucy;
  * written, are never modified, a Snapshot defines a point-in-time view of the
  * data in an index.
  *
- * [IndexReader](clownfish:class:lucy:IndexReader) objects interpret the data
+ * [IndexReader](clownfish:class:IndexReader) objects interpret the data
  * associated with a single Snapshot.
  */
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Plan/Architecture.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Plan/Architecture.cfh b/core/Lucy/Plan/Architecture.cfh
index b04b0e3..3162daa 100644
--- a/core/Lucy/Plan/Architecture.cfh
+++ b/core/Lucy/Plan/Architecture.cfh
@@ -22,8 +22,8 @@ parcel Lucy;
  * postings, stored documents, deletions, and highlight data.  The readers and
  * writers for that data are spawned by Architecture.  Each component operates
  * at the segment level; Architecture's factory methods are used to build up
- * [SegWriter](clownfish:class:lucy:SegWriter) and
- * [SegReader](clownfish:class:lucy:SegReader).
+ * [SegWriter](clownfish:class:SegWriter) and
+ * [SegReader](clownfish:class:SegReader).
  */
 public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj {
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Plan/FieldType.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Plan/FieldType.cfh b/core/Lucy/Plan/FieldType.cfh
index 215bc7d..1c0880e 100644
--- a/core/Lucy/Plan/FieldType.cfh
+++ b/core/Lucy/Plan/FieldType.cfh
@@ -65,7 +65,7 @@ __END_C__
  * not settable.
  *
  * The `similarity` property is a
- * [Similarity](clownfish:class:lucy:Similarity) object which defines matching
+ * [Similarity](clownfish:class:Similarity) object which defines matching
  * and scoring behavior for the field.  It is required if the field is
  * `indexed`.
  */

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Plan/FullTextType.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Plan/FullTextType.cfh b/core/Lucy/Plan/FullTextType.cfh
index 6537b8b..f358635 100644
--- a/core/Lucy/Plan/FullTextType.cfh
+++ b/core/Lucy/Plan/FullTextType.cfh
@@ -19,14 +19,14 @@ parcel Lucy;
 /** Full-text search field type.
  *
  * Lucy::Plan::FullTextType is an implementation of
- * [FieldType](clownfish:class:lucy:FieldType) tuned for "full text search".
+ * [FieldType](clownfish:class:FieldType) tuned for "full text search".
  *
  * Full text fields are associated with an
- * [Analyzer](clownfish:class:lucy:Analyzer), which is used to tokenize and
+ * [Analyzer](clownfish:class:Analyzer), which is used to tokenize and
  * normalize the text so that it can be searched for individual words.
  *
  * For an exact-match, single value field type using character data, see
- * [StringType](clownfish:class:lucy:StringType).
+ * [StringType](clownfish:class:StringType).
  */
 public class Lucy::Plan::FullTextType inherits Lucy::Plan::TextType {
 
@@ -54,7 +54,7 @@ public class Lucy::Plan::FullTextType inherits Lucy::Plan::TextType {
     new(Analyzer *analyzer);
 
     /** Indicate whether to store data required by
-     * [Highlighter](clownfish:class:lucy:Highlighter) for excerpt selection and search
+     * [Highlighter](clownfish:class:Highlighter) for excerpt selection and search
      * term highlighting.
      */
     public void

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/ANDQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/ANDQuery.cfh b/core/Lucy/Search/ANDQuery.cfh
index 200fc75..6322e67 100644
--- a/core/Lucy/Search/ANDQuery.cfh
+++ b/core/Lucy/Search/ANDQuery.cfh
@@ -18,7 +18,7 @@ parcel Lucy;
 
 /** Intersect multiple result sets.
  *
- * ANDQuery is a composite [Query](clownfish:class:lucy:Query) which matches
+ * ANDQuery is a composite [Query](clownfish:class:Query) which matches
  * only when all of its children match, so its result set is the intersection
  * of their result sets.  Documents which match receive a summed score.
  */

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/Collector.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Collector.cfh b/core/Lucy/Search/Collector.cfh
index 4d71e13..b15f2e0 100644
--- a/core/Lucy/Search/Collector.cfh
+++ b/core/Lucy/Search/Collector.cfh
@@ -19,7 +19,7 @@ parcel Lucy;
 /** Process hits.
  *
  * A Collector decides what to do with the hits that a
- * [Matcher](clownfish:class:lucy:Matcher) iterates through, based on how the
+ * [Matcher](clownfish:class:Matcher) iterates through, based on how the
  * abstract Collect() method is implemented.
  *
  * Collectors operate on individual segments, but must operate within the
@@ -77,7 +77,7 @@ public abstract class Lucy::Search::Collector nickname Coll
 /** Collector which records doc nums in a BitVector.
  *
  * BitCollector is a Collector which saves matching document ids in a
- * [BitVector](clownfish:class:lucy:BitVector).  It is useful for recording the
+ * [BitVector](clownfish:class:BitVector).  It is useful for recording the
  * entire set of documents which matches a query.
  */
 public class Lucy::Search::Collector::BitCollector nickname BitColl

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/Compiler.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Compiler.cfh b/core/Lucy/Search/Compiler.cfh
index 5335fb2..eb260af 100644
--- a/core/Lucy/Search/Compiler.cfh
+++ b/core/Lucy/Search/Compiler.cfh
@@ -19,8 +19,8 @@ parcel Lucy;
 /** Query-to-Matcher compiler.
  *
  * The purpose of the Compiler class is to take a specification in the form of
- * a [Query](clownfish:class:lucy:Query) object and compile a
- * [Matcher](clownfish:class:lucy:Matcher) object that can do real work.
+ * a [Query](clownfish:class:Query) object and compile a
+ * [Matcher](clownfish:class:Matcher) object that can do real work.
  *
  * The simplest Compiler subclasses -- such as those associated with
  * constant-scoring Query types -- might simply implement a Make_Matcher()
@@ -36,7 +36,7 @@ parcel Lucy;
  * Compiling a Matcher is a two stage process.
  *
  * The first stage takes place during the Compiler's construction, which is
- * where the Query object meets a [Searcher](clownfish:class:lucy:Searcher)
+ * where the Query object meets a [Searcher](clownfish:class:Searcher)
  * object for the first time.  Searchers operate on a specific document
  * collection and they can tell you certain statistical information about the
  * collection -- such as how many total documents are in the collection, or
@@ -46,7 +46,7 @@ parcel Lucy;
  * subclasses might do something similar.
  *
  * The second stage of compilation is Make_Matcher(), method, which is where
- * the Compiler meets a [SegReader](clownfish:class:lucy:SegReader) object.
+ * the Compiler meets a [SegReader](clownfish:class:SegReader) object.
  * SegReaders are associated with a single segment within a single index on a
  * single machine, and are thus lower-level than Searchers, which may
  * represent a document collection spread out over a search cluster

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/IndexSearcher.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/IndexSearcher.cfh b/core/Lucy/Search/IndexSearcher.cfh
index 7a7cd26..0115318 100644
--- a/core/Lucy/Search/IndexSearcher.cfh
+++ b/core/Lucy/Search/IndexSearcher.cfh
@@ -20,10 +20,10 @@ parcel Lucy;
  *
  * Use the IndexSearcher class to perform search queries against an index.
  * (For searching multiple indexes at once, see
- * [PolySearcher](clownfish:class:lucy:PolySearcher)).
+ * [PolySearcher](clownfish:class:PolySearcher)).
  *
  * IndexSearchers operate against a single point-in-time view or
- * [Snapshot](clownfish:class:lucy:Snapshot) of the index.  If an index is
+ * [Snapshot](clownfish:class:Snapshot) of the index.  If an index is
  * modified, a new IndexSearcher must be opened to access the changes.
  */
 public class Lucy::Search::IndexSearcher nickname IxSearcher

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/LeafQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/LeafQuery.cfh b/core/Lucy/Search/LeafQuery.cfh
index 600e51b..1d6db24 100644
--- a/core/Lucy/Search/LeafQuery.cfh
+++ b/core/Lucy/Search/LeafQuery.cfh
@@ -19,10 +19,10 @@ parcel Lucy;
 /** Leaf node in a tree created by QueryParser.
  *
  * LeafQuery objects serve as leaf nodes in the tree structure generated by
- * [QueryParser](clownfish:class:lucy:QueryParser)'s Tree() method.
+ * [QueryParser](clownfish:class:QueryParser)'s Tree() method.
  * Ultimately, they must be transformed, typically into either
- * [TermQuery](clownfish:class:lucy:TermQuery) or
- * [PhraseQuery](clownfish:class:lucy:PhraseQuery) objects, as attempting to
+ * [TermQuery](clownfish:class:TermQuery) or
+ * [PhraseQuery](clownfish:class:PhraseQuery) objects, as attempting to
  * search a LeafQuery causes an error.
  */
 public class Lucy::Search::LeafQuery inherits Lucy::Search::Query {

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/NOTQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/NOTQuery.cfh b/core/Lucy/Search/NOTQuery.cfh
index b0f72dc..730f900 100644
--- a/core/Lucy/Search/NOTQuery.cfh
+++ b/core/Lucy/Search/NOTQuery.cfh
@@ -18,12 +18,12 @@ parcel Lucy;
 
 /** Invert the result set of another Query.
  *
- * A NOTQuery wraps another [Query](clownfish:class:lucy:Query) and matches
+ * A NOTQuery wraps another [Query](clownfish:class:Query) and matches
  * against its inverse document set.  All matching docs recieve a score of
  * 0.0.
  *
  * NOTQuery is often used in conjunction with
- * [ANDQuery](clownfish:class:lucy:ANDQuery) to provide "a AND NOT b"
+ * [ANDQuery](clownfish:class:ANDQuery) to provide "a AND NOT b"
  * semantics.
  */
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/NoMatchQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/NoMatchQuery.cfh b/core/Lucy/Search/NoMatchQuery.cfh
index 5dc0b02..080b4a6 100644
--- a/core/Lucy/Search/NoMatchQuery.cfh
+++ b/core/Lucy/Search/NoMatchQuery.cfh
@@ -20,7 +20,7 @@ parcel Lucy;
  *
  * NoMatchQuery is a utility class representing a query which matches nothing.
  * Typical usage might include e.g. returning a NoMatchQuery when a
- * [QueryParser](clownfish:class:lucy:QueryParser) is asked to parse an empty
+ * [QueryParser](clownfish:class:QueryParser) is asked to parse an empty
  * string.
  */
 public class Lucy::Search::NoMatchQuery inherits Lucy::Search::Query {

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/ORQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/ORQuery.cfh b/core/Lucy/Search/ORQuery.cfh
index 20c5c3b..5be0dce 100644
--- a/core/Lucy/Search/ORQuery.cfh
+++ b/core/Lucy/Search/ORQuery.cfh
@@ -18,7 +18,7 @@ parcel Lucy;
 
 /** Union multiple result sets.
  *
- * ORQuery is a composite [Query](clownfish:class:lucy:Query) which matches
+ * ORQuery is a composite [Query](clownfish:class:Query) which matches
  * when any of its children match, so its result set is the union of their
  * result sets.  Matching documents recieve a summed score from all matching
  * child Queries.

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/PhraseQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/PhraseQuery.cfh b/core/Lucy/Search/PhraseQuery.cfh
index 8a6a461..aeafac2 100644
--- a/core/Lucy/Search/PhraseQuery.cfh
+++ b/core/Lucy/Search/PhraseQuery.cfh
@@ -18,7 +18,7 @@ parcel Lucy;
 
 /** Query matching an ordered list of terms.
  *
- * PhraseQuery is a subclass of [Query](clownfish:class:lucy:Query) for matching
+ * PhraseQuery is a subclass of [Query](clownfish:class:Query) for matching
  * against an ordered sequence of terms.
  */
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/PolyQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/PolyQuery.cfh b/core/Lucy/Search/PolyQuery.cfh
index 5d47534..8dcbde8 100644
--- a/core/Lucy/Search/PolyQuery.cfh
+++ b/core/Lucy/Search/PolyQuery.cfh
@@ -19,10 +19,10 @@ parcel Lucy;
 /** Base class for composite Query objects.
  *
  * PolyQuery serves as a shared base class for
- * [ANDQuery](clownfish:class:lucy:ANDQuery),
- * [ORQuery](clownfish:class:lucy:ORQuery),
- * [NOTQuery](clownfish:class:lucy:NOTQuery), and
- * [RequiredOptionalQuery](clownfish:class:lucy:RequiredOptionalQuery).  All of
+ * [ANDQuery](clownfish:class:ANDQuery),
+ * [ORQuery](clownfish:class:ORQuery),
+ * [NOTQuery](clownfish:class:NOTQuery), and
+ * [RequiredOptionalQuery](clownfish:class:RequiredOptionalQuery).  All of
  * these classes may serve as nodes in composite Query with a tree structure
  * which may be walked.
  */

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/Query.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Query.cfh b/core/Lucy/Search/Query.cfh
index d51398b..523ae1b 100644
--- a/core/Lucy/Search/Query.cfh
+++ b/core/Lucy/Search/Query.cfh
@@ -22,15 +22,15 @@ parcel Lucy;
  * necessary to define a search query.
  *
  * The most common way to generate Query objects is to feed a search string
- * such as 'foo AND bar' to a [QueryParser's](clownfish:class:lucy:QueryParser)
+ * such as 'foo AND bar' to a [QueryParser's](clownfish:class:QueryParser)
  * Parse() method, which outputs an abstract syntax tree built up from various
- * Query subclasses such as [ANDQuery](clownfish:class:lucy:ANDQuery) and
- * [TermQuery](clownfish:class:lucy:TermQuery).  However, it is also possible
+ * Query subclasses such as [ANDQuery](clownfish:class:ANDQuery) and
+ * [TermQuery](clownfish:class:TermQuery).  However, it is also possible
  * to use custom Query objects to build a search specification which cannot be
  * easily represented using a search string.
  *
  * Subclasses of Query must implement Make_Compiler(), which is the first step
- * in compiling a Query down to a [Matcher](clownfish:class:lucy:Matcher) which
+ * in compiling a Query down to a [Matcher](clownfish:class:Matcher) which
  * can actually match and score documents.
  */
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/QueryParser.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/QueryParser.cfh b/core/Lucy/Search/QueryParser.cfh
index 9b26736..2749147 100644
--- a/core/Lucy/Search/QueryParser.cfh
+++ b/core/Lucy/Search/QueryParser.cfh
@@ -19,9 +19,9 @@ parcel Lucy;
 /** Transform a string into a Query object.
  *
  * QueryParser accepts search strings as input and produces
- * [Query](clownfish:class:lucy:Query) objects, suitable for feeding into
- * [IndexSearcher](clownfish:class:lucy:IndexSearcher) and other
- * [Searcher](clownfish:class:lucy:Searcher) subclasses.
+ * [Query](clownfish:class:Query) objects, suitable for feeding into
+ * [IndexSearcher](clownfish:class:IndexSearcher) and other
+ * [Searcher](clownfish:class:Searcher) subclasses.
  *
  * The following syntactical constructs are recognized by QueryParser:
  *
@@ -57,8 +57,8 @@ public class Lucy::Search::QueryParser nickname QParser
 
     /** Constructor.
      *
-     * @param schema A [Schema](clownfish:class:lucy:Schema).
-     * @param analyzer An [Analyzer](clownfish:class:lucy:Analyzer).
+     * @param schema A [Schema](clownfish:class:Schema).
+     * @param analyzer An [Analyzer](clownfish:class:Analyzer).
      * Ordinarily, the analyzers specified by each field's definition will be
      * used, but if `analyzer` is supplied, it will override and be used for
      * all fields.  This can lead to mismatches between what is in the index

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/Searcher.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Searcher.cfh b/core/Lucy/Search/Searcher.cfh
index c491c36..f4aa257 100644
--- a/core/Lucy/Search/Searcher.cfh
+++ b/core/Lucy/Search/Searcher.cfh
@@ -19,8 +19,8 @@ parcel Lucy;
 /** Base class for searching collections of documents.
  *
  * Abstract base class for objects which search.  Core subclasses include
- * [IndexSearcher](clownfish:class:lucy:IndexSearcher) and
- * [PolySearcher](clownfish:class:lucy:PolySearcher).
+ * [IndexSearcher](clownfish:class:IndexSearcher) and
+ * [PolySearcher](clownfish:class:PolySearcher).
  */
 
 public class Lucy::Search::Searcher inherits Clownfish::Obj {
@@ -71,7 +71,7 @@ public class Lucy::Search::Searcher inherits Clownfish::Obj {
      * hits 21-30, assuming that 30 hits can be found.
      * @param num_wanted The number of hits you would like to see after
      * `offset` is taken into account.
-     * @param sort_spec A [SortSpec](clownfish:class:lucy:SortSpec), which will affect
+     * @param sort_spec A [SortSpec](clownfish:class:SortSpec), which will affect
      * how results are ranked and returned.
      */
     public incremented Hits*
@@ -79,7 +79,7 @@ public class Lucy::Search::Searcher inherits Clownfish::Obj {
          uint32_t num_wanted = 10, SortSpec *sort_spec = NULL);
 
     /** Iterate over hits, feeding them into a
-     * [Collector](clownfish:class:lucy:Collector).
+     * [Collector](clownfish:class:Collector).
      *
      * @param query A Query.
      * @param collector A Collector.

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/SortRule.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/SortRule.cfh b/core/Lucy/Search/SortRule.cfh
index 2b9eb70..080a87d 100644
--- a/core/Lucy/Search/SortRule.cfh
+++ b/core/Lucy/Search/SortRule.cfh
@@ -19,7 +19,7 @@ parcel Lucy;
 /** Element of a SortSpec.
  *
  * SortRules are the building blocks used to assemble
- * [SortSpecs](clownfish:class:lucy:SortSpec); each SortRule defines a single
+ * [SortSpecs](clownfish:class:SortSpec); each SortRule defines a single
  * level of sorting.  For example, sorting first by "category" then by score
  * requires a SortSpec with two SortRule elements.
  */

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/SortSpec.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/SortSpec.cfh b/core/Lucy/Search/SortSpec.cfh
index 954c4f0..2df63aa 100644
--- a/core/Lucy/Search/SortSpec.cfh
+++ b/core/Lucy/Search/SortSpec.cfh
@@ -20,7 +20,7 @@ parcel Lucy;
  *
  * By default, searches return results in order of relevance; SortSpec allows
  * you to indicate an alternate order via an array of
- * [SortRules](clownfish:class:lucy:SortRule).
+ * [SortRules](clownfish:class:SortRule).
  *
  * Fields you wish to sort against must be `sortable`.
  *

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Search/TermQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/TermQuery.cfh b/core/Lucy/Search/TermQuery.cfh
index 0558387..082acd2 100644
--- a/core/Lucy/Search/TermQuery.cfh
+++ b/core/Lucy/Search/TermQuery.cfh
@@ -19,7 +19,7 @@ parcel Lucy;
 
 /** Query which matches individual terms.
  *
- * TermQuery is a subclass of [Query](clownfish:class:lucy:Query) for matching
+ * TermQuery is a subclass of [Query](clownfish:class:Query) for matching
  * individual terms in a specific field.
  */
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Store/FSFolder.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/FSFolder.cfh b/core/Lucy/Store/FSFolder.cfh
index 337c38f..78b4948 100644
--- a/core/Lucy/Store/FSFolder.cfh
+++ b/core/Lucy/Store/FSFolder.cfh
@@ -18,7 +18,7 @@ parcel Lucy;
 
 /** File System implementation of Folder.
  *
- * Implementation of [Folder](clownfish:class:lucy:Folder) using a single file system
+ * Implementation of [Folder](clownfish:class:Folder) using a single file system
  * directory and multiple files.
  */
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Store/Folder.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/Folder.cfh b/core/Lucy/Store/Folder.cfh
index cbf2c65..030a981 100644
--- a/core/Lucy/Store/Folder.cfh
+++ b/core/Lucy/Store/Folder.cfh
@@ -23,7 +23,7 @@ parcel Lucy;
  * a key-value pair from a hash, or something else.
  *
  * The archetypal implementation of Folder,
- * [FSFolder](clownfish:class:lucy:FSFolder), represents a directory on
+ * [FSFolder](clownfish:class:FSFolder), represents a directory on
  * the file system holding a collection of files.
  */
 public abstract class Lucy::Store::Folder inherits Clownfish::Obj {

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Store/LockFactory.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/LockFactory.cfh b/core/Lucy/Store/LockFactory.cfh
index 3204d92..b96199d 100644
--- a/core/Lucy/Store/LockFactory.cfh
+++ b/core/Lucy/Store/LockFactory.cfh
@@ -34,7 +34,7 @@ public class Lucy::Store::LockFactory nickname LockFact
     new(Folder *folder, String *host);
 
     /**
-     * @param folder A [Folder](clownfish:class:lucy:Folder).
+     * @param folder A [Folder](clownfish:class:Folder).
      * @param host An identifier which should be unique per-machine.
      */
     public inert LockFactory*

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Store/RAMFolder.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/RAMFolder.cfh b/core/Lucy/Store/RAMFolder.cfh
index 5d2b562..731d414 100644
--- a/core/Lucy/Store/RAMFolder.cfh
+++ b/core/Lucy/Store/RAMFolder.cfh
@@ -19,7 +19,7 @@ parcel Lucy;
 /** In-memory Folder implementation.
  *
  * RAMFolder is an entirely in-memory implementation of
- * [Folder](clownfish:class:lucy:Folder), primarily used for testing and development.
+ * [Folder](clownfish:class:Folder), primarily used for testing and development.
  */
 
 public class Lucy::Store::RAMFolder inherits Lucy::Store::Folder {

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/Lucy/Store/SharedLock.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/SharedLock.cfh b/core/Lucy/Store/SharedLock.cfh
index 3ad6fb9..d8a8bc7 100644
--- a/core/Lucy/Store/SharedLock.cfh
+++ b/core/Lucy/Store/SharedLock.cfh
@@ -19,7 +19,7 @@ parcel Lucy;
 /** Shared (read) lock.
  *
  * SharedLock's interface is nearly identical to that of its parent class
- * [Lock](clownfish:class:lucy:Lock), taking the same constructor arguments and
+ * [Lock](clownfish:class:Lock), taking the same constructor arguments and
  * implementing the same list of methods.  It differs from Lock only in the
  * semantics of two methods.
  *

http://git-wip-us.apache.org/repos/asf/lucy/blob/60f2df8f/core/LucyX/Search/ProximityQuery.cfh
----------------------------------------------------------------------
diff --git a/core/LucyX/Search/ProximityQuery.cfh b/core/LucyX/Search/ProximityQuery.cfh
index 635873d..7e1eab3 100644
--- a/core/LucyX/Search/ProximityQuery.cfh
+++ b/core/LucyX/Search/ProximityQuery.cfh
@@ -18,7 +18,7 @@ parcel Lucy;
 
 /** Query matching an ordered list of terms.
  *
- * ProximityQuery is a subclass of [Query](clownfish:class:lucy:Query) for matching
+ * ProximityQuery is a subclass of [Query](clownfish:class:Query) for matching
  * against an ordered sequence of terms.
  */
 


[2/2] lucy git commit: Add clownfish URIs for methods

Posted by nw...@apache.org.
Add clownfish URIs for methods


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

Branch: refs/heads/markdown
Commit: 82d38667a204f4b0dc0f69151f3e54d59f1ec2dc
Parents: 60f2df8
Author: Nick Wellnhofer <we...@aevum.de>
Authored: Tue Dec 2 18:17:41 2014 +0100
Committer: Nick Wellnhofer <we...@aevum.de>
Committed: Tue Dec 2 18:46:09 2014 +0100

----------------------------------------------------------------------
 core/Lucy/Analysis/Analyzer.cfh              |  2 +-
 core/Lucy/Docs/FileLocking.cfh               |  6 +++---
 core/Lucy/Highlight/Highlighter.cfh          |  4 ++--
 core/Lucy/Index/BackgroundMerger.cfh         |  8 +++----
 core/Lucy/Index/DataWriter.cfh               |  2 +-
 core/Lucy/Index/IndexReader.cfh              |  2 +-
 core/Lucy/Index/Indexer.cfh                  | 24 ++++++++++-----------
 core/Lucy/Index/Inverter.cfh                 |  6 +++---
 core/Lucy/Index/Lexicon.cfh                  |  2 +-
 core/Lucy/Index/PolyReader.cfh               |  2 +-
 core/Lucy/Index/PostingList.cfh              |  2 +-
 core/Lucy/Index/PostingListReader.cfh        |  2 +-
 core/Lucy/Index/SegPostingList.cfh           |  2 +-
 core/Lucy/Index/SegWriter.cfh                | 12 +++++------
 core/Lucy/Index/Snapshot.cfh                 |  2 +-
 core/Lucy/Plan/Architecture.cfh              | 26 +++++++++++------------
 core/Lucy/Plan/FieldType.cfh                 |  2 +-
 core/Lucy/Plan/Schema.cfh                    |  2 +-
 core/Lucy/Search/Collector.cfh               |  8 +++----
 core/Lucy/Search/Collector/SortCollector.cfh |  2 +-
 core/Lucy/Search/Compiler.cfh                | 18 ++++++++--------
 core/Lucy/Search/LeafQuery.cfh               |  2 +-
 core/Lucy/Search/Matcher.cfh                 |  8 +++----
 core/Lucy/Search/ORMatcher.cfh               |  2 +-
 core/Lucy/Search/Query.cfh                   |  6 +++---
 core/Lucy/Search/QueryParser.cfh             | 20 ++++++++---------
 core/Lucy/Store/DirHandle.cfh                |  4 ++--
 core/Lucy/Store/FileHandle.cfh               |  2 +-
 core/Lucy/Store/Folder.cfh                   |  2 +-
 core/Lucy/Store/InStream.cfh                 |  4 ++--
 core/Lucy/Store/Lock.cfh                     | 12 +++++------
 core/Lucy/Store/LockFactory.cfh              | 10 ++++-----
 core/Lucy/Store/SharedLock.cfh               | 10 ++++-----
 core/Lucy/Test/Plan/TestArchitecture.cfh     |  2 +-
 core/Lucy/Test/TestSchema.cfh                |  2 +-
 core/Lucy/Util/Debug.cfh                     |  2 +-
 core/Lucy/Util/Freezer.cfh                   |  2 +-
 core/Lucy/Util/PriorityQueue.cfh             |  4 ++--
 core/Lucy/Util/SortExternal.cfh              | 16 +++++++-------
 core/Lucy/Util/Stepper.cfh                   |  4 ++--
 core/LucyX/Search/MockMatcher.cfh            |  2 +-
 41 files changed, 126 insertions(+), 126 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Analysis/Analyzer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/Analyzer.cfh b/core/Lucy/Analysis/Analyzer.cfh
index bbc9722..a9b868d 100644
--- a/core/Lucy/Analysis/Analyzer.cfh
+++ b/core/Lucy/Analysis/Analyzer.cfh
@@ -38,7 +38,7 @@ public abstract class Lucy::Analysis::Analyzer inherits Clownfish::Obj {
 
     /** Kick off an analysis chain, creating an Inversion from string input.
      * The default implementation simply creates an initial Inversion with a
-     * single Token, then calls Transform(), but occasionally subclasses will
+     * single Token, then calls [Transform()](clownfish:method:Transform), but occasionally subclasses will
      * provide an optimized implementation which minimizes string copies.
      */
     public incremented Inversion*

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Docs/FileLocking.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Docs/FileLocking.cfh b/core/Lucy/Docs/FileLocking.cfh
index 0192c71..5536477 100644
--- a/core/Lucy/Docs/FileLocking.cfh
+++ b/core/Lucy/Docs/FileLocking.cfh
@@ -39,7 +39,7 @@ parcel Lucy;
  * complex.
  *
  * Once an index file is no longer listed in the most recent snapshot, Indexer
- * attempts to delete it as part of a post-Commit() cleanup routine.  It is
+ * attempts to delete it as part of a post-[Commit()](clownfish:method:Indexer:Commit) cleanup routine.  It is
  * possible that at the moment an Indexer is deleting files which it believes
  * no longer needed, a Searcher referencing an earlier snapshot is in fact
  * using them.  The more often that an index is either updated or searched,
@@ -61,9 +61,9 @@ parcel Lucy;
  *
  * Under normal circumstances, it is neither necessary nor desirable for
  * IndexReaders to secure read locks against an index, but for NFS we have to
- * make an exception.  LockFactory's Make_Shared_Lock() method exists for this
+ * make an exception.  LockFactory's [Make_Shared_Lock()](clownfish:method:LockFactory:Make_Shared_Lock) method exists for this
  * reason; supplying an IndexManager instance to IndexReader's constructor
- * activates an internal locking mechanism using Make_Shared_Lock() which
+ * activates an internal locking mechanism using [Make_Shared_Lock()](clownfish:method:LockFactory:Make_Shared_Lock) which
  * prevents concurrent indexing processes from deleting files that are needed
  * by active readers.
  *

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Highlight/Highlighter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Highlight/Highlighter.cfh b/core/Lucy/Highlight/Highlighter.cfh
index 15b41ae..fef2656 100644
--- a/core/Lucy/Highlight/Highlighter.cfh
+++ b/core/Lucy/Highlight/Highlighter.cfh
@@ -59,7 +59,7 @@ public class Lucy::Highlight::Highlighter inherits Clownfish::Obj {
     Create_Excerpt(Highlighter *self, HitDoc *hit_doc);
 
     /** Encode text with HTML entities. This method is called internally by
-     * Create_Excerpt() for each text fragment when assembling an excerpt.  A
+     * [Create_Excerpt()](clownfish:method:Create_Excerpt) for each text fragment when assembling an excerpt.  A
      * subclass can override this if the text should be encoded differently or
      * not at all.
      */
@@ -67,7 +67,7 @@ public class Lucy::Highlight::Highlighter inherits Clownfish::Obj {
     Encode(Highlighter *self, String *text);
 
     /** Highlight a small section of text.  By default, prepends pre-tag and
-     * appends post-tag.  This method is called internally by Create_Excerpt()
+     * appends post-tag.  This method is called internally by [Create_Excerpt()](clownfish:method:Create_Excerpt)
      * when assembling an excerpt.
      */
     public incremented String*

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/BackgroundMerger.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/BackgroundMerger.cfh b/core/Lucy/Index/BackgroundMerger.cfh
index 4e1def8..b281f37 100644
--- a/core/Lucy/Index/BackgroundMerger.cfh
+++ b/core/Lucy/Index/BackgroundMerger.cfh
@@ -68,16 +68,16 @@ public class Lucy::Index::BackgroundMerger nickname BGMerger
     /** Commit any changes made to the index.  Until this is called, none of
      * the changes made during an indexing session are permanent.
      *
-     * Calls Prepare_Commit() implicitly if it has not already been called.
+     * Calls [Prepare_Commit()](clownfish:method:Prepare_Commit) implicitly if it has not already been called.
      */
     public void
     Commit(BackgroundMerger *self);
 
-    /** Perform the expensive setup for Commit() in advance, so that Commit()
+    /** Perform the expensive setup for [Commit()](clownfish:method:Commit) in advance, so that [Commit()](clownfish:method:Commit)
      * completes quickly.
      *
-     * Towards the end of Prepare_Commit(), the BackgroundMerger attempts to
-     * re-acquire the write lock, which is then held until Commit() finishes
+     * Towards the end of [Prepare_Commit()](clownfish:method:Prepare_Commit), the BackgroundMerger attempts to
+     * re-acquire the write lock, which is then held until [Commit()](clownfish:method:Commit) finishes
      * and releases it.
      */
     public void

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/DataWriter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DataWriter.cfh b/core/Lucy/Index/DataWriter.cfh
index 2e7586f..26e6033 100644
--- a/core/Lucy/Index/DataWriter.cfh
+++ b/core/Lucy/Index/DataWriter.cfh
@@ -83,7 +83,7 @@ public class Lucy::Index::DataWriter inherits Clownfish::Obj {
     /** Move content from an existing segment into the one currently being
      * written.
      *
-     * The default implementation calls Add_Segment() then Delete_Segment().
+     * The default implementation calls [Add_Segment()](clownfish:method:Add_Segment) then [Delete_Segment()](clownfish:method:Delete_Segment).
      *
      * @param reader The SegReader containing content to merge, which must
      * represent a segment which is part of the the current snapshot.

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/IndexReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/IndexReader.cfh b/core/Lucy/Index/IndexReader.cfh
index aa08e2b..10e7957 100644
--- a/core/Lucy/Index/IndexReader.cfh
+++ b/core/Lucy/Index/IndexReader.cfh
@@ -29,7 +29,7 @@ parcel Lucy;
  *
  * IndexReaders are composites; most of the work is done by individual
  * [DataReader](clownfish:class:DataReader) sub-components, which may be
- * accessed via Fetch() and Obtain().  The most efficient and powerful access
+ * accessed via [Fetch()](clownfish:method:Fetch) and [Obtain()](clownfish:method:Obtain).  The most efficient and powerful access
  * to index data happens at the segment level via
  * [SegReader](clownfish:class:SegReader)'s sub-components.
  */

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/Indexer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/Indexer.cfh b/core/Lucy/Index/Indexer.cfh
index 98eec00..4ac2441 100644
--- a/core/Lucy/Index/Indexer.cfh
+++ b/core/Lucy/Index/Indexer.cfh
@@ -31,7 +31,7 @@ parcel Lucy;
  * `host` id to Indexer's constructor or index corruption will
  * occur.  See L<Lucy::Docs::FileLocking> for a detailed discussion.
  *
- * Note: at present, Delete_By_Term() and Delete_By_Query() only affect
+ * Note: at present, [Delete_By_Term()](clownfish:method:Delete_By_Term) and [Delete_By_Query()](clownfish:method:Delete_By_Query) only affect
  * documents which had been previously committed to the index -- and not any
  * documents added this indexing session but not yet committed.  This may
  * change in a future update.
@@ -94,7 +94,7 @@ public class Lucy::Index::Indexer inherits Clownfish::Obj {
     /** Mark documents which contain the supplied term as deleted, so that
      * they will be excluded from search results and eventually removed
      * altogether.  The change is not apparent to search apps until after
-     * Commit() succeeds.
+     * [Commit()](clownfish:method:Commit) succeeds.
      *
      * @param field The name of an indexed field. (If it is not spec'd as
      * `indexed`, an error will occur.)
@@ -123,20 +123,20 @@ public class Lucy::Index::Indexer inherits Clownfish::Obj {
      * while, as it can involve rewriting large amounts of data.
      *
      * Every Indexer session which changes index content and ends in a
-     * Commit() creates a new segment.  Once written, segments are never
+     * [Commit()](clownfish:method:Commit) creates a new segment.  Once written, segments are never
      * modified.  However, they are periodically recycled by feeding their
      * content into the segment currently being written.
      *
-     * The Optimize() method causes all existing index content to be fed back
-     * into the Indexer.  When Commit() completes after an Optimize(), the
-     * index will consist of one segment.  So Optimize() must be called
-     * before Commit().  Also, optimizing a fresh index created from scratch
+     * The [Optimize()](clownfish:method:Optimize) method causes all existing index content to be fed back
+     * into the Indexer.  When [Commit()](clownfish:method:Commit) completes after an [Optimize()](clownfish:method:Optimize), the
+     * index will consist of one segment.  So [Optimize()](clownfish:method:Optimize) must be called
+     * before [Commit()](clownfish:method:Commit).  Also, optimizing a fresh index created from scratch
      * has no effect.
      *
      * Historically, there was a significant search-time performance benefit
      * to collapsing down to a single segment versus even two segments.  Now
      * the effect of collapsing is much less significant, and calling
-     * Optimize() is rarely justified.
+     * [Optimize()](clownfish:method:Optimize) is rarely justified.
      */
     public void
     Optimize(Indexer *self);
@@ -144,15 +144,15 @@ public class Lucy::Index::Indexer inherits Clownfish::Obj {
     /** Commit any changes made to the index.  Until this is called, none of
      * the changes made during an indexing session are permanent.
      *
-     * Calling Commit() invalidates the Indexer, so if you want to make more
+     * Calling [Commit()](clownfish:method:Commit) invalidates the Indexer, so if you want to make more
      * changes you'll need a new one.
      */
     public void
     Commit(Indexer *self);
 
-    /** Perform the expensive setup for Commit() in advance, so that Commit()
-     * completes quickly.  (If Prepare_Commit() is not called explicitly by
-     * the user, Commit() will call it internally.)
+    /** Perform the expensive setup for [Commit()](clownfish:method:Commit) in advance, so that [Commit()](clownfish:method:Commit)
+     * completes quickly.  (If [Prepare_Commit()](clownfish:method:Prepare_Commit) is not called explicitly by
+     * the user, [Commit()](clownfish:method:Commit) will call it internally.)
      */
     public void
     Prepare_Commit(Indexer *self);

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/Inverter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/Inverter.cfh b/core/Lucy/Index/Inverter.cfh
index 7858a0a..f635443 100644
--- a/core/Lucy/Index/Inverter.cfh
+++ b/core/Lucy/Index/Inverter.cfh
@@ -42,13 +42,13 @@ class Lucy::Index::Inverter inherits Clownfish::Obj {
     inert Inverter*
     init(Inverter *self, Schema *schema, Segment *segment);
 
-    /** Invert the document, first calling Set_Doc(), then Add_Field() for
+    /** Invert the document, first calling [Set_Doc()](clownfish:method:Set_Doc), then [Add_Field()](clownfish:method:Add_Field) for
      * each field in the Doc.
      */
     public void
     Invert_Doc(Inverter *self, Doc *doc);
 
-    /** Set the object's `doc` member.  Calls Clear() as side
+    /** Set the object's `doc` member.  Calls [Clear()](clownfish:method:Clear) as side
      * effect.
      */
     public void
@@ -63,7 +63,7 @@ class Lucy::Index::Inverter inherits Clownfish::Obj {
      * it.
      *
      * The InverterEntry's value should have already been set to the field's
-     * value when Add_Field() is called.
+     * value when [Add_Field()](clownfish:method:Add_Field) is called.
      */
     void
     Add_Field(Inverter *self, InverterEntry *entry);

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/Lexicon.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/Lexicon.cfh b/core/Lucy/Index/Lexicon.cfh
index 16058c1..e14d71f 100644
--- a/core/Lucy/Index/Lexicon.cfh
+++ b/core/Lucy/Index/Lexicon.cfh
@@ -55,7 +55,7 @@ public class Lucy::Index::Lexicon nickname Lex inherits Clownfish::Obj {
     public abstract bool
     Next(Lexicon *self);
 
-    /** Reset the iterator.  Next() must be called to proceed to the first
+    /** Reset the iterator.  [Next()](clownfish:method:Next) must be called to proceed to the first
      * element.
      */
     public abstract void

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/PolyReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/PolyReader.cfh b/core/Lucy/Index/PolyReader.cfh
index 5eda742..8418640 100644
--- a/core/Lucy/Index/PolyReader.cfh
+++ b/core/Lucy/Index/PolyReader.cfh
@@ -20,7 +20,7 @@ parcel Lucy;
  *
  * PolyReader conflates index data from multiple segments.  For instance, if
  * an index contains three segments with 10 documents each, PolyReader's
- * Doc_Max() method will return 30.
+ * [Doc_Max()](clownfish:method:Doc_Max) method will return 30.
  *
  * Some of PolyReader's [DataReader](clownfish:class:DataReader) components
  * may be less efficient or complete than the single-segment implementations

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/PostingList.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/PostingList.cfh b/core/Lucy/Index/PostingList.cfh
index 702db7c..3bd7352 100644
--- a/core/Lucy/Index/PostingList.cfh
+++ b/core/Lucy/Index/PostingList.cfh
@@ -54,7 +54,7 @@ public class Lucy::Index::PostingList nickname PList
     abstract void
     Seek_Lex(PostingList *self, Lexicon *lexicon);
 
-    /** Invoke Post_Make_Matcher() for this PostingList's posting.
+    /** Invoke [Post_Make_Matcher()](clownfish:method:Post_Make_Matcher) for this PostingList's posting.
      */
     abstract Matcher*
     Make_Matcher(PostingList *self, Similarity *similarity,

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/PostingListReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/PostingListReader.cfh b/core/Lucy/Index/PostingListReader.cfh
index 6474aeb..b2ab868 100644
--- a/core/Lucy/Index/PostingListReader.cfh
+++ b/core/Lucy/Index/PostingListReader.cfh
@@ -34,7 +34,7 @@ public class Lucy::Index::PostingListReader nickname PListReader
      *
      * @param field A field name.
      * @param term If supplied, the PostingList will be pre-located to this
-     * term using Seek().
+     * term using [Seek()](clownfish:method:PostingList:Seek).
      */
     public abstract incremented nullable PostingList*
     Posting_List(PostingListReader *self, String *field = NULL,

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/SegPostingList.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/SegPostingList.cfh b/core/Lucy/Index/SegPostingList.cfh
index bf2cc3f..9a81c30 100644
--- a/core/Lucy/Index/SegPostingList.cfh
+++ b/core/Lucy/Index/SegPostingList.cfh
@@ -69,7 +69,7 @@ class Lucy::Index::SegPostingList nickname SegPList
     public void
     Seek(SegPostingList *self, Obj *target = NULL);
 
-    /** Optimized version of Seek(), designed to speed sequential access.
+    /** Optimized version of [Seek()](clownfish:method:Seek), designed to speed sequential access.
      */
     void
     Seek_Lex(SegPostingList *self, Lexicon *lexicon);

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/SegWriter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/SegWriter.cfh b/core/Lucy/Index/SegWriter.cfh
index 16f784b..07d96d7 100644
--- a/core/Lucy/Index/SegWriter.cfh
+++ b/core/Lucy/Index/SegWriter.cfh
@@ -27,9 +27,9 @@ parcel Lucy;
  *
  * The sub-components of a SegWriter are determined by
  * [Architecture](clownfish:class:Architecture).  DataWriter components
- * which are added to the stack of writers via Add_Writer() have
- * Add_Inverted_Doc() invoked for each document supplied to SegWriter's
- * Add_Doc().
+ * which are added to the stack of writers via [Add_Writer()](clownfish:method:Add_Writer) have
+ * [Add_Inverted_Doc()](clownfish:method:Add_Inverted_Doc) invoked for each document supplied to SegWriter's
+ * [Add_Doc()](clownfish:method:Add_Doc).
  */
 public class Lucy::Index::SegWriter inherits Lucy::Index::DataWriter {
 
@@ -57,8 +57,8 @@ public class Lucy::Index::SegWriter inherits Lucy::Index::DataWriter {
 
     /**
      * Register a DataWriter component with the SegWriter.  (Note that
-     * registration simply makes the writer available via Fetch(), so you may
-     * also want to call Add_Writer()).
+     * registration simply makes the writer available via [Fetch()](clownfish:method:Fetch), so you may
+     * also want to call [Add_Writer()](clownfish:method:Add_Writer)).
      *
      * @param api The name of the DataWriter api which `writer`
      * implements.
@@ -89,7 +89,7 @@ public class Lucy::Index::SegWriter inherits Lucy::Index::DataWriter {
     Prep_Seg_Dir(SegWriter *self);
 
     /** Add a document to the segment.  Inverts `doc`, increments
-     * the Segment's internal document id, then calls Add_Inverted_Doc(),
+     * the Segment's internal document id, then calls [Add_Inverted_Doc()](clownfish:method:Add_Inverted_Doc),
      * feeding all sub-writers.
      */
     public void

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/Snapshot.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/Snapshot.cfh b/core/Lucy/Index/Snapshot.cfh
index 634be2c..f0c1bd9 100644
--- a/core/Lucy/Index/Snapshot.cfh
+++ b/core/Lucy/Index/Snapshot.cfh
@@ -95,7 +95,7 @@ public class Lucy::Index::Snapshot inherits Clownfish::Obj {
     Set_Path(Snapshot *self, String *path);
 
     /** Get the path to the snapshot file.  Initially NULL; updated by
-     * Read_File(), Write_File(), and Set_Path().
+     * [Read_File()](clownfish:method:Read_File), [Write_File()](clownfish:method:Write_File), and [Set_Path()](clownfish:method:Set_Path).
      */
     public nullable String*
     Get_Path(Snapshot *self);

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Plan/Architecture.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Plan/Architecture.cfh b/core/Lucy/Plan/Architecture.cfh
index 3162daa..34cefb8 100644
--- a/core/Lucy/Plan/Architecture.cfh
+++ b/core/Lucy/Plan/Architecture.cfh
@@ -42,7 +42,7 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj {
     public void
     Init_Seg_Writer(Architecture *self, SegWriter *writer);
 
-    /** Spawn a LexiconWriter and Register() it with the supplied SegWriter,
+    /** Spawn a LexiconWriter and [Register()](clownfish:method:SegWriter:Register) it with the supplied SegWriter,
      * but don't add it to the SegWriter's writer stack.
      *
      * @param writer A SegWriter.
@@ -50,7 +50,7 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj {
     public void
     Register_Lexicon_Writer(Architecture *self, SegWriter *writer);
 
-    /** Spawn a PostingListWriter and Register() it with the supplied
+    /** Spawn a PostingListWriter and [Register()](clownfish:method:SegWriter:Register) it with the supplied
      * SegWriter, adding it to the SegWriter's writer stack.  The SegWriter
      * must contain a previously registered LexiconWriter.
      *
@@ -59,7 +59,7 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj {
     public void
     Register_Posting_List_Writer(Architecture *self, SegWriter *writer);
 
-    /** Spawn a DataWriter and Register() it with the supplied SegWriter,
+    /** Spawn a DataWriter and [Register()](clownfish:method:SegWriter:Register) it with the supplied SegWriter,
      * adding it to the SegWriter's writer stack.
      *
      * @param writer A SegWriter.
@@ -67,7 +67,7 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj {
     public void
     Register_Doc_Writer(Architecture *self, SegWriter *writer);
 
-    /** Spawn a SortWriter and Register() it with the supplied SegWriter,
+    /** Spawn a SortWriter and [Register()](clownfish:method:SegWriter:Register) it with the supplied SegWriter,
      * adding it to the SegWriter's writer stack.
      *
      * @param writer A SegWriter.
@@ -75,7 +75,7 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj {
     public void
     Register_Sort_Writer(Architecture *self, SegWriter *writer);
 
-    /** Spawn a HighlightWriter and Register() it with the supplied SegWriter,
+    /** Spawn a HighlightWriter and [Register()](clownfish:method:SegWriter:Register) it with the supplied SegWriter,
      * adding it to the SegWriter's writer stack.
      *
      * @param writer A SegWriter.
@@ -83,8 +83,8 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj {
     public void
     Register_Highlight_Writer(Architecture *self, SegWriter *writer);
 
-    /** Spawn a DeletionsWriter and Register() it with the supplied SegWriter,
-     * also calling Set_Del_Writer().
+    /** Spawn a DeletionsWriter and [Register()](clownfish:method:SegWriter:Register) it with the supplied SegWriter,
+     * also calling [Set_Del_Writer()](clownfish:method:SegWriter:Set_Del_Writer).
      *
      * @param writer A SegWriter.
      */
@@ -96,28 +96,28 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj {
     public void
     Init_Seg_Reader(Architecture *self, SegReader *reader);
 
-    /** Spawn a DocReader and Register() it with the supplied SegReader.
+    /** Spawn a DocReader and [Register()](clownfish:method:SegReader:Register) it with the supplied SegReader.
      *
      * @param reader A SegReader.
      */
     public void
     Register_Doc_Reader(Architecture *self, SegReader *reader);
 
-    /** Spawn a PostingListReader and Register() it with the supplied SegReader.
+    /** Spawn a PostingListReader and [Register()](clownfish:method:SegReader:Register) it with the supplied SegReader.
      *
      * @param reader A SegReader.
      */
     public void
     Register_Posting_List_Reader(Architecture *self, SegReader *reader);
 
-    /** Spawn a SortReader and Register() it with the supplied SegReader.
+    /** Spawn a SortReader and [Register()](clownfish:method:SegReader:Register) it with the supplied SegReader.
      *
      * @param reader A SegReader.
      */
     public void
     Register_Sort_Reader(Architecture *self, SegReader *reader);
 
-    /** Spawn a HighlightReader and Register() it with the supplied
+    /** Spawn a HighlightReader and [Register()](clownfish:method:SegReader:Register) it with the supplied
      * SegReader.
      *
      * @param reader A SegReader.
@@ -125,14 +125,14 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj {
     public void
     Register_Highlight_Reader(Architecture *self, SegReader *reader);
 
-    /** Spawn a LexiconReader and Register() it with the supplied SegReader.
+    /** Spawn a LexiconReader and [Register()](clownfish:method:SegReader:Register) it with the supplied SegReader.
      *
      * @param reader A SegReader.
      */
     public void
     Register_Lexicon_Reader(Architecture *self, SegReader *reader);
 
-    /** Spawn a DeletionsReader and Register() it with the supplied SegReader.
+    /** Spawn a DeletionsReader and [Register()](clownfish:method:SegReader:Register) it with the supplied SegReader.
      *
      * @param reader A SegReader.
      */

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Plan/FieldType.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Plan/FieldType.cfh b/core/Lucy/Plan/FieldType.cfh
index 1c0880e..7da470b 100644
--- a/core/Lucy/Plan/FieldType.cfh
+++ b/core/Lucy/Plan/FieldType.cfh
@@ -130,7 +130,7 @@ public abstract class Lucy::Plan::FieldType nickname FType
     Binary(FieldType *self);
 
     /** Compare two values for the field.  The default implementation
-     * dispatches to the Compare_To() method of argument `a`.
+     * dispatches to the [Compare_To()](clownfish:method:Compare_To) method of argument `a`.
      *
      * @return a negative number if a is "less than" b, 0 if they are "equal",
      * and a positive number if a is "greater than" b.

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Plan/Schema.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Plan/Schema.cfh b/core/Lucy/Plan/Schema.cfh
index 6d00eac..017ac7f 100644
--- a/core/Lucy/Plan/Schema.cfh
+++ b/core/Lucy/Plan/Schema.cfh
@@ -51,7 +51,7 @@ public class Lucy::Plan::Schema inherits Clownfish::Obj {
      *
      * If this method has already been called for the supplied
      * `field`, it will merely test to verify that the supplied
-     * FieldType Equals() the existing one.
+     * FieldType [Equals()](clownfish:method:Equals) the existing one.
      *
      * @param name The name of the field.
      * @param type A FieldType.

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Search/Collector.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Collector.cfh b/core/Lucy/Search/Collector.cfh
index b15f2e0..b260bd3 100644
--- a/core/Lucy/Search/Collector.cfh
+++ b/core/Lucy/Search/Collector.cfh
@@ -20,11 +20,11 @@ parcel Lucy;
  *
  * A Collector decides what to do with the hits that a
  * [Matcher](clownfish:class:Matcher) iterates through, based on how the
- * abstract Collect() method is implemented.
+ * abstract [Collect()](clownfish:method:Collect) method is implemented.
  *
  * Collectors operate on individual segments, but must operate within the
  * context of a larger collection.  Each time the collector moves to a new
- * segment, Set_Reader(), Set_Base() and Set_Matcher() will be called, and the
+ * segment, [Set_Reader()](clownfish:method:Set_Reader), [Set_Base()](clownfish:method:Set_Base) and [Set_Matcher()](clownfish:method:Set_Matcher) will be called, and the
  * collector must take the updated information into account.
  */
 
@@ -57,13 +57,13 @@ public abstract class Lucy::Search::Collector nickname Coll
     Set_Reader(Collector *self, SegReader *reader);
 
     /** Set the "base" document id, an offset which must be added to the
-     * `doc_id` supplied via Collect() to get the doc id for the
+     * `doc_id` supplied via [Collect()](clownfish:method:Collect) to get the doc id for the
      * larger index.
      */
     public void
     Set_Base(Collector *self, int32_t base);
 
-    /** Indicate whether the Collector will call Score() on its Matcher.
+    /** Indicate whether the Collector will call [Score()](clownfish:method:Matcher:Score) on its Matcher.
      */
     public abstract bool
     Need_Score(Collector *self);

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Search/Collector/SortCollector.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Collector/SortCollector.cfh b/core/Lucy/Search/Collector/SortCollector.cfh
index 2df7bb4..88757d0 100644
--- a/core/Lucy/Search/Collector/SortCollector.cfh
+++ b/core/Lucy/Search/Collector/SortCollector.cfh
@@ -66,7 +66,7 @@ class Lucy::Search::Collector::SortCollector nickname SortColl
     Pop_Match_Docs(SortCollector *self);
 
     /** Accessor for "total_hits" member, which tracks the number of times
-     * that Collect() was called.
+     * that [Collect()](clownfish:method:Collect) was called.
      */
     uint32_t
     Get_Total_Hits(SortCollector *self);

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Search/Compiler.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Compiler.cfh b/core/Lucy/Search/Compiler.cfh
index eb260af..cab0286 100644
--- a/core/Lucy/Search/Compiler.cfh
+++ b/core/Lucy/Search/Compiler.cfh
@@ -23,15 +23,15 @@ parcel Lucy;
  * [Matcher](clownfish:class:Matcher) object that can do real work.
  *
  * The simplest Compiler subclasses -- such as those associated with
- * constant-scoring Query types -- might simply implement a Make_Matcher()
+ * constant-scoring Query types -- might simply implement a [Make_Matcher()](clownfish:method:Make_Matcher)
  * method which passes along information verbatim from the Query to the
  * Matcher's constructor.
  *
  * However it is common for the Compiler to perform some calculations which
  * affect it's "weight" -- a floating point multiplier that the Matcher will
  * factor into each document's score.  If that is the case, then the Compiler
- * subclass may wish to override Get_Weight(), Sum_Of_Squared_Weights(), and
- * Apply_Norm_Factor().
+ * subclass may wish to override [Get_Weight()](clownfish:method:Get_Weight), [Sum_Of_Squared_Weights()](clownfish:method:Sum_Of_Squared_Weights), and
+ * [Apply_Norm_Factor()](clownfish:method:Apply_Norm_Factor).
  *
  * Compiling a Matcher is a two stage process.
  *
@@ -45,7 +45,7 @@ parcel Lucy;
  * TF/IDF weighting algorithm to adjust the Compiler's weight; custom
  * subclasses might do something similar.
  *
- * The second stage of compilation is Make_Matcher(), method, which is where
+ * The second stage of compilation is [Make_Matcher()](clownfish:method:Make_Matcher), method, which is where
  * the Compiler meets a [SegReader](clownfish:class:SegReader) object.
  * SegReaders are associated with a single segment within a single index on a
  * single machine, and are thus lower-level than Searchers, which may
@@ -54,7 +54,7 @@ parcel Lucy;
  * use new information supplied by the SegReader -- such as whether a term is
  * missing from the local index even though it is present within the larger
  * collection represented by the Searcher -- when figuring out what to feed to
- * the Matchers's constructor, or whether Make_Matcher() should return a
+ * the Matchers's constructor, or whether [Make_Matcher()](clownfish:method:Make_Matcher) should return a
  * Matcher at all.
  */
 public class Lucy::Search::Compiler inherits Lucy::Search::Query {
@@ -78,7 +78,7 @@ public class Lucy::Search::Compiler inherits Lucy::Search::Query {
     /** Factory method returning a Matcher.
      *
      * @param reader A SegReader.
-     * @param need_score Indicate whether the Matcher must implement Score().
+     * @param need_score Indicate whether the Matcher must implement [Score()](clownfish:method:Matcher:Score).
      * @return a Matcher, or NULL if the Matcher would have matched no
      * documents.
      */
@@ -102,7 +102,7 @@ public class Lucy::Search::Compiler inherits Lucy::Search::Query {
     Get_Parent(Compiler *self);
 
     /** Compute and return a raw weighting factor.  (This quantity is used by
-     * Normalize()).  By default, simply returns 1.0.
+     * [Normalize()](clownfish:method:Normalize)).  By default, simply returns 1.0.
      */
     public float
     Sum_Of_Squared_Weights(Compiler *self);
@@ -122,13 +122,13 @@ public class Lucy::Search::Compiler inherits Lucy::Search::Query {
 
     /**  Take a newly minted Compiler object and apply query-specific
      * normalization factors.  Should be invoked by Query subclasses during
-     * Make_Compiler() for top-level nodes.
+     * [Make_Compiler()](clownfish:method:Make_Compiler) for top-level nodes.
      *
      * For a TermQuery, the scoring formula is approximately:
      *
      *     (tf_d * idf_t / norm_d) * (tf_q * idf_t / norm_q)
      *
-     * Normalize() is theoretically concerned with applying the second half of
+     * [Normalize()](clownfish:method:Normalize) is theoretically concerned with applying the second half of
      * that formula to a the Compiler's weight. What actually happens depends
      * on how the Compiler and Similarity methods called internally are
      * implemented.

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Search/LeafQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/LeafQuery.cfh b/core/Lucy/Search/LeafQuery.cfh
index 1d6db24..586e407 100644
--- a/core/Lucy/Search/LeafQuery.cfh
+++ b/core/Lucy/Search/LeafQuery.cfh
@@ -19,7 +19,7 @@ parcel Lucy;
 /** Leaf node in a tree created by QueryParser.
  *
  * LeafQuery objects serve as leaf nodes in the tree structure generated by
- * [QueryParser](clownfish:class:QueryParser)'s Tree() method.
+ * [QueryParser](clownfish:class:QueryParser)'s [Tree()](clownfish:method:QueryParser:Tree) method.
  * Ultimately, they must be transformed, typically into either
  * [TermQuery](clownfish:class:TermQuery) or
  * [PhraseQuery](clownfish:class:PhraseQuery) objects, as attempting to

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Search/Matcher.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Matcher.cfh b/core/Lucy/Search/Matcher.cfh
index 3d242b5..3bd1d4c 100644
--- a/core/Lucy/Search/Matcher.cfh
+++ b/core/Lucy/Search/Matcher.cfh
@@ -19,7 +19,7 @@ parcel Lucy;
 /** Match a set of document ids.
  *
  * A Matcher iterates over a set of ascending document ids.  Some Matchers
- * implement Score() and can assign relevance scores to the docs that they
+ * implement [Score()](clownfish:method:Score) and can assign relevance scores to the docs that they
  * match.  Other implementations may be match-only.
  */
 
@@ -38,7 +38,7 @@ public abstract class Lucy::Search::Matcher inherits Clownfish::Obj {
     Next(Matcher *self);
 
     /** Advance the iterator to the first doc id greater than or equal to
-     * `target`. The default implementation simply calls Next()
+     * `target`. The default implementation simply calls [Next()](clownfish:method:Next)
      * over and over, but subclasses have the option of doing something more
      * efficient.
      *
@@ -50,14 +50,14 @@ public abstract class Lucy::Search::Matcher inherits Clownfish::Obj {
     Advance(Matcher *self, int32_t target);
 
     /** Return the current doc id.  Valid only after a successful call to
-     * Next() or Advance() and must not be called otherwise.
+     * [Next()](clownfish:method:Next) or [Advance()](clownfish:method:Advance) and must not be called otherwise.
      */
     public abstract int32_t
     Get_Doc_ID(Matcher *self);
 
     /** Return the score of the current document.
      *
-     * Only Matchers which are used for scored search need implement Score().
+     * Only Matchers which are used for scored search need implement [Score()](clownfish:method:Score).
      */
     public abstract float
     Score(Matcher *self);

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Search/ORMatcher.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/ORMatcher.cfh b/core/Lucy/Search/ORMatcher.cfh
index 51bb8d8..a97d29b 100644
--- a/core/Lucy/Search/ORMatcher.cfh
+++ b/core/Lucy/Search/ORMatcher.cfh
@@ -19,7 +19,7 @@ parcel Lucy;
 __C__
 #include "Lucy/Search/Matcher.h"
 
-/* A wrapper for a Matcher which caches the result of Matcher_Get_Doc_ID().
+/* A wrapper for a Matcher which caches the result of [Matcher_Get_Doc_ID()](clownfish:method:Matcher_Get_Doc_ID).
  */
 typedef struct lucy_HeapedMatcherDoc {
     lucy_Matcher *matcher;

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Search/Query.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Query.cfh b/core/Lucy/Search/Query.cfh
index 523ae1b..56a7aa5 100644
--- a/core/Lucy/Search/Query.cfh
+++ b/core/Lucy/Search/Query.cfh
@@ -23,13 +23,13 @@ parcel Lucy;
  *
  * The most common way to generate Query objects is to feed a search string
  * such as 'foo AND bar' to a [QueryParser's](clownfish:class:QueryParser)
- * Parse() method, which outputs an abstract syntax tree built up from various
+ * [Parse()](clownfish:method:QueryParser:Parse) method, which outputs an abstract syntax tree built up from various
  * Query subclasses such as [ANDQuery](clownfish:class:ANDQuery) and
  * [TermQuery](clownfish:class:TermQuery).  However, it is also possible
  * to use custom Query objects to build a search specification which cannot be
  * easily represented using a search string.
  *
- * Subclasses of Query must implement Make_Compiler(), which is the first step
+ * Subclasses of Query must implement [Make_Compiler()](clownfish:method:Make_Compiler), which is the first step
  * in compiling a Query down to a [Matcher](clownfish:class:Matcher) which
  * can actually match and score documents.
  */
@@ -54,7 +54,7 @@ public class Lucy::Search::Query inherits Clownfish::Obj {
      * @param boost A scoring multiplier.
      * @param subordinate Indicates whether the Query is a subquery (as
      * opposed to a top-level query).  If false, the implementation must
-     * invoke Normalize() on the newly minted Compiler object before returning
+     * invoke [Normalize()](clownfish:method:Compiler:Normalize) on the newly minted Compiler object before returning
      * it.
      */
     public abstract incremented Compiler*

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Search/QueryParser.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/QueryParser.cfh b/core/Lucy/Search/QueryParser.cfh
index 2749147..4fcd3d2 100644
--- a/core/Lucy/Search/QueryParser.cfh
+++ b/core/Lucy/Search/QueryParser.cfh
@@ -32,7 +32,7 @@ parcel Lucy;
  * * Logical groups, delimited by parentheses.
  * * Phrases, delimited by double quotes.
  *
- * Additionally, the following syntax can be enabled via Set_Heed_Colons():
+ * Additionally, the following syntax can be enabled via [Set_Heed_Colons()](clownfish:method:Set_Heed_Colons):
  *
  * * Field-specific constructs, in the form of 'fieldname:termtext' or
  *   'fieldname:(foo bar)'.  (The field specified by 'fieldname:' will be
@@ -76,7 +76,7 @@ public class Lucy::Search::QueryParser nickname QParser
         String *default_boolop = NULL, VArray *fields = NULL);
 
     /** Build a Query object from the contents of a query string.  At present,
-     * implemented internally by calling Tree(), Expand(), and Prune().
+     * implemented internally by calling [Tree()](clownfish:method:Tree), [Expand()](clownfish:method:Expand), and [Prune()](clownfish:method:Prune).
      *
      * @param query_string The string to be parsed.  May be NULL.
      * @return a Query.
@@ -90,8 +90,8 @@ public class Lucy::Search::QueryParser nickname QParser
      * well.  Internal nodes will be objects which subclass PolyQuery:
      * ANDQuery, ORQuery, NOTQuery, and RequiredOptionalQuery.
      *
-     * The output of Tree() is an intermediate form which must be passed
-     * through Expand() before being used to feed a search.
+     * The output of [Tree()](clownfish:method:Tree) is an intermediate form which must be passed
+     * through [Expand()](clownfish:method:Expand) before being used to feed a search.
      *
      * @param query_string The string to be parsed.
      * @return a Query.
@@ -100,7 +100,7 @@ public class Lucy::Search::QueryParser nickname QParser
     Tree(QueryParser *self, String *query_string);
 
     /** Walk the hierarchy of a Query tree, descending through all PolyQuery
-     * nodes and calling Expand_Leaf() on any LeafQuery nodes encountered.
+     * nodes and calling [Expand_Leaf()](clownfish:method:Expand_Leaf) on any LeafQuery nodes encountered.
      *
      * @param query A Query object.
      * @return A Query -- usually the same one that was supplied after
@@ -124,23 +124,23 @@ public class Lucy::Search::QueryParser nickname QParser
     Expand_Leaf(QueryParser *self, Query *query);
 
     /** Prevent certain Query structures from returning too many results.
-     * Query objects built via Tree() and Expand() can generate "return the
+     * Query objects built via [Tree()](clownfish:method:Tree) and [Expand()](clownfish:method:Expand) can generate "return the
      * world" result sets, such as in the case of
-     * `NOT a_term_not_in_the_index`; Prune() walks the hierarchy
+     * `NOT a_term_not_in_the_index`; [Prune()](clownfish:method:Prune) walks the hierarchy
      * and eliminates such branches.
      *
      *      'NOT foo'               => [NOMATCH]
      *      'foo OR NOT bar'        => 'foo'
      *      'foo OR (-bar AND -baz) => 'foo'
      *
-     * Prune() also eliminates some double-negative constructs -- even though
+     * [Prune()](clownfish:method:Prune) also eliminates some double-negative constructs -- even though
      * such constructs may not actually return the world:
      *
      *      'foo AND -(-bar)'      => 'foo'
      *
      * In this example, safety is taking precedence over logical consistency.
-     * If you want logical consistency instead, call Tree() then Expand(),
-     * skipping Prune().
+     * If you want logical consistency instead, call [Tree()](clownfish:method:Tree) then [Expand()](clownfish:method:Expand),
+     * skipping [Prune()](clownfish:method:Prune).
      *
      *
      * @param query A Query.

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Store/DirHandle.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/DirHandle.cfh b/core/Lucy/Store/DirHandle.cfh
index f300285..c0e1e28 100644
--- a/core/Lucy/Store/DirHandle.cfh
+++ b/core/Lucy/Store/DirHandle.cfh
@@ -50,7 +50,7 @@ abstract class Lucy::Store::DirHandle nickname DH
     Get_Dir(DirHandle *self);
 
     /** Return the path of the current entry.  The value is only valid when
-     * Next() has returned successfully.
+     * [Next()](clownfish:method:Next) has returned successfully.
      */
     incremented String*
     Get_Entry(DirHandle *self);
@@ -66,7 +66,7 @@ abstract class Lucy::Store::DirHandle nickname DH
     abstract bool
     Entry_Is_Symlink(DirHandle *self);
 
-    /** Invokes Close(), but ignores any errors.
+    /** Invokes [Close()](clownfish:method:Close), but ignores any errors.
      */
     public void
     Destroy(DirHandle *self);

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Store/FileHandle.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/FileHandle.cfh b/core/Lucy/Store/FileHandle.cfh
index c1a9669..4d7664d 100644
--- a/core/Lucy/Store/FileHandle.cfh
+++ b/core/Lucy/Store/FileHandle.cfh
@@ -125,7 +125,7 @@ abstract class Lucy::Store::FileHandle nickname FH
     nullable String*
     Get_Path(FileHandle *self);
 
-    /** Invokes Close(), but ignores whether it succeeds or fails.
+    /** Invokes [Close()](clownfish:method:Close), but ignores whether it succeeds or fails.
      */
     public void
     Destroy(FileHandle *self);

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Store/Folder.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/Folder.cfh b/core/Lucy/Store/Folder.cfh
index 030a981..661bf1c 100644
--- a/core/Lucy/Store/Folder.cfh
+++ b/core/Lucy/Store/Folder.cfh
@@ -19,7 +19,7 @@ parcel Lucy;
 /** Abstract class representing a directory.
  *
  * A "file" within a Folder might be a real file on disk -- or it might be a
- * RAM buffer.  Similarly, Delete() might delete a file from the file system, or
+ * RAM buffer.  Similarly, [Delete()](clownfish:method:Delete) might delete a file from the file system, or
  * a key-value pair from a hash, or something else.
  *
  * The archetypal implementation of Folder,

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Store/InStream.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/InStream.cfh b/core/Lucy/Store/InStream.cfh
index 4bf7d27..c0a6516 100644
--- a/core/Lucy/Store/InStream.cfh
+++ b/core/Lucy/Store/InStream.cfh
@@ -119,8 +119,8 @@ class Lucy::Store::InStream inherits Clownfish::Obj {
     Buf(InStream *self, size_t request);
 
     /** Set the buf to a new value, checking for overrun.  The idiom is for
-     * the caller to call Buf(), use no more bytes than requested, then use
-     * Advance_Buf() to update the InStream object.
+     * the caller to call [Buf()](clownfish:method:Buf), use no more bytes than requested, then use
+     * [Advance_Buf()](clownfish:method:Advance_Buf) to update the InStream object.
      */
     final void
     Advance_Buf(InStream *self, const char *buf);

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Store/Lock.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/Lock.cfh b/core/Lucy/Store/Lock.cfh
index 1e20aaa..59eab09 100644
--- a/core/Lucy/Store/Lock.cfh
+++ b/core/Lucy/Store/Lock.cfh
@@ -43,7 +43,7 @@ public abstract class Lucy::Store::Lock inherits Clownfish::Obj {
      * consist solely of characters matching [-_.A-Za-z0-9].
      * @param host A unique per-machine identifier.
      * @param timeout Time in milliseconds to keep retrying before abandoning
-     * the attempt to Obtain() a lock.
+     * the attempt to [Obtain()](clownfish:method:Obtain) a lock.
      * @param interval Time in milliseconds between retries.
      */
     public inert Lock*
@@ -55,7 +55,7 @@ public abstract class Lucy::Store::Lock inherits Clownfish::Obj {
     public abstract bool
     Shared(Lock *self);
 
-    /** Call Request() once per `interval` until Request() returns
+    /** Call [Request()](clownfish:method:Request) once per `interval` until [Request()](clownfish:method:Request) returns
      * success or the `timeout` has been reached.
      *
      * @return true on success, false on failure (sets Err_error).
@@ -65,12 +65,12 @@ public abstract class Lucy::Store::Lock inherits Clownfish::Obj {
 
     /** Make one attempt to acquire the lock.
      *
-     * The semantics of Request() differ depending on whether Shared() returns
-     * true.  If the Lock is Shared(), then Request() should not fail if
+     * The semantics of [Request()](clownfish:method:Request) differ depending on whether [Shared()](clownfish:method:Shared) returns
+     * true.  If the Lock is [Shared()](clownfish:method:Shared), then [Request()](clownfish:method:Request) should not fail if
      * another lock is held against the resource identified by
      * `name` (though it might fail for other reasons).  If it is
-     * not Shared() -- i.e. it's an exclusive (write) lock -- then other locks
-     * should cause Request() to fail.
+     * not [Shared()](clownfish:method:Shared) -- i.e. it's an exclusive (write) lock -- then other locks
+     * should cause [Request()](clownfish:method:Request) to fail.
      *
      * @return true on success, false on failure (sets Err_error).
      */

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Store/LockFactory.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/LockFactory.cfh b/core/Lucy/Store/LockFactory.cfh
index b96199d..d68e008 100644
--- a/core/Lucy/Store/LockFactory.cfh
+++ b/core/Lucy/Store/LockFactory.cfh
@@ -40,27 +40,27 @@ public class Lucy::Store::LockFactory nickname LockFact
     public inert LockFactory*
     init(LockFactory *self, Folder *folder, String *host);
 
-    /** Return a Lock object, which, once Obtain() returns successfully,
+    /** Return a Lock object, which, once [Obtain()](clownfish:method:Lock:Obtain) returns successfully,
      * maintains an exclusive lock on a resource.
      *
      * @param name A file-system-friendly id which identifies the
      * resource to be locked.
      * @param timeout Time in milliseconds to keep retrying before abandoning
-     * the attempt to Obtain() a lock.
+     * the attempt to [Obtain()](clownfish:method:Lock:Obtain) a lock.
      * @param interval Time in milliseconds between retries.
      */
     public incremented Lock*
     Make_Lock(LockFactory *self, String *name, int32_t timeout = 0,
               int32_t interval = 100);
 
-    /** Return a Lock object for which Shared() returns true, and which
-     * maintains a non-exclusive lock on a resource once Obtain() returns
+    /** Return a Lock object for which [Shared()](clownfish:method:Lock:Shared) returns true, and which
+     * maintains a non-exclusive lock on a resource once [Obtain()](clownfish:method:Lock:Obtain) returns
      * success.
      *
      * @param name A file-system-friendly id which identifies the
      * resource to be locked.
      * @param timeout Time in milliseconds to keep retrying before abandoning
-     * the attempt to Obtain() a lock.
+     * the attempt to [Obtain()](clownfish:method:Lock:Obtain) a lock.
      * @param interval Time in milliseconds between retries.
      */
     public incremented Lock*

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Store/SharedLock.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/SharedLock.cfh b/core/Lucy/Store/SharedLock.cfh
index d8a8bc7..b4a6462 100644
--- a/core/Lucy/Store/SharedLock.cfh
+++ b/core/Lucy/Store/SharedLock.cfh
@@ -23,13 +23,13 @@ parcel Lucy;
  * implementing the same list of methods.  It differs from Lock only in the
  * semantics of two methods.
  *
- * First, Obtain() will not fail if another lock is held against the resource
+ * First, [Obtain()](clownfish:method:Obtain) will not fail if another lock is held against the resource
  * identified by `name` (though it might fail for other reasons).
  *
- * Second, Is_Locked() returns true so long as some lock, somewhere is holding
+ * Second, [Is_Locked()](clownfish:method:Is_Locked) returns true so long as some lock, somewhere is holding
  * a lock on `name`.  That lock could be this instance, or it could
- * be another -- so is entirely possible to call Release() successfully on a
- * SharedLock object yet still have Is_Locked() return true.
+ * be another -- so is entirely possible to call [Release()](clownfish:method:Release) successfully on a
+ * SharedLock object yet still have [Is_Locked()](clownfish:method:Is_Locked) return true.
  *
  * As currently implemented, SharedLock differs from Lock in that each caller
  * gets its own lockfile.  Lockfiles still have filenames which begin with the
@@ -51,7 +51,7 @@ class Lucy::Store::SharedLock nickname ShLock
      * @param name String identifying the resource to be locked.
      * @param host An identifier which should be unique per-machine.
      * @param timeout Time in milliseconds to keep retrying before abandoning
-     * the attempt to Obtain() a lock.
+     * the attempt to [Obtain()](clownfish:method:Obtain) a lock.
      * @param interval Time in milliseconds between retries.
      */
     public inert SharedLock*

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Test/Plan/TestArchitecture.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Plan/TestArchitecture.cfh b/core/Lucy/Test/Plan/TestArchitecture.cfh
index d86b1b8..dc4883b 100644
--- a/core/Lucy/Test/Plan/TestArchitecture.cfh
+++ b/core/Lucy/Test/Plan/TestArchitecture.cfh
@@ -17,7 +17,7 @@
 parcel TestLucy;
 
 /**
- * Returns absurdly low values for Index_Interval() and Skip_Interval().
+ * Returns absurdly low values for [Index_Interval()](clownfish:method:Index_Interval) and [Skip_Interval()](clownfish:method:Skip_Interval).
  */
 
 class Lucy::Test::Plan::TestArchitecture nickname TestArch

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Test/TestSchema.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/TestSchema.cfh b/core/Lucy/Test/TestSchema.cfh
index 87dd41a..219698b 100644
--- a/core/Lucy/Test/TestSchema.cfh
+++ b/core/Lucy/Test/TestSchema.cfh
@@ -19,7 +19,7 @@ parcel TestLucy;
 /** Schema for use by the test suite.
  *
  * Exposes problems faced by much larger indexes by using an TestArchitecture,
- * which returns absurdly low values for Index_Interval() and Skip_Interval().
+ * which returns absurdly low values for [Index_Interval()](clownfish:method:Index_Interval) and [Skip_Interval()](clownfish:method:Skip_Interval).
  */
 
 class Lucy::Test::TestSchema inherits Lucy::Plan::Schema {

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Util/Debug.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Util/Debug.cfh b/core/Lucy/Util/Debug.cfh
index 9e81d04..5ba535a 100644
--- a/core/Lucy/Util/Debug.cfh
+++ b/core/Lucy/Util/Debug.cfh
@@ -98,7 +98,7 @@ __C__
 
 /** Abort on error if test fails.
  *
- * Note: unlike the system assert(), this ASSERT() is #ifdef LUCY_DEBUG.
+ * Note: unlike the system assert(), this [ASSERT()](clownfish:method:ASSERT) is #ifdef LUCY_DEBUG.
  */
 #define LUCY_ASSERT(test , args...)                                    \
     do {                                                               \

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Util/Freezer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Util/Freezer.cfh b/core/Lucy/Util/Freezer.cfh
index 5de2474..0cde753 100644
--- a/core/Lucy/Util/Freezer.cfh
+++ b/core/Lucy/Util/Freezer.cfh
@@ -43,7 +43,7 @@ inert class Lucy::Util::Freezer {
     /** Return a representation of the object using only scalars, hashes, and
      * arrays.  Some classes support JSON serialization via dump() and its
      * companion, load(); for others, dump() is only a debugging aid.
-     * The default simply calls To_String().
+     * The default simply calls [To_String()](clownfish:method:To_String).
      */
     inert incremented Obj*
     dump(Obj *obj);

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Util/PriorityQueue.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Util/PriorityQueue.cfh b/core/Lucy/Util/PriorityQueue.cfh
index 2480bb5..7c0e267 100644
--- a/core/Lucy/Util/PriorityQueue.cfh
+++ b/core/Lucy/Util/PriorityQueue.cfh
@@ -53,8 +53,8 @@ class Lucy::Util::PriorityQueue nickname PriQ
     bool
     Insert(PriorityQueue *self, decremented Obj *element);
 
-    /** Equivalent to Insert(), except for the return value.  If the Queue has
-     * room, the element is inserted and Jostle() returns NULL.  If not, then
+    /** Equivalent to [Insert()](clownfish:method:Insert), except for the return value.  If the Queue has
+     * room, the element is inserted and [Jostle()](clownfish:method:Jostle) returns NULL.  If not, then
      * the item which falls out of the bottom of the Queue is returned.
      */
     incremented nullable Obj*

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Util/SortExternal.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Util/SortExternal.cfh b/core/Lucy/Util/SortExternal.cfh
index 7e8439b..d8420ff 100644
--- a/core/Lucy/Util/SortExternal.cfh
+++ b/core/Lucy/Util/SortExternal.cfh
@@ -19,19 +19,19 @@ parcel Lucy;
 /** Abstract external sorter.
  *
  * SortExternal objects are sort pools which allow you to sort huge
- * collections of elements.  To achieve this, you Feed() all items into the
- * SortExternal object, Flip() it from write mode to read mode, then Fetch()
+ * collections of elements.  To achieve this, you [Feed()](clownfish:method:Feed) all items into the
+ * SortExternal object, [Flip()](clownfish:method:Flip) it from write mode to read mode, then [Fetch()](clownfish:method:Fetch)
  * the elements one at a time in sorted order.
  *
  * It's expected that the total memory footprint of the buffered sortable
  * items will eventually exceed a specified threshold; at that point, the
- * SortExternal object will call the abstract method Flush().  It's expected
- * that Flush() implementations will empty out the current buffer, write a
+ * SortExternal object will call the abstract method [Flush()](clownfish:method:Flush).  It's expected
+ * that [Flush()](clownfish:method:Flush) implementations will empty out the current buffer, write a
  * sorted "run" to external storage, and add a new child SortExternal object
  * to the top level object's "runs" array to represent the flushed content.
  *
  * During the read phase, the child sortex objects retrieve elements from
- * external storage by calling the abstract method Refill().  The top-level
+ * external storage by calling the abstract method [Refill()](clownfish:method:Refill).  The top-level
  * SortExternal object then interleaves multiple sorted streams to produce a
  * single unified stream of sorted items.
  */
@@ -63,7 +63,7 @@ abstract class Lucy::Util::SortExternal nickname SortEx
      *
      * Presumably this entails sorting everything, writing the sorted elements
      * to disk, spawning a child object to represent those elements, and
-     * adding that child to the top-level object via Add_Run().
+     * adding that child to the top-level object via [Add_Run()](clownfish:method:Add_Run).
      */
     abstract void
     Flush(SortExternal *self);
@@ -79,13 +79,13 @@ abstract class Lucy::Util::SortExternal nickname SortEx
     Flip(SortExternal *self);
 
     /** Fetch the next sorted item from the sort pool.  Invalid prior to
-     * calling Flip(). Returns NULL when all elements have been exhausted.
+     * calling [Flip()](clownfish:method:Flip). Returns NULL when all elements have been exhausted.
      */
     incremented nullable Obj*
     Fetch(SortExternal *self);
 
     /** Preview the next item that Fetch will return, but don't pop it.
-     * Invalid prior to calling Flip().
+     * Invalid prior to calling [Flip()](clownfish:method:Flip).
      */
     nullable Obj*
     Peek(SortExternal *self);

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Util/Stepper.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Util/Stepper.cfh b/core/Lucy/Util/Stepper.cfh
index 36ed485..73d0003 100644
--- a/core/Lucy/Util/Stepper.cfh
+++ b/core/Lucy/Util/Stepper.cfh
@@ -44,7 +44,7 @@ class Lucy::Util::Stepper inherits Clownfish::Obj {
     Reset(Stepper* self);
 
     /** Update internal state to reflect `value` and write a frame
-     * to `outstream` that can be read using Read_Key_Frame().
+     * to `outstream` that can be read using [Read_Key_Frame()](clownfish:method:Read_Key_Frame).
      *
      * @param outstream An OutStream.
      * @param value State information.
@@ -53,7 +53,7 @@ class Lucy::Util::Stepper inherits Clownfish::Obj {
     Write_Key_Frame(Stepper *self, OutStream *outstream, Obj *value);
 
     /** Update internal state to reflect `value` and write a frame
-     * to `outstream` that can be read using Read_Delta().
+     * to `outstream` that can be read using [Read_Delta()](clownfish:method:Read_Delta).
      *
      * @param outstream An OutStream.
      * @param value State information.

http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/LucyX/Search/MockMatcher.cfh
----------------------------------------------------------------------
diff --git a/core/LucyX/Search/MockMatcher.cfh b/core/LucyX/Search/MockMatcher.cfh
index 27c23c6..f25877a 100644
--- a/core/LucyX/Search/MockMatcher.cfh
+++ b/core/LucyX/Search/MockMatcher.cfh
@@ -29,7 +29,7 @@ class LucyX::Search::MockMatcher inherits Lucy::Search::Matcher {
     /**
      * @param doc_ids An array of matching doc ids.
      * @param scores Float scores corresponding to the doc ids array.  If not
-     * supplied, calling Score() will throw an exception.
+     * supplied, calling [Score()](clownfish:method:Score) will throw an exception.
      */
     inert incremented MockMatcher*
     init(MockMatcher *self, I32Array *doc_ids, ByteBuf *scores = NULL);