lucy-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mar...@apache.org
Subject [lucy-commits] [06/11] git commit: refs/heads/master - Migrate most of Lucy core to _IMP.
Date Sat, 17 Aug 2013 17:20:27 GMT
Migrate most of Lucy core to _IMP.

Change implementing funcs to utilize the new-style _IMP function at the
site of the definition.  However, retain the old aliases where they are
invoked so that this large commit can remain very superficial.


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

Branch: refs/heads/master
Commit: cb510ae722e4372e62f1366d10c2a9124eecd6ec
Parents: b5a1e69
Author: Marvin Humphrey <marvin@rectangular.com>
Authored: Fri Aug 9 14:53:09 2013 -0700
Committer: Marvin Humphrey <marvin@rectangular.com>
Committed: Mon Aug 12 15:11:38 2013 -0700

----------------------------------------------------------------------
 core/Lucy/Analysis/Analyzer.c                | 10 ++--
 core/Lucy/Analysis/CaseFolder.c              | 12 ++---
 core/Lucy/Analysis/EasyAnalyzer.c            | 12 ++---
 core/Lucy/Analysis/Inversion.c               | 14 ++---
 core/Lucy/Analysis/Normalizer.c              |  8 +--
 core/Lucy/Analysis/PolyAnalyzer.c            | 15 +++---
 core/Lucy/Analysis/RegexTokenizer.c          | 10 ++--
 core/Lucy/Analysis/SnowballStemmer.c         | 10 ++--
 core/Lucy/Analysis/SnowballStopFilter.c      | 14 +++--
 core/Lucy/Analysis/StandardTokenizer.c       | 10 ++--
 core/Lucy/Analysis/Token.c                   | 18 +++----
 core/Lucy/Document/Doc.c                     |  6 +--
 core/Lucy/Document/HitDoc.c                  | 14 ++---
 core/Lucy/Highlight/HeatMap.c                | 10 ++--
 core/Lucy/Highlight/Highlighter.c            | 48 +++++++++---------
 core/Lucy/Index/BackgroundMerger.c           |  8 +--
 core/Lucy/Index/BitVecDelDocs.c              |  2 +-
 core/Lucy/Index/DataReader.c                 | 14 ++---
 core/Lucy/Index/DataWriter.c                 | 20 ++++----
 core/Lucy/Index/DeletionsReader.c            | 22 ++++----
 core/Lucy/Index/DeletionsWriter.c            | 38 +++++++-------
 core/Lucy/Index/DocReader.c                  | 17 ++++---
 core/Lucy/Index/DocVector.c                  | 18 +++----
 core/Lucy/Index/DocWriter.c                  | 14 ++---
 core/Lucy/Index/FilePurger.c                 |  4 +-
 core/Lucy/Index/HighlightReader.c            | 20 ++++----
 core/Lucy/Index/HighlightWriter.c            | 16 +++---
 core/Lucy/Index/IndexManager.c               | 62 ++++++++++++-----------
 core/Lucy/Index/IndexReader.c                | 10 ++--
 core/Lucy/Index/Indexer.c                    | 24 ++++-----
 core/Lucy/Index/Inverter.c                   | 36 ++++++-------
 core/Lucy/Index/LexIndex.c                   | 10 ++--
 core/Lucy/Index/Lexicon.c                    |  4 +-
 core/Lucy/Index/LexiconReader.c              | 31 ++++++------
 core/Lucy/Index/LexiconWriter.c              | 24 ++++-----
 core/Lucy/Index/PolyLexicon.c                | 14 ++---
 core/Lucy/Index/PolyReader.c                 | 16 +++---
 core/Lucy/Index/Posting.c                    |  4 +-
 core/Lucy/Index/Posting/MatchPosting.c       | 54 ++++++++++----------
 core/Lucy/Index/Posting/RawPosting.c         | 16 +++---
 core/Lucy/Index/Posting/RichPosting.c        | 23 +++++----
 core/Lucy/Index/Posting/ScorePosting.c       | 33 ++++++------
 core/Lucy/Index/PostingListReader.c          | 14 ++---
 core/Lucy/Index/PostingListWriter.c          | 14 ++---
 core/Lucy/Index/PostingPool.c                | 25 ++++-----
 core/Lucy/Index/RawLexicon.c                 |  8 +--
 core/Lucy/Index/RawPostingList.c             |  8 +--
 core/Lucy/Index/SegLexicon.c                 | 18 +++----
 core/Lucy/Index/SegPostingList.c             | 28 +++++-----
 core/Lucy/Index/SegReader.c                  | 20 ++++----
 core/Lucy/Index/SegWriter.c                  | 35 ++++++-------
 core/Lucy/Index/Segment.c                    | 36 ++++++-------
 core/Lucy/Index/Similarity.c                 | 36 ++++++-------
 core/Lucy/Index/SkipStepper.c                | 12 ++---
 core/Lucy/Index/Snapshot.c                   | 18 +++----
 core/Lucy/Index/SortCache.c                  | 18 +++----
 core/Lucy/Index/SortCache/NumericSortCache.c | 18 +++----
 core/Lucy/Index/SortCache/TextSortCache.c    |  6 +--
 core/Lucy/Index/SortFieldWriter.c            | 24 ++++-----
 core/Lucy/Index/SortReader.c                 | 10 ++--
 core/Lucy/Index/SortWriter.c                 | 16 +++---
 core/Lucy/Index/TermInfo.c                   | 24 ++++-----
 core/Lucy/Index/TermStepper.c                |  8 +--
 core/Lucy/Index/TermVector.c                 | 14 ++---
 core/Lucy/Index/ZombieKeyedHash.c            |  4 +-
 core/Lucy/Object/BitVector.c                 | 38 +++++++-------
 core/Lucy/Object/I32Array.c                  |  8 +--
 core/Lucy/Plan/Architecture.c                | 36 ++++++-------
 core/Lucy/Plan/BlobType.c                    | 16 +++---
 core/Lucy/Plan/FieldType.c                   | 24 ++++-----
 core/Lucy/Plan/FullTextType.c                | 18 +++----
 core/Lucy/Plan/NumericType.c                 | 32 ++++++------
 core/Lucy/Plan/Schema.c                      | 30 +++++------
 core/Lucy/Plan/StringType.c                  | 12 ++---
 core/Lucy/Plan/TextType.c                    | 17 ++++---
 core/Lucy/Search/ANDMatcher.c                | 10 ++--
 core/Lucy/Search/ANDQuery.c                  | 12 ++---
 core/Lucy/Search/BitVecMatcher.c             |  8 +--
 core/Lucy/Search/Collector.c                 | 26 +++++-----
 core/Lucy/Search/Collector/SortCollector.c   | 12 ++---
 core/Lucy/Search/Compiler.c                  | 26 +++++-----
 core/Lucy/Search/HitQueue.c                  |  6 +--
 core/Lucy/Search/Hits.c                      |  6 +--
 core/Lucy/Search/IndexSearcher.c             | 20 ++++----
 core/Lucy/Search/LeafQuery.c                 | 24 ++++-----
 core/Lucy/Search/MatchAllMatcher.c           |  8 +--
 core/Lucy/Search/MatchAllQuery.c             | 12 ++---
 core/Lucy/Search/MatchDoc.c                  | 18 +++----
 core/Lucy/Search/Matcher.c                   |  4 +-
 core/Lucy/Search/NOTMatcher.c                | 10 ++--
 core/Lucy/Search/NOTQuery.c                  | 22 ++++----
 core/Lucy/Search/NoMatchMatcher.c            |  4 +-
 core/Lucy/Search/NoMatchQuery.c              | 24 ++++-----
 core/Lucy/Search/ORMatcher.c                 | 18 +++----
 core/Lucy/Search/ORQuery.c                   | 12 ++---
 core/Lucy/Search/PhraseMatcher.c             | 12 ++---
 core/Lucy/Search/PhraseQuery.c               | 44 ++++++++--------
 core/Lucy/Search/PolyMatcher.c               |  2 +-
 core/Lucy/Search/PolyQuery.c                 | 34 ++++++-------
 core/Lucy/Search/PolySearcher.c              | 18 +++----
 core/Lucy/Search/Query.c                     | 14 +++--
 core/Lucy/Search/QueryParser.c               | 41 +++++++--------
 core/Lucy/Search/QueryParser/ParserElem.c    | 20 ++++----
 core/Lucy/Search/QueryParser/QueryLexer.c    |  6 +--
 core/Lucy/Search/RangeMatcher.c              | 10 ++--
 core/Lucy/Search/RangeQuery.c                | 24 ++++-----
 core/Lucy/Search/RequiredOptionalMatcher.c   | 10 ++--
 core/Lucy/Search/RequiredOptionalQuery.c     | 24 ++++-----
 core/Lucy/Search/Searcher.c                  | 12 ++---
 core/Lucy/Search/SeriesMatcher.c             |  8 +--
 core/Lucy/Search/SortRule.c                  | 12 ++---
 core/Lucy/Search/SortSpec.c                  |  8 +--
 core/Lucy/Search/Span.c                      | 16 +++---
 core/Lucy/Search/TermMatcher.c               |  8 +--
 core/Lucy/Search/TermQuery.c                 | 45 ++++++++--------
 core/Lucy/Search/TopDocs.c                   | 14 ++---
 core/Lucy/Store/CompoundFileReader.c         | 34 +++++++------
 core/Lucy/Store/CompoundFileWriter.c         |  4 +-
 core/Lucy/Store/DirHandle.c                  |  6 +--
 core/Lucy/Store/FSDirHandle.c                | 18 +++----
 core/Lucy/Store/FSFileHandle.c               | 20 ++++----
 core/Lucy/Store/FSFolder.c                   | 28 +++++-----
 core/Lucy/Store/FileHandle.c                 |  8 +--
 core/Lucy/Store/FileWindow.c                 | 12 ++---
 core/Lucy/Store/Folder.c                     | 39 +++++++-------
 core/Lucy/Store/InStream.c                   | 50 +++++++++---------
 core/Lucy/Store/Lock.c                       | 28 +++++-----
 core/Lucy/Store/LockFactory.c                | 10 ++--
 core/Lucy/Store/OutStream.c                  | 42 +++++++--------
 core/Lucy/Store/RAMDirHandle.c               |  8 +--
 core/Lucy/Store/RAMFile.c                    |  8 +--
 core/Lucy/Store/RAMFileHandle.c              | 20 ++++----
 core/Lucy/Store/RAMFolder.c                  | 28 +++++-----
 core/Lucy/Store/SharedLock.c                 | 10 ++--
 core/Lucy/Util/BBSortEx.c                    | 14 ++---
 core/Lucy/Util/MemoryPool.c                  | 12 ++---
 core/Lucy/Util/PriorityQueue.c               | 14 ++---
 core/Lucy/Util/SortExternal.c                | 22 ++++----
 138 files changed, 1257 insertions(+), 1252 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Analysis/Analyzer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/Analyzer.c b/core/Lucy/Analysis/Analyzer.c
index 9a16c16..3115d6b 100644
--- a/core/Lucy/Analysis/Analyzer.c
+++ b/core/Lucy/Analysis/Analyzer.c
@@ -29,7 +29,7 @@ Analyzer_init(Analyzer *self) {
 }
 
 Inversion*
-Analyzer_transform_text(Analyzer *self, CharBuf *text) {
+Analyzer_Transform_Text_IMP(Analyzer *self, CharBuf *text) {
     size_t token_len = CB_Get_Size(text);
     Token *seed = Token_new((char*)CB_Get_Ptr8(text), token_len, 0,
                             token_len, 1.0, 1);
@@ -41,7 +41,7 @@ Analyzer_transform_text(Analyzer *self, CharBuf *text) {
 }
 
 VArray*
-Analyzer_split(Analyzer *self, CharBuf *text) {
+Analyzer_Split_IMP(Analyzer *self, CharBuf *text) {
     Inversion  *inversion = Analyzer_Transform_Text(self, text);
     VArray     *out       = VA_new(0);
     Token      *token;
@@ -59,8 +59,7 @@ Analyzer_split(Analyzer *self, CharBuf *text) {
 }
 
 Obj*
-Analyzer_dump(Analyzer *self)
-{
+Analyzer_Dump_IMP(Analyzer *self) {
     Hash *dump = Hash_new(0);
     Hash_Store_Str(dump, "_class", 6,
                    (Obj*)CB_Clone(Obj_Get_Class_Name((Obj*)self)));
@@ -68,8 +67,7 @@ Analyzer_dump(Analyzer *self)
 }
 
 Obj*
-Analyzer_load(Analyzer *self, Obj *dump)
-{
+Analyzer_Load_IMP(Analyzer *self, Obj *dump) {
     CHY_UNUSED_VAR(self);
     Hash *source = (Hash*)CERTIFY(dump, HASH);
     CharBuf *class_name

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Analysis/CaseFolder.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/CaseFolder.c b/core/Lucy/Analysis/CaseFolder.c
index 9330caf..6f113e0 100644
--- a/core/Lucy/Analysis/CaseFolder.c
+++ b/core/Lucy/Analysis/CaseFolder.c
@@ -36,40 +36,40 @@ CaseFolder_init(CaseFolder *self) {
 }
 
 void
-CaseFolder_destroy(CaseFolder *self) {
+CaseFolder_Destroy_IMP(CaseFolder *self) {
     CaseFolderIVARS *const ivars = CaseFolder_IVARS(self);
     DECREF(ivars->normalizer);
     SUPER_DESTROY(self, CASEFOLDER);
 }
 
 Inversion*
-CaseFolder_transform(CaseFolder *self, Inversion *inversion) {
+CaseFolder_Transform_IMP(CaseFolder *self, Inversion *inversion) {
     CaseFolderIVARS *const ivars = CaseFolder_IVARS(self);
     return Normalizer_Transform(ivars->normalizer, inversion);
 }
 
 Inversion*
-CaseFolder_transform_text(CaseFolder *self, CharBuf *text) {
+CaseFolder_Transform_Text_IMP(CaseFolder *self, CharBuf *text) {
     CaseFolderIVARS *const ivars = CaseFolder_IVARS(self);
     return Normalizer_Transform_Text(ivars->normalizer, text);
 }
 
 bool
-CaseFolder_equals(CaseFolder *self, Obj *other) {
+CaseFolder_Equals_IMP(CaseFolder *self, Obj *other) {
     if ((CaseFolder*)other == self)   { return true; }
     if (!Obj_Is_A(other, CASEFOLDER)) { return false; }
     return true;
 }
 
 Hash*
-CaseFolder_dump(CaseFolder *self) {
+CaseFolder_Dump_IMP(CaseFolder *self) {
     CaseFolder_Dump_t super_dump
         = SUPER_METHOD_PTR(CASEFOLDER, Lucy_CaseFolder_Dump);
     return super_dump(self);
 }
 
 CaseFolder*
-CaseFolder_load(CaseFolder *self, Obj *dump) {
+CaseFolder_Load_IMP(CaseFolder *self, Obj *dump) {
     CaseFolder_Load_t super_load
         = SUPER_METHOD_PTR(CASEFOLDER, Lucy_CaseFolder_Load);
     CaseFolder *loaded = super_load(self, dump);

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Analysis/EasyAnalyzer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/EasyAnalyzer.c b/core/Lucy/Analysis/EasyAnalyzer.c
index 5441fd8..1a676fe 100644
--- a/core/Lucy/Analysis/EasyAnalyzer.c
+++ b/core/Lucy/Analysis/EasyAnalyzer.c
@@ -41,7 +41,7 @@ EasyAnalyzer_init(EasyAnalyzer *self, const CharBuf *language) {
 }
 
 void
-EasyAnalyzer_destroy(EasyAnalyzer *self) {
+EasyAnalyzer_Destroy_IMP(EasyAnalyzer *self) {
     EasyAnalyzerIVARS *const ivars = EasyAnalyzer_IVARS(self);
     DECREF(ivars->language);
     DECREF(ivars->tokenizer);
@@ -51,7 +51,7 @@ EasyAnalyzer_destroy(EasyAnalyzer *self) {
 }
 
 Inversion*
-EasyAnalyzer_transform(EasyAnalyzer *self, Inversion *inversion) {
+EasyAnalyzer_Transform_IMP(EasyAnalyzer *self, Inversion *inversion) {
     EasyAnalyzerIVARS *const ivars = EasyAnalyzer_IVARS(self);
     Inversion *inv1 = StandardTokenizer_Transform(ivars->tokenizer, inversion);
     Inversion *inv2 = Normalizer_Transform(ivars->normalizer, inv1);
@@ -62,7 +62,7 @@ EasyAnalyzer_transform(EasyAnalyzer *self, Inversion *inversion) {
 }
 
 Inversion*
-EasyAnalyzer_transform_text(EasyAnalyzer *self, CharBuf *text) {
+EasyAnalyzer_Transform_Text_IMP(EasyAnalyzer *self, CharBuf *text) {
     EasyAnalyzerIVARS *const ivars = EasyAnalyzer_IVARS(self);
     Inversion *inv1 = StandardTokenizer_Transform_Text(ivars->tokenizer, text);
     Inversion *inv2 = Normalizer_Transform(ivars->normalizer, inv1);
@@ -73,7 +73,7 @@ EasyAnalyzer_transform_text(EasyAnalyzer *self, CharBuf *text) {
 }
 
 Hash*
-EasyAnalyzer_dump(EasyAnalyzer *self) {
+EasyAnalyzer_Dump_IMP(EasyAnalyzer *self) {
     EasyAnalyzerIVARS *const ivars = EasyAnalyzer_IVARS(self);
     EasyAnalyzer_Dump_t super_dump
         = SUPER_METHOD_PTR(EASYANALYZER, Lucy_EasyAnalyzer_Dump);
@@ -83,7 +83,7 @@ EasyAnalyzer_dump(EasyAnalyzer *self) {
 }
 
 EasyAnalyzer*
-EasyAnalyzer_load(EasyAnalyzer *self, Obj *dump) {
+EasyAnalyzer_Load_IMP(EasyAnalyzer *self, Obj *dump) {
     EasyAnalyzer_Load_t super_load
         = SUPER_METHOD_PTR(EASYANALYZER, Lucy_EasyAnalyzer_Load);
     EasyAnalyzer *loaded = super_load(self, dump);
@@ -94,7 +94,7 @@ EasyAnalyzer_load(EasyAnalyzer *self, Obj *dump) {
 }
 
 bool
-EasyAnalyzer_equals(EasyAnalyzer *self, Obj *other) {
+EasyAnalyzer_Equals_IMP(EasyAnalyzer *self, Obj *other) {
     if ((EasyAnalyzer*)other == self)                       { return true; }
     if (!Obj_Is_A(other, EASYANALYZER))                     { return false; }
     EasyAnalyzerIVARS *const ivars = EasyAnalyzer_IVARS(self);

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Analysis/Inversion.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/Inversion.c b/core/Lucy/Analysis/Inversion.c
index 9a3fb34..da0704d 100644
--- a/core/Lucy/Analysis/Inversion.c
+++ b/core/Lucy/Analysis/Inversion.c
@@ -49,7 +49,7 @@ Inversion_new(Token *seed_token) {
 }
 
 void
-Inversion_destroy(Inversion *self) {
+Inversion_Destroy_IMP(Inversion *self) {
     InversionIVARS *const ivars = Inversion_IVARS(self);
     if (ivars->tokens) {
         Token **tokens       = ivars->tokens;
@@ -64,12 +64,12 @@ Inversion_destroy(Inversion *self) {
 }
 
 uint32_t
-Inversion_get_size(Inversion *self) {
+Inversion_Get_Size_IMP(Inversion *self) {
     return Inversion_IVARS(self)->size;
 }
 
 Token*
-Inversion_next(Inversion *self) {
+Inversion_Next_IMP(Inversion *self) {
     InversionIVARS *const ivars = Inversion_IVARS(self);
     // Kill the iteration if we're out of tokens.
     if (ivars->cur == ivars->size) {
@@ -79,7 +79,7 @@ Inversion_next(Inversion *self) {
 }
 
 void
-Inversion_reset(Inversion *self) {
+Inversion_Reset_IMP(Inversion *self) {
     Inversion_IVARS(self)->cur = 0;
 }
 
@@ -98,7 +98,7 @@ S_grow(Inversion *self, size_t size) {
 }
 
 void
-Inversion_append(Inversion *self, Token *token) {
+Inversion_Append_IMP(Inversion *self, Token *token) {
     InversionIVARS *const ivars = Inversion_IVARS(self);
     if (ivars->inverted) {
         THROW(ERR, "Can't append tokens after inversion");
@@ -112,7 +112,7 @@ Inversion_append(Inversion *self, Token *token) {
 }
 
 Token**
-Inversion_next_cluster(Inversion *self, uint32_t *count) {
+Inversion_Next_Cluster_IMP(Inversion *self, uint32_t *count) {
     InversionIVARS *const ivars = Inversion_IVARS(self);
     Token **cluster = ivars->tokens + ivars->cur;
 
@@ -137,7 +137,7 @@ Inversion_next_cluster(Inversion *self, uint32_t *count) {
 }
 
 void
-Inversion_invert(Inversion *self) {
+Inversion_Invert_IMP(Inversion *self) {
     InversionIVARS *const ivars = Inversion_IVARS(self);
     Token   **tokens = ivars->tokens;
     Token   **limit  = tokens + ivars->size;

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Analysis/Normalizer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/Normalizer.c b/core/Lucy/Analysis/Normalizer.c
index a120db3..1b72d73 100644
--- a/core/Lucy/Analysis/Normalizer.c
+++ b/core/Lucy/Analysis/Normalizer.c
@@ -66,7 +66,7 @@ Normalizer_init(Normalizer *self, const CharBuf *form, bool case_fold,
 }
 
 Inversion*
-Normalizer_transform(Normalizer *self, Inversion *inversion) {
+Normalizer_Transform_IMP(Normalizer *self, Inversion *inversion) {
     // allocate additional space because utf8proc_reencode adds a
     // terminating null char
     int32_t static_buffer[INITIAL_BUFSIZE + 1];
@@ -119,7 +119,7 @@ Normalizer_transform(Normalizer *self, Inversion *inversion) {
 }
 
 Hash*
-Normalizer_dump(Normalizer *self) {
+Normalizer_Dump_IMP(Normalizer *self) {
     Normalizer_Dump_t super_dump
         = SUPER_METHOD_PTR(NORMALIZER, Lucy_Normalizer_Dump);
     Hash *dump = super_dump(self);
@@ -145,7 +145,7 @@ Normalizer_dump(Normalizer *self) {
 }
 
 Normalizer*
-Normalizer_load(Normalizer *self, Obj *dump) {
+Normalizer_Load_IMP(Normalizer *self, Obj *dump) {
     Normalizer_Load_t super_load
         = SUPER_METHOD_PTR(NORMALIZER, Lucy_Normalizer_Load);
     Normalizer *loaded = super_load(self, dump);
@@ -162,7 +162,7 @@ Normalizer_load(Normalizer *self, Obj *dump) {
 }
 
 bool
-Normalizer_equals(Normalizer *self, Obj *other) {
+Normalizer_Equals_IMP(Normalizer *self, Obj *other) {
     if ((Normalizer*)other == self)       { return true; }
     if (!Obj_Is_A(other, NORMALIZER))     { return false; }
     NormalizerIVARS *const ivars = Normalizer_IVARS(self);

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Analysis/PolyAnalyzer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/PolyAnalyzer.c b/core/Lucy/Analysis/PolyAnalyzer.c
index f29b122..2e35c36 100644
--- a/core/Lucy/Analysis/PolyAnalyzer.c
+++ b/core/Lucy/Analysis/PolyAnalyzer.c
@@ -57,19 +57,19 @@ PolyAnalyzer_init(PolyAnalyzer *self, const CharBuf *language,
 }
 
 void
-PolyAnalyzer_destroy(PolyAnalyzer *self) {
+PolyAnalyzer_Destroy_IMP(PolyAnalyzer *self) {
     PolyAnalyzerIVARS *const ivars = PolyAnalyzer_IVARS(self);
     DECREF(ivars->analyzers);
     SUPER_DESTROY(self, POLYANALYZER);
 }
 
 VArray*
-PolyAnalyzer_get_analyzers(PolyAnalyzer *self) {
+PolyAnalyzer_Get_Analyzers_IMP(PolyAnalyzer *self) {
     return PolyAnalyzer_IVARS(self)->analyzers;
 }
 
 Inversion*
-PolyAnalyzer_transform(PolyAnalyzer *self, Inversion *inversion) {
+PolyAnalyzer_Transform_IMP(PolyAnalyzer *self, Inversion *inversion) {
     VArray *const analyzers = PolyAnalyzer_IVARS(self)->analyzers;
     (void)INCREF(inversion);
 
@@ -85,7 +85,7 @@ PolyAnalyzer_transform(PolyAnalyzer *self, Inversion *inversion) {
 }
 
 Inversion*
-PolyAnalyzer_transform_text(PolyAnalyzer *self, CharBuf *text) {
+PolyAnalyzer_Transform_Text_IMP(PolyAnalyzer *self, CharBuf *text) {
     VArray *const   analyzers     = PolyAnalyzer_IVARS(self)->analyzers;
     const uint32_t  num_analyzers = VA_Get_Size(analyzers);
     Inversion      *retval;
@@ -112,7 +112,7 @@ PolyAnalyzer_transform_text(PolyAnalyzer *self, CharBuf *text) {
 }
 
 bool
-PolyAnalyzer_equals(PolyAnalyzer *self, Obj *other) {
+PolyAnalyzer_Equals_IMP(PolyAnalyzer *self, Obj *other) {
     if ((PolyAnalyzer*)other == self)                         { return true; }
     if (!Obj_Is_A(other, POLYANALYZER))                       { return false; }
     PolyAnalyzerIVARS *const ivars = PolyAnalyzer_IVARS(self);
@@ -122,8 +122,7 @@ PolyAnalyzer_equals(PolyAnalyzer *self, Obj *other) {
 }
 
 Obj*
-PolyAnalyzer_dump(PolyAnalyzer *self)
-{
+PolyAnalyzer_Dump_IMP(PolyAnalyzer *self) {
     PolyAnalyzerIVARS *const ivars = PolyAnalyzer_IVARS(self);
     PolyAnalyzer_Dump_t super_dump
         = SUPER_METHOD_PTR(POLYANALYZER, Lucy_PolyAnalyzer_Dump);
@@ -136,7 +135,7 @@ PolyAnalyzer_dump(PolyAnalyzer *self)
 }
 
 PolyAnalyzer*
-PolyAnalyzer_load(PolyAnalyzer *self, Obj *dump) {
+PolyAnalyzer_Load_IMP(PolyAnalyzer *self, Obj *dump) {
     Hash *source = (Hash*)CERTIFY(dump, HASH);
     PolyAnalyzer_Load_t super_load 
         = SUPER_METHOD_PTR(POLYANALYZER, Lucy_PolyAnalyzer_Load);

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Analysis/RegexTokenizer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/RegexTokenizer.c b/core/Lucy/Analysis/RegexTokenizer.c
index d504498..cfb989c 100644
--- a/core/Lucy/Analysis/RegexTokenizer.c
+++ b/core/Lucy/Analysis/RegexTokenizer.c
@@ -29,7 +29,7 @@ RegexTokenizer_new(const CharBuf *pattern) {
 }
 
 Inversion*
-RegexTokenizer_transform(RegexTokenizer *self, Inversion *inversion) {
+RegexTokenizer_Transform_IMP(RegexTokenizer *self, Inversion *inversion) {
     Inversion *new_inversion = Inversion_new(NULL);
     Token *token;
 
@@ -43,7 +43,7 @@ RegexTokenizer_transform(RegexTokenizer *self, Inversion *inversion) {
 }
 
 Inversion*
-RegexTokenizer_transform_text(RegexTokenizer *self, CharBuf *text) {
+RegexTokenizer_Transform_Text_IMP(RegexTokenizer *self, CharBuf *text) {
     Inversion *new_inversion = Inversion_new(NULL);
     RegexTokenizer_Tokenize_Str(self, (char*)CB_Get_Ptr8(text),
                                 CB_Get_Size(text), new_inversion);
@@ -51,7 +51,7 @@ RegexTokenizer_transform_text(RegexTokenizer *self, CharBuf *text) {
 }
 
 Obj*
-RegexTokenizer_dump(RegexTokenizer *self) {
+RegexTokenizer_Dump_IMP(RegexTokenizer *self) {
     RegexTokenizerIVARS *const ivars = RegexTokenizer_IVARS(self);
     RegexTokenizer_Dump_t super_dump
         = SUPER_METHOD_PTR(REGEXTOKENIZER, Lucy_RegexTokenizer_Dump);
@@ -61,7 +61,7 @@ RegexTokenizer_dump(RegexTokenizer *self) {
 }
 
 RegexTokenizer*
-RegexTokenizer_load(RegexTokenizer *self, Obj *dump) {
+RegexTokenizer_Load_IMP(RegexTokenizer *self, Obj *dump) {
     Hash *source = (Hash*)CERTIFY(dump, HASH);
     RegexTokenizer_Load_t super_load
         = SUPER_METHOD_PTR(REGEXTOKENIZER, Lucy_RegexTokenizer_Load);
@@ -72,7 +72,7 @@ RegexTokenizer_load(RegexTokenizer *self, Obj *dump) {
 }
 
 bool
-RegexTokenizer_equals(RegexTokenizer *self, Obj *other) {
+RegexTokenizer_Equals_IMP(RegexTokenizer *self, Obj *other) {
     if ((RegexTokenizer*)other == self)                   { return true; }
     if (!Obj_Is_A(other, REGEXTOKENIZER))                 { return false; }
     RegexTokenizerIVARS *ivars = RegexTokenizer_IVARS(self);

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Analysis/SnowballStemmer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/SnowballStemmer.c b/core/Lucy/Analysis/SnowballStemmer.c
index 2229389..c048fda 100644
--- a/core/Lucy/Analysis/SnowballStemmer.c
+++ b/core/Lucy/Analysis/SnowballStemmer.c
@@ -51,7 +51,7 @@ SnowStemmer_init(SnowballStemmer *self, const CharBuf *language) {
 }
 
 void
-SnowStemmer_destroy(SnowballStemmer *self) {
+SnowStemmer_Destroy_IMP(SnowballStemmer *self) {
     SnowballStemmerIVARS *const ivars = SnowStemmer_IVARS(self);
     if (ivars->snowstemmer) {
         sb_stemmer_delete((struct sb_stemmer*)ivars->snowstemmer);
@@ -61,7 +61,7 @@ SnowStemmer_destroy(SnowballStemmer *self) {
 }
 
 Inversion*
-SnowStemmer_transform(SnowballStemmer *self, Inversion *inversion) {
+SnowStemmer_Transform_IMP(SnowballStemmer *self, Inversion *inversion) {
     Token *token;
     SnowballStemmerIVARS *const ivars = SnowStemmer_IVARS(self);
     struct sb_stemmer *const snowstemmer
@@ -85,7 +85,7 @@ SnowStemmer_transform(SnowballStemmer *self, Inversion *inversion) {
 }
 
 Hash*
-SnowStemmer_dump(SnowballStemmer *self) {
+SnowStemmer_Dump_IMP(SnowballStemmer *self) {
     SnowballStemmerIVARS *const ivars = SnowStemmer_IVARS(self);
     SnowStemmer_Dump_t super_dump
         = SUPER_METHOD_PTR(SNOWBALLSTEMMER, Lucy_SnowStemmer_Dump);
@@ -95,7 +95,7 @@ SnowStemmer_dump(SnowballStemmer *self) {
 }
 
 SnowballStemmer*
-SnowStemmer_load(SnowballStemmer *self, Obj *dump) {
+SnowStemmer_Load_IMP(SnowballStemmer *self, Obj *dump) {
     SnowStemmer_Load_t super_load
         = SUPER_METHOD_PTR(SNOWBALLSTEMMER, Lucy_SnowStemmer_Load);
     SnowballStemmer *loaded = super_load(self, dump);
@@ -106,7 +106,7 @@ SnowStemmer_load(SnowballStemmer *self, Obj *dump) {
 }
 
 bool
-SnowStemmer_equals(SnowballStemmer *self, Obj *other) {
+SnowStemmer_Equals_IMP(SnowballStemmer *self, Obj *other) {
     if ((SnowballStemmer*)other == self)                    { return true; }
     if (!Obj_Is_A(other, SNOWBALLSTEMMER))                  { return false; }
     SnowballStemmerIVARS *ivars = SnowStemmer_IVARS(self);

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Analysis/SnowballStopFilter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/SnowballStopFilter.c b/core/Lucy/Analysis/SnowballStopFilter.c
index b764f70..8a299c8 100644
--- a/core/Lucy/Analysis/SnowballStopFilter.c
+++ b/core/Lucy/Analysis/SnowballStopFilter.c
@@ -54,14 +54,14 @@ SnowStop_init(SnowballStopFilter *self, const CharBuf *language,
 }
 
 void
-SnowStop_destroy(SnowballStopFilter *self) {
+SnowStop_Destroy_IMP(SnowballStopFilter *self) {
     SnowballStopFilterIVARS *const ivars = SnowStop_IVARS(self);
     DECREF(ivars->stoplist);
     SUPER_DESTROY(self, SNOWBALLSTOPFILTER);
 }
 
 Inversion*
-SnowStop_transform(SnowballStopFilter *self, Inversion *inversion) {
+SnowStop_Transform_IMP(SnowballStopFilter *self, Inversion *inversion) {
     Token *token;
     Inversion *new_inversion = Inversion_new(NULL);
     SnowballStopFilterIVARS *const ivars = SnowStop_IVARS(self);
@@ -78,7 +78,7 @@ SnowStop_transform(SnowballStopFilter *self, Inversion *inversion) {
 }
 
 bool
-SnowStop_equals(SnowballStopFilter *self, Obj *other) {
+SnowStop_Equals_IMP(SnowballStopFilter *self, Obj *other) {
     if ((SnowballStopFilter*)other == self)   { return true; }
     if (!Obj_Is_A(other, SNOWBALLSTOPFILTER)) { return false; }
     SnowballStopFilterIVARS *const ivars = SnowStop_IVARS(self);
@@ -91,8 +91,7 @@ SnowStop_equals(SnowballStopFilter *self, Obj *other) {
 }
 
 Obj*
-SnowStop_dump(SnowballStopFilter *self)
-{
+SnowStop_Dump_IMP(SnowballStopFilter *self) {
     SnowballStopFilterIVARS *ivars = SnowStop_IVARS(self);
     SnowStop_Dump_t super_dump
         = SUPER_METHOD_PTR(SNOWBALLSTOPFILTER, Lucy_SnowStop_Dump);
@@ -105,8 +104,7 @@ SnowStop_dump(SnowballStopFilter *self)
 }
 
 Obj*
-SnowStop_load(SnowballStopFilter *self, Obj *dump)
-{
+SnowStop_Load_IMP(SnowballStopFilter *self, Obj *dump) {
     Hash *source = (Hash*)CERTIFY(dump, HASH);
     SnowStop_Load_t super_load
         = SUPER_METHOD_PTR(SNOWBALLSTOPFILTER, Lucy_SnowStop_Load);
@@ -169,7 +167,7 @@ NoCloneHash_init(NoCloneHash *self, uint32_t capacity) {
 }
 
 Obj*
-NoCloneHash_make_key(NoCloneHash *self, Obj *key, int32_t hash_sum) {
+NoCloneHash_Make_Key_IMP(NoCloneHash *self, Obj *key, int32_t hash_sum) {
     UNUSED_VAR(self);
     UNUSED_VAR(hash_sum);
     return INCREF(key);

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Analysis/StandardTokenizer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/StandardTokenizer.c b/core/Lucy/Analysis/StandardTokenizer.c
index 61a19a1..9a02c48 100644
--- a/core/Lucy/Analysis/StandardTokenizer.c
+++ b/core/Lucy/Analysis/StandardTokenizer.c
@@ -81,7 +81,7 @@ StandardTokenizer_init(StandardTokenizer *self) {
 }
 
 Inversion*
-StandardTokenizer_transform(StandardTokenizer *self, Inversion *inversion) {
+StandardTokenizer_Transform_IMP(StandardTokenizer *self, Inversion *inversion) {
     Inversion *new_inversion = Inversion_new(NULL);
     Token *token;
 
@@ -95,7 +95,7 @@ StandardTokenizer_transform(StandardTokenizer *self, Inversion *inversion) {
 }
 
 Inversion*
-StandardTokenizer_transform_text(StandardTokenizer *self, CharBuf *text) {
+StandardTokenizer_Transform_Text_IMP(StandardTokenizer *self, CharBuf *text) {
     Inversion *new_inversion = Inversion_new(NULL);
     StandardTokenizer_Tokenize_Str(self, (char*)CB_Get_Ptr8(text),
                                    CB_Get_Size(text), new_inversion);
@@ -103,8 +103,8 @@ StandardTokenizer_transform_text(StandardTokenizer *self, CharBuf *text) {
 }
 
 void
-StandardTokenizer_tokenize_str(StandardTokenizer *self, const char *text,
-                               size_t len, Inversion *inversion) {
+StandardTokenizer_Tokenize_Str_IMP(StandardTokenizer *self, const char *text,
+                                   size_t len, Inversion *inversion) {
     UNUSED_VAR(self);
     if ((len >= 1 && (uint8_t)text[len - 1] >= 0xC0)
         ||  (len >= 2 && (uint8_t)text[len - 2] >= 0xE0)
@@ -293,7 +293,7 @@ S_skip_extend_format(const char *text, size_t len, lucy_StringIter *iter) {
 }
 
 bool
-StandardTokenizer_equals(StandardTokenizer *self, Obj *other) {
+StandardTokenizer_Equals_IMP(StandardTokenizer *self, Obj *other) {
     if ((StandardTokenizer*)other == self)   { return true; }
     if (!Obj_Is_A(other, STANDARDTOKENIZER)) { return false; }
     return true;

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Analysis/Token.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/Token.c b/core/Lucy/Analysis/Token.c
index b1b1665..a59f3aa 100644
--- a/core/Lucy/Analysis/Token.c
+++ b/core/Lucy/Analysis/Token.c
@@ -51,7 +51,7 @@ Token_init(Token *self, const char* text, size_t len, uint32_t start_offset,
 }
 
 void
-Token_destroy(Token *self) {
+Token_Destroy_IMP(Token *self) {
     TokenIVARS *const ivars = Token_IVARS(self);
     FREEMEM(ivars->text);
     SUPER_DESTROY(self, TOKEN);
@@ -80,42 +80,42 @@ Token_compare(void *context, const void *va, const void *vb) {
 }
 
 uint32_t
-Token_get_start_offset(Token *self) {
+Token_Get_Start_Offset_IMP(Token *self) {
     return Token_IVARS(self)->start_offset;
 }
 
 uint32_t
-Token_get_end_offset(Token *self) {
+Token_Get_End_Offset_IMP(Token *self) {
     return Token_IVARS(self)->end_offset;
 }
 
 float
-Token_get_boost(Token *self) {
+Token_Get_Boost_IMP(Token *self) {
     return Token_IVARS(self)->boost;
 }
 
 int32_t
-Token_get_pos_inc(Token *self) {
+Token_Get_Pos_Inc_IMP(Token *self) {
     return Token_IVARS(self)->pos_inc;
 }
 
 int32_t
-Token_get_pos(Token *self) {
+Token_Get_Pos_IMP(Token *self) {
     return Token_IVARS(self)->pos;
 }
 
 char*
-Token_get_text(Token *self) {
+Token_Get_Text_IMP(Token *self) {
     return Token_IVARS(self)->text;
 }
 
 size_t
-Token_get_len(Token *self) {
+Token_Get_Len_IMP(Token *self) {
     return Token_IVARS(self)->len;
 }
 
 void
-Token_set_text(Token *self, char *text, size_t len) {
+Token_Set_Text_IMP(Token *self, char *text, size_t len) {
     TokenIVARS *const ivars = Token_IVARS(self);
     if (len > ivars->len) {
         FREEMEM(ivars->text);

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Document/Doc.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Document/Doc.c b/core/Lucy/Document/Doc.c
index 6ad9996..157051c 100644
--- a/core/Lucy/Document/Doc.c
+++ b/core/Lucy/Document/Doc.c
@@ -26,17 +26,17 @@ Doc_new(void *fields, int32_t doc_id) {
 }
 
 void
-Doc_set_doc_id(Doc *self, int32_t doc_id) {
+Doc_Set_Doc_ID_IMP(Doc *self, int32_t doc_id) {
     Doc_IVARS(self)->doc_id = doc_id;
 }
 
 int32_t
-Doc_get_doc_id(Doc *self) {
+Doc_Get_Doc_ID_IMP(Doc *self) {
     return Doc_IVARS(self)->doc_id;
 }
 
 void*
-Doc_get_fields(Doc *self) {
+Doc_Get_Fields_IMP(Doc *self) {
     return Doc_IVARS(self)->fields;
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Document/HitDoc.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Document/HitDoc.c b/core/Lucy/Document/HitDoc.c
index 45c64e5..a884772 100644
--- a/core/Lucy/Document/HitDoc.c
+++ b/core/Lucy/Document/HitDoc.c
@@ -36,17 +36,17 @@ HitDoc_init(HitDoc *self, void *fields, int32_t doc_id, float score) {
 }
 
 void
-HitDoc_set_score(HitDoc *self, float score) {
+HitDoc_Set_Score_IMP(HitDoc *self, float score) {
     HitDoc_IVARS(self)->score = score;
 }
 
 float
-HitDoc_get_score(HitDoc *self) {
+HitDoc_Get_Score_IMP(HitDoc *self) {
     return HitDoc_IVARS(self)->score;
 }
 
 void
-HitDoc_serialize(HitDoc *self, OutStream *outstream) {
+HitDoc_Serialize_IMP(HitDoc *self, OutStream *outstream) {
     HitDocIVARS *const ivars = HitDoc_IVARS(self);
     HitDoc_Serialize_t super_serialize
         = SUPER_METHOD_PTR(HITDOC, Lucy_HitDoc_Serialize);
@@ -55,7 +55,7 @@ HitDoc_serialize(HitDoc *self, OutStream *outstream) {
 }
 
 HitDoc*
-HitDoc_deserialize(HitDoc *self, InStream *instream) {
+HitDoc_Deserialize_IMP(HitDoc *self, InStream *instream) {
     HitDoc_Deserialize_t super_deserialize
         = SUPER_METHOD_PTR(HITDOC, Lucy_HitDoc_Deserialize);
     self = super_deserialize(self, instream);
@@ -65,7 +65,7 @@ HitDoc_deserialize(HitDoc *self, InStream *instream) {
 }
 
 Hash*
-HitDoc_dump(HitDoc *self) {
+HitDoc_Dump_IMP(HitDoc *self) {
     HitDocIVARS *const ivars = HitDoc_IVARS(self);
     HitDoc_Dump_t super_dump
         = SUPER_METHOD_PTR(HITDOC, Lucy_HitDoc_Dump);
@@ -75,7 +75,7 @@ HitDoc_dump(HitDoc *self) {
 }
 
 HitDoc*
-HitDoc_load(HitDoc *self, Obj *dump) {
+HitDoc_Load_IMP(HitDoc *self, Obj *dump) {
     Hash *source = (Hash*)CERTIFY(dump, HASH);
     HitDoc_Load_t super_load
         = SUPER_METHOD_PTR(HITDOC, Lucy_HitDoc_Load);
@@ -87,7 +87,7 @@ HitDoc_load(HitDoc *self, Obj *dump) {
 }
 
 bool
-HitDoc_equals(HitDoc *self, Obj *other) {
+HitDoc_Equals_IMP(HitDoc *self, Obj *other) {
     if ((HitDoc*)other == self)           { return true;  }
     if (!Obj_Is_A(other, HITDOC))         { return false; }
     if (!Doc_equals((Doc*)self, other))   { return false; }

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Highlight/HeatMap.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Highlight/HeatMap.c b/core/Lucy/Highlight/HeatMap.c
index 114bbbe..92695ac 100644
--- a/core/Lucy/Highlight/HeatMap.c
+++ b/core/Lucy/Highlight/HeatMap.c
@@ -49,7 +49,7 @@ HeatMap_init(HeatMap *self, VArray *spans, uint32_t window) {
 }
 
 void
-HeatMap_destroy(HeatMap *self) {
+HeatMap_Destroy_IMP(HeatMap *self) {
     HeatMapIVARS *const ivars = HeatMap_IVARS(self);
     DECREF(ivars->spans);
     SUPER_DESTROY(self, HEATMAP);
@@ -98,7 +98,7 @@ S_flattened_but_empty_spans(VArray *spans) {
 }
 
 VArray*
-HeatMap_flatten_spans(HeatMap *self, VArray *spans) {
+HeatMap_Flatten_Spans_IMP(HeatMap *self, VArray *spans) {
     const uint32_t num_spans = VA_Get_Size(spans);
     UNUSED_VAR(self);
 
@@ -156,7 +156,7 @@ HeatMap_flatten_spans(HeatMap *self, VArray *spans) {
 }
 
 float
-HeatMap_calc_proximity_boost(HeatMap *self, Span *span1, Span *span2) {
+HeatMap_Calc_Proximity_Boost_IMP(HeatMap *self, Span *span1, Span *span2) {
     HeatMapIVARS *const ivars = HeatMap_IVARS(self);
     int32_t comparison = Span_Compare_To(span1, (Obj*)span2);
     Span *lower = comparison <= 0 ? span1 : span2;
@@ -179,7 +179,7 @@ HeatMap_calc_proximity_boost(HeatMap *self, Span *span1, Span *span2) {
 }
 
 VArray*
-HeatMap_generate_proximity_boosts(HeatMap *self, VArray *spans) {
+HeatMap_Generate_Proximity_Boosts_IMP(HeatMap *self, VArray *spans) {
     VArray *boosts = VA_new(0);
     const uint32_t num_spans = VA_Get_Size(spans);
 
@@ -210,7 +210,7 @@ HeatMap_generate_proximity_boosts(HeatMap *self, VArray *spans) {
 }
 
 VArray*
-HeatMap_get_spans(HeatMap *self) {
+HeatMap_Get_Spans_IMP(HeatMap *self) {
     return HeatMap_IVARS(self)->spans;
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Highlight/Highlighter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Highlight/Highlighter.c b/core/Lucy/Highlight/Highlighter.c
index 1e43b21..81fea17 100644
--- a/core/Lucy/Highlight/Highlighter.c
+++ b/core/Lucy/Highlight/Highlighter.c
@@ -74,7 +74,7 @@ Highlighter_init(Highlighter *self, Searcher *searcher, Obj *query,
 }
 
 void
-Highlighter_destroy(Highlighter *self) {
+Highlighter_Destroy_IMP(Highlighter *self) {
     HighlighterIVARS *const ivars = Highlighter_IVARS(self);
     DECREF(ivars->searcher);
     DECREF(ivars->query);
@@ -86,7 +86,7 @@ Highlighter_destroy(Highlighter *self) {
 }
 
 CharBuf*
-Highlighter_highlight(Highlighter *self, const CharBuf *text) {
+Highlighter_Highlight_IMP(Highlighter *self, const CharBuf *text) {
     HighlighterIVARS *const ivars = Highlighter_IVARS(self);
     size_t size = CB_Get_Size(text)
                   + CB_Get_Size(ivars->pre_tag)
@@ -99,54 +99,54 @@ Highlighter_highlight(Highlighter *self, const CharBuf *text) {
 }
 
 void
-Highlighter_set_pre_tag(Highlighter *self, const CharBuf *pre_tag) {
+Highlighter_Set_Pre_Tag_IMP(Highlighter *self, const CharBuf *pre_tag) {
     HighlighterIVARS *const ivars = Highlighter_IVARS(self);
     CB_Mimic(ivars->pre_tag, (Obj*)pre_tag);
 }
 
 void
-Highlighter_set_post_tag(Highlighter *self, const CharBuf *post_tag) {
+Highlighter_Set_Post_Tag_IMP(Highlighter *self, const CharBuf *post_tag) {
     HighlighterIVARS *const ivars = Highlighter_IVARS(self);
     CB_Mimic(ivars->post_tag, (Obj*)post_tag);
 }
 
 CharBuf*
-Highlighter_get_pre_tag(Highlighter *self) {
+Highlighter_Get_Pre_Tag_IMP(Highlighter *self) {
     return Highlighter_IVARS(self)->pre_tag;
 }
 
 CharBuf*
-Highlighter_get_post_tag(Highlighter *self) {
+Highlighter_Get_Post_Tag_IMP(Highlighter *self) {
     return Highlighter_IVARS(self)->post_tag;
 }
 
 CharBuf*
-Highlighter_get_field(Highlighter *self) {
+Highlighter_Get_Field_IMP(Highlighter *self) {
     return Highlighter_IVARS(self)->field;
 }
 
 Query*
-Highlighter_get_query(Highlighter *self) {
+Highlighter_Get_Query_IMP(Highlighter *self) {
     return Highlighter_IVARS(self)->query;
 }
 
 Searcher*
-Highlighter_get_searcher(Highlighter *self) {
+Highlighter_Get_Searcher_IMP(Highlighter *self) {
     return Highlighter_IVARS(self)->searcher;
 }
 
 Compiler*
-Highlighter_get_compiler(Highlighter *self) {
+Highlighter_Get_Compiler_IMP(Highlighter *self) {
     return Highlighter_IVARS(self)->compiler;
 }
 
 uint32_t
-Highlighter_get_excerpt_length(Highlighter *self) {
+Highlighter_Get_Excerpt_Length_IMP(Highlighter *self) {
     return Highlighter_IVARS(self)->excerpt_length;
 }
 
 CharBuf*
-Highlighter_create_excerpt(Highlighter *self, HitDoc *hit_doc) {
+Highlighter_Create_Excerpt_IMP(Highlighter *self, HitDoc *hit_doc) {
     HighlighterIVARS *const ivars = Highlighter_IVARS(self);
     ZombieCharBuf *field_val
         = (ZombieCharBuf*)HitDoc_Extract(hit_doc, ivars->field,
@@ -212,8 +212,9 @@ S_hottest(HeatMap *heat_map) {
 }
 
 int32_t
-Highlighter_find_best_fragment(Highlighter *self, const CharBuf *field_val,
-                               ViewCharBuf *fragment, HeatMap *heat_map) {
+Highlighter_Find_Best_Fragment_IMP(Highlighter *self,
+                                   const CharBuf *field_val,
+                                   ViewCharBuf *fragment, HeatMap *heat_map) {
     HighlighterIVARS *const ivars = Highlighter_IVARS(self);
 
     // Window is 1.66 * excerpt_length, with the loc in the middle.
@@ -288,9 +289,10 @@ S_has_heat(HeatMap *heat_map, int32_t offset, int32_t length) {
 }
 
 int32_t
-Highlighter_raw_excerpt(Highlighter *self, const CharBuf *field_val,
-                        const CharBuf *fragment, CharBuf *raw_excerpt,
-                        int32_t top, HeatMap *heat_map, VArray *sentences) {
+Highlighter_Raw_Excerpt_IMP(Highlighter *self, const CharBuf *field_val,
+                            const CharBuf *fragment, CharBuf *raw_excerpt,
+                            int32_t top, HeatMap *heat_map,
+                            VArray *sentences) {
     HighlighterIVARS *const ivars = Highlighter_IVARS(self);
     bool     found_starting_edge = false;
     bool     found_ending_edge   = false;
@@ -489,9 +491,9 @@ Highlighter_raw_excerpt(Highlighter *self, const CharBuf *field_val,
 }
 
 void
-Highlighter_highlight_excerpt(Highlighter *self, VArray *spans,
-                              CharBuf *raw_excerpt, CharBuf *highlighted,
-                              int32_t top) {
+Highlighter_Highlight_Excerpt_IMP(Highlighter *self, VArray *spans,
+                                  CharBuf *raw_excerpt, CharBuf *highlighted,
+                                  int32_t top) {
     int32_t        hl_start        = 0;
     int32_t        hl_end          = 0;
     ZombieCharBuf *temp            = ZCB_WRAP(raw_excerpt);
@@ -589,8 +591,8 @@ S_close_sentence(VArray *sentences, Span **sentence_ptr,
 }
 
 VArray*
-Highlighter_find_sentences(Highlighter *self, CharBuf *text, int32_t offset,
-                           int32_t length) {
+Highlighter_Find_Sentences_IMP(Highlighter *self, CharBuf *text,
+                               int32_t offset, int32_t length) {
     /* When [sentence] is NULL, that means a sentence start has not yet been
      * found.  When it is a Span object, we have a start, but we haven't found
      * an end.  Once we find the end, we add the sentence to the [sentences]
@@ -670,7 +672,7 @@ Highlighter_find_sentences(Highlighter *self, CharBuf *text, int32_t offset,
 }
 
 CharBuf*
-Highlighter_encode(Highlighter *self, CharBuf *text) {
+Highlighter_Encode_IMP(Highlighter *self, CharBuf *text) {
     CharBuf *encoded = CB_new(0);
     UNUSED_VAR(self);
     return S_encode_entities(text, encoded);

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Index/BackgroundMerger.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/BackgroundMerger.c b/core/Lucy/Index/BackgroundMerger.c
index 5f219ce..53a88ba 100644
--- a/core/Lucy/Index/BackgroundMerger.c
+++ b/core/Lucy/Index/BackgroundMerger.c
@@ -155,7 +155,7 @@ BGMerger_init(BackgroundMerger *self, Obj *index, IndexManager *manager) {
 }
 
 void
-BGMerger_destroy(BackgroundMerger *self) {
+BGMerger_Destroy_IMP(BackgroundMerger *self) {
     BackgroundMergerIVARS *const ivars = BGMerger_IVARS(self);
     S_release_merge_lock(self);
     S_release_write_lock(self);
@@ -198,7 +198,7 @@ S_init_folder(Obj *index) {
 }
 
 void
-BGMerger_optimize(BackgroundMerger *self) {
+BGMerger_Optimize_IMP(BackgroundMerger *self) {
     BGMerger_IVARS(self)->optimize = true;
 }
 
@@ -368,7 +368,7 @@ S_merge_updated_deletions(BackgroundMerger *self) {
 }
 
 void
-BGMerger_prepare_commit(BackgroundMerger *self) {
+BGMerger_Prepare_Commit_IMP(BackgroundMerger *self) {
     BackgroundMergerIVARS *const ivars = BGMerger_IVARS(self);
     VArray   *seg_readers     = PolyReader_Get_Seg_Readers(ivars->polyreader);
     uint32_t  num_seg_readers = VA_Get_Size(seg_readers);
@@ -469,7 +469,7 @@ BGMerger_prepare_commit(BackgroundMerger *self) {
 }
 
 void
-BGMerger_commit(BackgroundMerger *self) {
+BGMerger_Commit_IMP(BackgroundMerger *self) {
     BackgroundMergerIVARS *const ivars = BGMerger_IVARS(self);
 
     // Safety check.

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Index/BitVecDelDocs.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/BitVecDelDocs.c b/core/Lucy/Index/BitVecDelDocs.c
index e0dac0e..3c1aeff 100644
--- a/core/Lucy/Index/BitVecDelDocs.c
+++ b/core/Lucy/Index/BitVecDelDocs.c
@@ -46,7 +46,7 @@ BitVecDelDocs_init(BitVecDelDocs *self, Folder *folder,
 }
 
 void
-BitVecDelDocs_destroy(BitVecDelDocs *self) {
+BitVecDelDocs_Destroy_IMP(BitVecDelDocs *self) {
     BitVecDelDocsIVARS *const ivars = BitVecDelDocs_IVARS(self);
     DECREF(ivars->filename);
     if (ivars->instream) {

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Index/DataReader.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DataReader.c b/core/Lucy/Index/DataReader.c
index 3404dcf..4a2879a 100644
--- a/core/Lucy/Index/DataReader.c
+++ b/core/Lucy/Index/DataReader.c
@@ -54,7 +54,7 @@ DataReader_init(DataReader *self, Schema *schema, Folder *folder,
 }
 
 void
-DataReader_destroy(DataReader *self) {
+DataReader_Destroy_IMP(DataReader *self) {
     DataReaderIVARS *const ivars = DataReader_IVARS(self);
     DECREF(ivars->schema);
     DECREF(ivars->folder);
@@ -65,32 +65,32 @@ DataReader_destroy(DataReader *self) {
 }
 
 Schema*
-DataReader_get_schema(DataReader *self) {
+DataReader_Get_Schema_IMP(DataReader *self) {
     return DataReader_IVARS(self)->schema;
 }
 
 Folder*
-DataReader_get_folder(DataReader *self) {
+DataReader_Get_Folder_IMP(DataReader *self) {
     return DataReader_IVARS(self)->folder;
 }
 
 Snapshot*
-DataReader_get_snapshot(DataReader *self) {
+DataReader_Get_Snapshot_IMP(DataReader *self) {
     return DataReader_IVARS(self)->snapshot;
 }
 
 VArray*
-DataReader_get_segments(DataReader *self) {
+DataReader_Get_Segments_IMP(DataReader *self) {
     return DataReader_IVARS(self)->segments;
 }
 
 int32_t
-DataReader_get_seg_tick(DataReader *self) {
+DataReader_Get_Seg_Tick_IMP(DataReader *self) {
     return DataReader_IVARS(self)->seg_tick;
 }
 
 Segment*
-DataReader_get_segment(DataReader *self) {
+DataReader_Get_Segment_IMP(DataReader *self) {
     return DataReader_IVARS(self)->segment;
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Index/DataWriter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DataWriter.c b/core/Lucy/Index/DataWriter.c
index 3177ed6..8f211f9 100644
--- a/core/Lucy/Index/DataWriter.c
+++ b/core/Lucy/Index/DataWriter.c
@@ -40,7 +40,7 @@ DataWriter_init(DataWriter *self, Schema *schema, Snapshot *snapshot,
 }
 
 void
-DataWriter_destroy(DataWriter *self) {
+DataWriter_Destroy_IMP(DataWriter *self) {
     DataWriterIVARS *const ivars = DataWriter_IVARS(self);
     DECREF(ivars->snapshot);
     DECREF(ivars->segment);
@@ -51,45 +51,45 @@ DataWriter_destroy(DataWriter *self) {
 }
 
 Snapshot*
-DataWriter_get_snapshot(DataWriter *self) {
+DataWriter_Get_Snapshot_IMP(DataWriter *self) {
     return DataWriter_IVARS(self)->snapshot;
 }
 
 Segment*
-DataWriter_get_segment(DataWriter *self) {
+DataWriter_Get_Segment_IMP(DataWriter *self) {
     return DataWriter_IVARS(self)->segment;
 }
 
 PolyReader*
-DataWriter_get_polyreader(DataWriter *self) {
+DataWriter_Get_PolyReader_IMP(DataWriter *self) {
     return DataWriter_IVARS(self)->polyreader;
 }
 
 Schema*
-DataWriter_get_schema(DataWriter *self) {
+DataWriter_Get_Schema_IMP(DataWriter *self) {
     return DataWriter_IVARS(self)->schema;
 }
 
 Folder*
-DataWriter_get_folder(DataWriter *self) {
+DataWriter_Get_Folder_IMP(DataWriter *self) {
     return DataWriter_IVARS(self)->folder;
 }
 
 void
-DataWriter_delete_segment(DataWriter *self, SegReader *reader) {
+DataWriter_Delete_Segment_IMP(DataWriter *self, SegReader *reader) {
     UNUSED_VAR(self);
     UNUSED_VAR(reader);
 }
 
 void
-DataWriter_merge_segment(DataWriter *self, SegReader *reader,
-                         I32Array *doc_map) {
+DataWriter_Merge_Segment_IMP(DataWriter *self, SegReader *reader,
+                             I32Array *doc_map) {
     DataWriter_Add_Segment(self, reader, doc_map);
     DataWriter_Delete_Segment(self, reader);
 }
 
 Hash*
-DataWriter_metadata(DataWriter *self) {
+DataWriter_Metadata_IMP(DataWriter *self) {
     Hash *metadata = Hash_new(0);
     Hash_Store_Str(metadata, "format", 6,
                    (Obj*)CB_newf("%i32", DataWriter_Format(self)));

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Index/DeletionsReader.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DeletionsReader.c b/core/Lucy/Index/DeletionsReader.c
index ef45ebd..37946f1 100644
--- a/core/Lucy/Index/DeletionsReader.c
+++ b/core/Lucy/Index/DeletionsReader.c
@@ -41,8 +41,8 @@ DelReader_init(DeletionsReader *self, Schema *schema, Folder *folder,
 }
 
 DeletionsReader*
-DelReader_aggregator(DeletionsReader *self, VArray *readers,
-                     I32Array *offsets) {
+DelReader_Aggregator_IMP(DeletionsReader *self, VArray *readers,
+                         I32Array *offsets) {
     UNUSED_VAR(self);
     return (DeletionsReader*)PolyDelReader_new(readers, offsets);
 }
@@ -71,7 +71,7 @@ PolyDelReader_init(PolyDeletionsReader *self, VArray *readers,
 }
 
 void
-PolyDelReader_close(PolyDeletionsReader *self) {
+PolyDelReader_Close_IMP(PolyDeletionsReader *self) {
     PolyDeletionsReaderIVARS *const ivars = PolyDelReader_IVARS(self);
     if (ivars->readers) {
         for (uint32_t i = 0, max = VA_Get_Size(ivars->readers); i < max; i++) {
@@ -84,7 +84,7 @@ PolyDelReader_close(PolyDeletionsReader *self) {
 }
 
 void
-PolyDelReader_destroy(PolyDeletionsReader *self) {
+PolyDelReader_Destroy_IMP(PolyDeletionsReader *self) {
     PolyDeletionsReaderIVARS *const ivars = PolyDelReader_IVARS(self);
     DECREF(ivars->readers);
     DECREF(ivars->offsets);
@@ -92,12 +92,12 @@ PolyDelReader_destroy(PolyDeletionsReader *self) {
 }
 
 int32_t
-PolyDelReader_del_count(PolyDeletionsReader *self) {
+PolyDelReader_Del_Count_IMP(PolyDeletionsReader *self) {
     return PolyDelReader_IVARS(self)->del_count;
 }
 
 Matcher*
-PolyDelReader_iterator(PolyDeletionsReader *self) {
+PolyDelReader_Iterator_IMP(PolyDeletionsReader *self) {
     PolyDeletionsReaderIVARS *const ivars = PolyDelReader_IVARS(self);
     SeriesMatcher *deletions = NULL;
     if (ivars->del_count) {
@@ -140,21 +140,21 @@ DefDelReader_init(DefaultDeletionsReader *self, Schema *schema,
 }
 
 void
-DefDelReader_close(DefaultDeletionsReader *self) {
+DefDelReader_Close_IMP(DefaultDeletionsReader *self) {
     DefaultDeletionsReaderIVARS *const ivars = DefDelReader_IVARS(self);
     DECREF(ivars->deldocs);
     ivars->deldocs = NULL;
 }
 
 void
-DefDelReader_destroy(DefaultDeletionsReader *self) {
+DefDelReader_Destroy_IMP(DefaultDeletionsReader *self) {
     DefaultDeletionsReaderIVARS *const ivars = DefDelReader_IVARS(self);
     DECREF(ivars->deldocs);
     SUPER_DESTROY(self, DEFAULTDELETIONSREADER);
 }
 
 BitVector*
-DefDelReader_read_deletions(DefaultDeletionsReader *self) {
+DefDelReader_Read_Deletions_IMP(DefaultDeletionsReader *self) {
     DefaultDeletionsReaderIVARS *const ivars = DefDelReader_IVARS(self);
     VArray  *segments    = DefDelReader_Get_Segments(self);
     Segment *segment     = DefDelReader_Get_Segment(self);
@@ -201,13 +201,13 @@ DefDelReader_read_deletions(DefaultDeletionsReader *self) {
 }
 
 Matcher*
-DefDelReader_iterator(DefaultDeletionsReader *self) {
+DefDelReader_Iterator_IMP(DefaultDeletionsReader *self) {
     DefaultDeletionsReaderIVARS *const ivars = DefDelReader_IVARS(self);
     return (Matcher*)BitVecMatcher_new(ivars->deldocs);
 }
 
 int32_t
-DefDelReader_del_count(DefaultDeletionsReader *self) {
+DefDelReader_Del_Count_IMP(DefaultDeletionsReader *self) {
     return DefDelReader_IVARS(self)->del_count;
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Index/DeletionsWriter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DeletionsWriter.c b/core/Lucy/Index/DeletionsWriter.c
index 759c6de..a7874e5 100644
--- a/core/Lucy/Index/DeletionsWriter.c
+++ b/core/Lucy/Index/DeletionsWriter.c
@@ -47,8 +47,8 @@ DelWriter_init(DeletionsWriter *self, Schema *schema, Snapshot *snapshot,
 }
 
 I32Array*
-DelWriter_generate_doc_map(DeletionsWriter *self, Matcher *deletions,
-                           int32_t doc_max, int32_t offset) {
+DelWriter_Generate_Doc_Map_IMP(DeletionsWriter *self, Matcher *deletions,
+                               int32_t doc_max, int32_t offset) {
     int32_t *doc_map = (int32_t*)CALLOCATE(doc_max + 1, sizeof(int32_t));
     int32_t  next_deletion = deletions ? Matcher_Next(deletions) : INT32_MAX;
     UNUSED_VAR(self);
@@ -119,7 +119,7 @@ DefDelWriter_init(DefaultDeletionsWriter *self, Schema *schema,
 }
 
 void
-DefDelWriter_destroy(DefaultDeletionsWriter *self) {
+DefDelWriter_Destroy_IMP(DefaultDeletionsWriter *self) {
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
     DECREF(ivars->seg_readers);
     DECREF(ivars->seg_starts);
@@ -139,7 +139,7 @@ S_del_filename(DefaultDeletionsWriter *self, SegReader *target_reader) {
 }
 
 void
-DefDelWriter_finish(DefaultDeletionsWriter *self) {
+DefDelWriter_Finish_IMP(DefaultDeletionsWriter *self) {
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
     Folder *const folder = ivars->folder;
 
@@ -173,7 +173,7 @@ DefDelWriter_finish(DefaultDeletionsWriter *self) {
 }
 
 Hash*
-DefDelWriter_metadata(DefaultDeletionsWriter *self) {
+DefDelWriter_Metadata_IMP(DefaultDeletionsWriter *self) {
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
     Hash    *const metadata = DataWriter_metadata((DataWriter*)self);
     Hash    *const files    = Hash_new(0);
@@ -197,14 +197,14 @@ DefDelWriter_metadata(DefaultDeletionsWriter *self) {
 }
 
 int32_t
-DefDelWriter_format(DefaultDeletionsWriter *self) {
+DefDelWriter_Format_IMP(DefaultDeletionsWriter *self) {
     UNUSED_VAR(self);
     return DefDelWriter_current_file_format;
 }
 
 Matcher*
-DefDelWriter_seg_deletions(DefaultDeletionsWriter *self,
-                           SegReader *seg_reader) {
+DefDelWriter_Seg_Deletions_IMP(DefaultDeletionsWriter *self,
+                               SegReader *seg_reader) {
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
     Matcher *deletions    = NULL;
     Segment *segment      = SegReader_Get_Segment(seg_reader);
@@ -233,8 +233,8 @@ DefDelWriter_seg_deletions(DefaultDeletionsWriter *self,
 }
 
 int32_t
-DefDelWriter_seg_del_count(DefaultDeletionsWriter *self,
-                           const CharBuf *seg_name) {
+DefDelWriter_Seg_Del_Count_IMP(DefaultDeletionsWriter *self,
+                               const CharBuf *seg_name) {
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
     Integer32 *tick
         = (Integer32*)Hash_Fetch(ivars->name_to_tick, (Obj*)seg_name);
@@ -245,8 +245,8 @@ DefDelWriter_seg_del_count(DefaultDeletionsWriter *self,
 }
 
 void
-DefDelWriter_delete_by_term(DefaultDeletionsWriter *self,
-                            const CharBuf *field, Obj *term) {
+DefDelWriter_Delete_By_Term_IMP(DefaultDeletionsWriter *self,
+                                const CharBuf *field, Obj *term) {
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
     for (uint32_t i = 0, max = VA_Get_Size(ivars->seg_readers); i < max; i++) {
         SegReader *seg_reader = (SegReader*)VA_Fetch(ivars->seg_readers, i);
@@ -273,7 +273,7 @@ DefDelWriter_delete_by_term(DefaultDeletionsWriter *self,
 }
 
 void
-DefDelWriter_delete_by_query(DefaultDeletionsWriter *self, Query *query) {
+DefDelWriter_Delete_By_Query_IMP(DefaultDeletionsWriter *self, Query *query) {
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
     Compiler *compiler = Query_Make_Compiler(query, (Searcher*)ivars->searcher,
                                              Query_Get_Boost(query), false);
@@ -302,7 +302,7 @@ DefDelWriter_delete_by_query(DefaultDeletionsWriter *self, Query *query) {
 }
 
 void
-DefDelWriter_delete_by_doc_id(DefaultDeletionsWriter *self, int32_t doc_id) {
+DefDelWriter_Delete_By_Doc_ID_IMP(DefaultDeletionsWriter *self, int32_t doc_id) {
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
     uint32_t   sub_tick   = PolyReader_sub_tick(ivars->seg_starts, doc_id);
     BitVector *bit_vec    = (BitVector*)VA_Fetch(ivars->bit_vecs, sub_tick);
@@ -316,7 +316,7 @@ DefDelWriter_delete_by_doc_id(DefaultDeletionsWriter *self, int32_t doc_id) {
 }
 
 bool
-DefDelWriter_updated(DefaultDeletionsWriter *self) {
+DefDelWriter_Updated_IMP(DefaultDeletionsWriter *self) {
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
     for (uint32_t i = 0, max = VA_Get_Size(ivars->seg_readers); i < max; i++) {
         if (ivars->updated[i]) { return true; }
@@ -325,8 +325,8 @@ DefDelWriter_updated(DefaultDeletionsWriter *self) {
 }
 
 void
-DefDelWriter_add_segment(DefaultDeletionsWriter *self, SegReader *reader,
-                         I32Array *doc_map) {
+DefDelWriter_Add_Segment_IMP(DefaultDeletionsWriter *self, SegReader *reader,
+                             I32Array *doc_map) {
     // This method is a no-op, because the only reason it would be called is
     // if we are adding an entire index.  If that's the case, all deletes are
     // already being applied.
@@ -336,8 +336,8 @@ DefDelWriter_add_segment(DefaultDeletionsWriter *self, SegReader *reader,
 }
 
 void
-DefDelWriter_merge_segment(DefaultDeletionsWriter *self, SegReader *reader,
-                           I32Array *doc_map) {
+DefDelWriter_Merge_Segment_IMP(DefaultDeletionsWriter *self,
+                               SegReader *reader, I32Array *doc_map) {
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
     UNUSED_VAR(doc_map);
     Segment *segment = SegReader_Get_Segment(reader);

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Index/DocReader.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DocReader.c b/core/Lucy/Index/DocReader.c
index 24c8052..da09fc3 100644
--- a/core/Lucy/Index/DocReader.c
+++ b/core/Lucy/Index/DocReader.c
@@ -37,7 +37,8 @@ DocReader_init(DocReader *self, Schema *schema, Folder *folder,
 }
 
 DocReader*
-DocReader_aggregator(DocReader *self, VArray *readers, I32Array *offsets) {
+DocReader_Aggregator_IMP(DocReader *self, VArray *readers,
+                         I32Array *offsets) {
     UNUSED_VAR(self);
     return (DocReader*)PolyDocReader_new(readers, offsets);
 }
@@ -61,7 +62,7 @@ PolyDocReader_init(PolyDocReader *self, VArray *readers, I32Array *offsets) {
 }
 
 void
-PolyDocReader_close(PolyDocReader *self) {
+PolyDocReader_Close_IMP(PolyDocReader *self) {
     PolyDocReaderIVARS *const ivars = PolyDocReader_IVARS(self);
     if (ivars->readers) {
         for (uint32_t i = 0, max = VA_Get_Size(ivars->readers); i < max; i++) {
@@ -73,7 +74,7 @@ PolyDocReader_close(PolyDocReader *self) {
 }
 
 void
-PolyDocReader_destroy(PolyDocReader *self) {
+PolyDocReader_Destroy_IMP(PolyDocReader *self) {
     PolyDocReaderIVARS *const ivars = PolyDocReader_IVARS(self);
     DECREF(ivars->readers);
     DECREF(ivars->offsets);
@@ -81,7 +82,7 @@ PolyDocReader_destroy(PolyDocReader *self) {
 }
 
 HitDoc*
-PolyDocReader_fetch_doc(PolyDocReader *self, int32_t doc_id) {
+PolyDocReader_Fetch_Doc_IMP(PolyDocReader *self, int32_t doc_id) {
     PolyDocReaderIVARS *const ivars = PolyDocReader_IVARS(self);
     uint32_t seg_tick = PolyReader_sub_tick(ivars->offsets, doc_id);
     int32_t  offset   = I32Arr_Get(ivars->offsets, seg_tick);
@@ -107,7 +108,7 @@ DefDocReader_new(Schema *schema, Folder *folder, Snapshot *snapshot,
 }
 
 void
-DefDocReader_close(DefaultDocReader *self) {
+DefDocReader_Close_IMP(DefaultDocReader *self) {
     DefaultDocReaderIVARS *const ivars = DefDocReader_IVARS(self);
     if (ivars->dat_in != NULL) {
         InStream_Close(ivars->dat_in);
@@ -122,7 +123,7 @@ DefDocReader_close(DefaultDocReader *self) {
 }
 
 void
-DefDocReader_destroy(DefaultDocReader *self) {
+DefDocReader_Destroy_IMP(DefaultDocReader *self) {
     DefaultDocReaderIVARS *const ivars = DefDocReader_IVARS(self);
     DECREF(ivars->ix_in);
     DECREF(ivars->dat_in);
@@ -186,8 +187,8 @@ DefDocReader_init(DefaultDocReader *self, Schema *schema, Folder *folder,
 }
 
 void
-DefDocReader_read_record(DefaultDocReader *self, ByteBuf *buffer,
-                         int32_t doc_id) {
+DefDocReader_Read_Record_IMP(DefaultDocReader *self, ByteBuf *buffer,
+                             int32_t doc_id) {
     DefaultDocReaderIVARS *const ivars = DefDocReader_IVARS(self);
 
     // Find start and length of variable length record.

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Index/DocVector.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DocVector.c b/core/Lucy/Index/DocVector.c
index 131aaf4..8f01ddf 100644
--- a/core/Lucy/Index/DocVector.c
+++ b/core/Lucy/Index/DocVector.c
@@ -48,14 +48,14 @@ DocVec_init(DocVector *self) {
 }
 
 void
-DocVec_serialize(DocVector *self, OutStream *outstream) {
+DocVec_Serialize_IMP(DocVector *self, OutStream *outstream) {
     DocVectorIVARS *const ivars = DocVec_IVARS(self);
     Freezer_serialize_hash(ivars->field_bufs, outstream);
     Freezer_serialize_hash(ivars->field_vectors, outstream);
 }
 
 DocVector*
-DocVec_deserialize(DocVector *self, InStream *instream) {
+DocVec_Deserialize_IMP(DocVector *self, InStream *instream) {
     DocVectorIVARS *const ivars = DocVec_IVARS(self);
     ivars->field_bufs    = Freezer_read_hash(instream);
     ivars->field_vectors = Freezer_read_hash(instream);
@@ -63,7 +63,7 @@ DocVec_deserialize(DocVector *self, InStream *instream) {
 }
 
 void
-DocVec_destroy(DocVector *self) {
+DocVec_Destroy_IMP(DocVector *self) {
     DocVectorIVARS *const ivars = DocVec_IVARS(self);
     DECREF(ivars->field_bufs);
     DECREF(ivars->field_vectors);
@@ -71,27 +71,27 @@ DocVec_destroy(DocVector *self) {
 }
 
 void
-DocVec_add_field_buf(DocVector *self, const CharBuf *field,
-                     ByteBuf *field_buf) {
+DocVec_Add_Field_Buf_IMP(DocVector *self, const CharBuf *field,
+                         ByteBuf *field_buf) {
     DocVectorIVARS *const ivars = DocVec_IVARS(self);
     Hash_Store(ivars->field_bufs, (Obj*)field, INCREF(field_buf));
 }
 
 ByteBuf*
-DocVec_field_buf(DocVector *self, const CharBuf *field) {
+DocVec_Field_Buf_IMP(DocVector *self, const CharBuf *field) {
     DocVectorIVARS *const ivars = DocVec_IVARS(self);
     return (ByteBuf*)Hash_Fetch(ivars->field_bufs, (Obj*)field);
 }
 
 VArray*
-DocVec_field_names(DocVector *self) {
+DocVec_Field_Names_IMP(DocVector *self) {
     DocVectorIVARS *const ivars = DocVec_IVARS(self);
     return Hash_Keys(ivars->field_bufs);
 }
 
 TermVector*
-DocVec_term_vector(DocVector *self, const CharBuf *field,
-                   const CharBuf *term_text) {
+DocVec_Term_Vector_IMP(DocVector *self, const CharBuf *field,
+                       const CharBuf *term_text) {
     DocVectorIVARS *const ivars = DocVec_IVARS(self);
     Hash *field_vector = (Hash*)Hash_Fetch(ivars->field_vectors, (Obj*)field);
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Index/DocWriter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DocWriter.c b/core/Lucy/Index/DocWriter.c
index 0299de2..f9b8496 100644
--- a/core/Lucy/Index/DocWriter.c
+++ b/core/Lucy/Index/DocWriter.c
@@ -51,7 +51,7 @@ DocWriter_init(DocWriter *self, Schema *schema, Snapshot *snapshot,
 }
 
 void
-DocWriter_destroy(DocWriter *self) {
+DocWriter_Destroy_IMP(DocWriter *self) {
     DocWriterIVARS *const ivars = DocWriter_IVARS(self);
     DECREF(ivars->dat_out);
     DECREF(ivars->ix_out);
@@ -83,8 +83,8 @@ S_lazy_init(DocWriter *self) {
 }
 
 void
-DocWriter_add_inverted_doc(DocWriter *self, Inverter *inverter,
-                           int32_t doc_id) {
+DocWriter_Add_Inverted_Doc_IMP(DocWriter *self, Inverter *inverter,
+                               int32_t doc_id) {
     DocWriterIVARS *const ivars = DocWriter_IVARS(self);
     OutStream *dat_out    = S_lazy_init(self);
     OutStream *ix_out     = ivars->ix_out;
@@ -159,8 +159,8 @@ DocWriter_add_inverted_doc(DocWriter *self, Inverter *inverter,
 }
 
 void
-DocWriter_add_segment(DocWriter *self, SegReader *reader,
-                      I32Array *doc_map) {
+DocWriter_Add_Segment_IMP(DocWriter *self, SegReader *reader,
+                          I32Array *doc_map) {
     DocWriterIVARS *const ivars = DocWriter_IVARS(self);
     int32_t doc_max = SegReader_Doc_Max(reader);
 
@@ -197,7 +197,7 @@ DocWriter_add_segment(DocWriter *self, SegReader *reader,
 }
 
 void
-DocWriter_finish(DocWriter *self) {
+DocWriter_Finish_IMP(DocWriter *self) {
     DocWriterIVARS *const ivars = DocWriter_IVARS(self);
     if (ivars->dat_out) {
         // Write one final file pointer, so that we can derive the length of
@@ -214,7 +214,7 @@ DocWriter_finish(DocWriter *self) {
 }
 
 int32_t
-DocWriter_format(DocWriter *self) {
+DocWriter_Format_IMP(DocWriter *self) {
     UNUSED_VAR(self);
     return DocWriter_current_file_format;
 }

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Index/FilePurger.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/FilePurger.c b/core/Lucy/Index/FilePurger.c
index 35283ee..ada10b2 100644
--- a/core/Lucy/Index/FilePurger.c
+++ b/core/Lucy/Index/FilePurger.c
@@ -66,7 +66,7 @@ FilePurger_init(FilePurger *self, Folder *folder, Snapshot *snapshot,
 }
 
 void
-FilePurger_destroy(FilePurger *self) {
+FilePurger_Destroy_IMP(FilePurger *self) {
     FilePurgerIVARS *const ivars = FilePurger_IVARS(self);
     DECREF(ivars->folder);
     DECREF(ivars->snapshot);
@@ -76,7 +76,7 @@ FilePurger_destroy(FilePurger *self) {
 }
 
 void
-FilePurger_purge(FilePurger *self) {
+FilePurger_Purge_IMP(FilePurger *self) {
     FilePurgerIVARS *const ivars = FilePurger_IVARS(self);
     Lock *deletion_lock = IxManager_Make_Deletion_Lock(ivars->manager);
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Index/HighlightReader.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/HighlightReader.c b/core/Lucy/Index/HighlightReader.c
index 655a5e4..4f1f3b6 100644
--- a/core/Lucy/Index/HighlightReader.c
+++ b/core/Lucy/Index/HighlightReader.c
@@ -41,8 +41,8 @@ HLReader_init(HighlightReader *self, Schema *schema, Folder *folder,
 }
 
 HighlightReader*
-HLReader_aggregator(HighlightReader *self, VArray *readers,
-                    I32Array *offsets) {
+HLReader_Aggregator_IMP(HighlightReader *self, VArray *readers,
+                        I32Array *offsets) {
     UNUSED_VAR(self);
     return (HighlightReader*)PolyHLReader_new(readers, offsets);
 }
@@ -68,7 +68,7 @@ PolyHLReader_init(PolyHighlightReader *self, VArray *readers,
 }
 
 void
-PolyHLReader_close(PolyHighlightReader *self) {
+PolyHLReader_Close_IMP(PolyHighlightReader *self) {
     PolyHighlightReaderIVARS *const ivars = PolyHLReader_IVARS(self);
     if (ivars->readers) {
         for (uint32_t i = 0, max = VA_Get_Size(ivars->readers); i < max; i++) {
@@ -84,7 +84,7 @@ PolyHLReader_close(PolyHighlightReader *self) {
 }
 
 void
-PolyHLReader_destroy(PolyHighlightReader *self) {
+PolyHLReader_Destroy_IMP(PolyHighlightReader *self) {
     PolyHighlightReaderIVARS *const ivars = PolyHLReader_IVARS(self);
     DECREF(ivars->readers);
     DECREF(ivars->offsets);
@@ -92,7 +92,7 @@ PolyHLReader_destroy(PolyHighlightReader *self) {
 }
 
 DocVector*
-PolyHLReader_fetch_doc_vec(PolyHighlightReader *self, int32_t doc_id) {
+PolyHLReader_Fetch_Doc_Vec_IMP(PolyHighlightReader *self, int32_t doc_id) {
     PolyHighlightReaderIVARS *const ivars = PolyHLReader_IVARS(self);
     uint32_t seg_tick = PolyReader_sub_tick(ivars->offsets, doc_id);
     int32_t  offset   = I32Arr_Get(ivars->offsets, seg_tick);
@@ -165,7 +165,7 @@ DefHLReader_init(DefaultHighlightReader *self, Schema *schema,
 }
 
 void
-DefHLReader_close(DefaultHighlightReader *self) {
+DefHLReader_Close_IMP(DefaultHighlightReader *self) {
     DefaultHighlightReaderIVARS *const ivars = DefHLReader_IVARS(self);
     if (ivars->dat_in != NULL) {
         InStream_Close(ivars->dat_in);
@@ -180,7 +180,7 @@ DefHLReader_close(DefaultHighlightReader *self) {
 }
 
 void
-DefHLReader_destroy(DefaultHighlightReader *self) {
+DefHLReader_Destroy_IMP(DefaultHighlightReader *self) {
     DefaultHighlightReaderIVARS *const ivars = DefHLReader_IVARS(self);
     DECREF(ivars->ix_in);
     DECREF(ivars->dat_in);
@@ -188,7 +188,7 @@ DefHLReader_destroy(DefaultHighlightReader *self) {
 }
 
 DocVector*
-DefHLReader_fetch_doc_vec(DefaultHighlightReader *self, int32_t doc_id) {
+DefHLReader_Fetch_Doc_Vec_IMP(DefaultHighlightReader *self, int32_t doc_id) {
     DefaultHighlightReaderIVARS *const ivars = DefHLReader_IVARS(self);
     InStream *const ix_in  = ivars->ix_in;
     InStream *const dat_in = ivars->dat_in;
@@ -211,8 +211,8 @@ DefHLReader_fetch_doc_vec(DefaultHighlightReader *self, int32_t doc_id) {
 }
 
 void
-DefHLReader_read_record(DefaultHighlightReader *self, int32_t doc_id,
-                        ByteBuf *target) {
+DefHLReader_Read_Record_IMP(DefaultHighlightReader *self, int32_t doc_id,
+                            ByteBuf *target) {
     DefaultHighlightReaderIVARS *const ivars = DefHLReader_IVARS(self);
     InStream *dat_in = ivars->dat_in;
     InStream *ix_in  = ivars->ix_in;

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Index/HighlightWriter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/HighlightWriter.c b/core/Lucy/Index/HighlightWriter.c
index 60154df..cb588ea 100644
--- a/core/Lucy/Index/HighlightWriter.c
+++ b/core/Lucy/Index/HighlightWriter.c
@@ -58,7 +58,7 @@ HLWriter_init(HighlightWriter *self, Schema *schema, Snapshot *snapshot,
 }
 
 void
-HLWriter_destroy(HighlightWriter *self) {
+HLWriter_Destroy_IMP(HighlightWriter *self) {
     HighlightWriterIVARS *const ivars = HLWriter_IVARS(self);
     DECREF(ivars->dat_out);
     DECREF(ivars->ix_out);
@@ -92,8 +92,8 @@ S_lazy_init(HighlightWriter *self) {
 }
 
 void
-HLWriter_add_inverted_doc(HighlightWriter *self, Inverter *inverter,
-                          int32_t doc_id) {
+HLWriter_Add_Inverted_Doc_IMP(HighlightWriter *self, Inverter *inverter,
+                              int32_t doc_id) {
     HighlightWriterIVARS *const ivars = HLWriter_IVARS(self);
     OutStream *dat_out = S_lazy_init(self);
     OutStream *ix_out  = ivars->ix_out;
@@ -138,7 +138,7 @@ HLWriter_add_inverted_doc(HighlightWriter *self, Inverter *inverter,
 }
 
 ByteBuf*
-HLWriter_tv_buf(HighlightWriter *self, Inversion *inversion) {
+HLWriter_TV_Buf_IMP(HighlightWriter *self, Inversion *inversion) {
     const char *last_text = "";
     size_t      last_len = 0;
     ByteBuf    *tv_buf = BB_new(20 + Inversion_Get_Size(inversion) * 8);
@@ -209,8 +209,8 @@ HLWriter_tv_buf(HighlightWriter *self, Inversion *inversion) {
 }
 
 void
-HLWriter_add_segment(HighlightWriter *self, SegReader *reader,
-                     I32Array *doc_map) {
+HLWriter_Add_Segment_IMP(HighlightWriter *self, SegReader *reader,
+                         I32Array *doc_map) {
     HighlightWriterIVARS *const ivars = HLWriter_IVARS(self);
     int32_t doc_max = SegReader_Doc_Max(reader);
 
@@ -248,7 +248,7 @@ HLWriter_add_segment(HighlightWriter *self, SegReader *reader,
 }
 
 void
-HLWriter_finish(HighlightWriter *self) {
+HLWriter_Finish_IMP(HighlightWriter *self) {
     HighlightWriterIVARS *const ivars = HLWriter_IVARS(self);
     if (ivars->dat_out) {
         // Write one final file pointer, so that we can derive the length of
@@ -265,7 +265,7 @@ HLWriter_finish(HighlightWriter *self) {
 }
 
 int32_t
-HLWriter_format(HighlightWriter *self) {
+HLWriter_Format_IMP(HighlightWriter *self) {
     UNUSED_VAR(self);
     return HLWriter_current_file_format;
 }

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Index/IndexManager.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/IndexManager.c b/core/Lucy/Index/IndexManager.c
index 684e476..aa46298 100644
--- a/core/Lucy/Index/IndexManager.c
+++ b/core/Lucy/Index/IndexManager.c
@@ -57,7 +57,7 @@ IxManager_init(IndexManager *self, const CharBuf *host,
 }
 
 void
-IxManager_destroy(IndexManager *self) {
+IxManager_Destroy_IMP(IndexManager *self) {
     IndexManagerIVARS *const ivars = IxManager_IVARS(self);
     DECREF(ivars->host);
     DECREF(ivars->folder);
@@ -66,7 +66,7 @@ IxManager_destroy(IndexManager *self) {
 }
 
 int64_t
-IxManager_highest_seg_num(IndexManager *self, Snapshot *snapshot) {
+IxManager_Highest_Seg_Num_IMP(IndexManager *self, Snapshot *snapshot) {
     VArray *files = Snapshot_List(snapshot);
     uint64_t highest_seg_num = 0;
     UNUSED_VAR(self);
@@ -82,7 +82,7 @@ IxManager_highest_seg_num(IndexManager *self, Snapshot *snapshot) {
 }
 
 CharBuf*
-IxManager_make_snapshot_filename(IndexManager *self) {
+IxManager_Make_Snapshot_Filename_IMP(IndexManager *self) {
     IndexManagerIVARS *const ivars = IxManager_IVARS(self);
     Folder *folder = (Folder*)CERTIFY(ivars->folder, FOLDER);
     DirHandle *dh = Folder_Open_Dir(folder, NULL);
@@ -137,9 +137,9 @@ S_fibonacci(uint32_t n) {
 }
 
 VArray*
-IxManager_recycle(IndexManager *self, PolyReader *reader,
-                  DeletionsWriter *del_writer, int64_t cutoff,
-                  bool optimize) {
+IxManager_Recycle_IMP(IndexManager *self, PolyReader *reader,
+                      DeletionsWriter *del_writer, int64_t cutoff,
+                      bool optimize) {
     VArray *seg_readers = PolyReader_Get_Seg_Readers(reader);
     VArray *candidates  = VA_Gather(seg_readers, S_check_cutoff, &cutoff);
     VArray *recyclables = VA_new(VA_Get_Size(candidates));
@@ -187,7 +187,7 @@ IxManager_recycle(IndexManager *self, PolyReader *reader,
 }
 
 uint32_t
-IxManager_choose_sparse(IndexManager *self, I32Array *doc_counts) {
+IxManager_Choose_Sparse_IMP(IndexManager *self, I32Array *doc_counts) {
     UNUSED_VAR(self);
     uint32_t threshold  = 0;
     uint32_t total_docs = 0;
@@ -230,7 +230,7 @@ S_obtain_lock_factory(IndexManager *self) {
 }
 
 Lock*
-IxManager_make_write_lock(IndexManager *self) {
+IxManager_Make_Write_Lock_IMP(IndexManager *self) {
     IndexManagerIVARS *const ivars = IxManager_IVARS(self);
     ZombieCharBuf *write_lock_name = ZCB_WRAP_STR("write", 5);
     LockFactory *lock_factory = S_obtain_lock_factory(self);
@@ -240,7 +240,7 @@ IxManager_make_write_lock(IndexManager *self) {
 }
 
 Lock*
-IxManager_make_deletion_lock(IndexManager *self) {
+IxManager_Make_Deletion_Lock_IMP(IndexManager *self) {
     IndexManagerIVARS *const ivars = IxManager_IVARS(self);
     ZombieCharBuf *lock_name = ZCB_WRAP_STR("deletion", 8);
     LockFactory *lock_factory = S_obtain_lock_factory(self);
@@ -250,7 +250,7 @@ IxManager_make_deletion_lock(IndexManager *self) {
 }
 
 Lock*
-IxManager_make_merge_lock(IndexManager *self) {
+IxManager_Make_Merge_Lock_IMP(IndexManager *self) {
     IndexManagerIVARS *const ivars = IxManager_IVARS(self);
     ZombieCharBuf *merge_lock_name = ZCB_WRAP_STR("merge", 5);
     LockFactory *lock_factory = S_obtain_lock_factory(self);
@@ -260,7 +260,7 @@ IxManager_make_merge_lock(IndexManager *self) {
 }
 
 void
-IxManager_write_merge_data(IndexManager *self, int64_t cutoff) {
+IxManager_Write_Merge_Data_IMP(IndexManager *self, int64_t cutoff) {
     IndexManagerIVARS *const ivars = IxManager_IVARS(self);
     ZombieCharBuf *merge_json = ZCB_WRAP_STR("merge.json", 10);
     Hash *data = Hash_new(1);
@@ -274,7 +274,7 @@ IxManager_write_merge_data(IndexManager *self, int64_t cutoff) {
 }
 
 Hash*
-IxManager_read_merge_data(IndexManager *self) {
+IxManager_Read_Merge_Data_IMP(IndexManager *self) {
     IndexManagerIVARS *const ivars = IxManager_IVARS(self);
     ZombieCharBuf *merge_json = ZCB_WRAP_STR("merge.json", 10);
     if (Folder_Exists(ivars->folder, (CharBuf*)merge_json)) {
@@ -294,15 +294,15 @@ IxManager_read_merge_data(IndexManager *self) {
 }
 
 bool
-IxManager_remove_merge_data(IndexManager *self) {
+IxManager_Remove_Merge_Data_IMP(IndexManager *self) {
     IndexManagerIVARS *const ivars = IxManager_IVARS(self);
     ZombieCharBuf *merge_json = ZCB_WRAP_STR("merge.json", 10);
     return Folder_Delete(ivars->folder, (CharBuf*)merge_json) != 0;
 }
 
 Lock*
-IxManager_make_snapshot_read_lock(IndexManager *self,
-                                  const CharBuf *filename) {
+IxManager_Make_Snapshot_Read_Lock_IMP(IndexManager *self,
+                                      const CharBuf *filename) {
     ZombieCharBuf *lock_name = ZCB_WRAP(filename);
     LockFactory *lock_factory = S_obtain_lock_factory(self);
 
@@ -319,79 +319,81 @@ IxManager_make_snapshot_read_lock(IndexManager *self,
 }
 
 void
-IxManager_set_folder(IndexManager *self, Folder *folder) {
+IxManager_Set_Folder_IMP(IndexManager *self, Folder *folder) {
     IndexManagerIVARS *const ivars = IxManager_IVARS(self);
     DECREF(ivars->folder);
     ivars->folder = (Folder*)INCREF(folder);
 }
 
 Folder*
-IxManager_get_folder(IndexManager *self) {
+IxManager_Get_Folder_IMP(IndexManager *self) {
     return IxManager_IVARS(self)->folder;
 }
 
 CharBuf*
-IxManager_get_host(IndexManager *self) {
+IxManager_Get_Host_IMP(IndexManager *self) {
     return IxManager_IVARS(self)->host;
 }
 
 uint32_t
-IxManager_get_write_lock_timeout(IndexManager *self) {
+IxManager_Get_Write_Lock_Timeout_IMP(IndexManager *self) {
     return IxManager_IVARS(self)->write_lock_timeout;
 }
 
 uint32_t
-IxManager_get_write_lock_interval(IndexManager *self) {
+IxManager_Get_Write_Lock_Interval_IMP(IndexManager *self) {
     return IxManager_IVARS(self)->write_lock_interval;
 }
 
 uint32_t
-IxManager_get_merge_lock_timeout(IndexManager *self) {
+IxManager_Get_Merge_Lock_Timeout_IMP(IndexManager *self) {
     return IxManager_IVARS(self)->merge_lock_timeout;
 }
 
 uint32_t
-IxManager_get_merge_lock_interval(IndexManager *self) {
+IxManager_Get_Merge_Lock_Interval_IMP(IndexManager *self) {
     return IxManager_IVARS(self)->merge_lock_interval;
 }
 
 uint32_t
-IxManager_get_deletion_lock_timeout(IndexManager *self) {
+IxManager_Get_Deletion_Lock_Timeout_IMP(IndexManager *self) {
     return IxManager_IVARS(self)->deletion_lock_timeout;
 }
 
 uint32_t
-IxManager_get_deletion_lock_interval(IndexManager *self) {
+IxManager_Get_Deletion_Lock_Interval_IMP(IndexManager *self) {
     return IxManager_IVARS(self)->deletion_lock_interval;
 }
 
 void
-IxManager_set_write_lock_timeout(IndexManager *self, uint32_t timeout) {
+IxManager_Set_Write_Lock_Timeout_IMP(IndexManager *self, uint32_t timeout) {
     IxManager_IVARS(self)->write_lock_timeout = timeout;
 }
 
 void
-IxManager_set_write_lock_interval(IndexManager *self, uint32_t interval) {
+IxManager_Set_Write_Lock_Interval_IMP(IndexManager *self, uint32_t interval) {
     IxManager_IVARS(self)->write_lock_interval = interval;
 }
 
 void
-IxManager_set_merge_lock_timeout(IndexManager *self, uint32_t timeout) {
+IxManager_Set_Merge_Lock_Timeout_IMP(IndexManager *self, uint32_t timeout) {
     IxManager_IVARS(self)->merge_lock_timeout = timeout;
 }
 
 void
-IxManager_set_merge_lock_interval(IndexManager *self, uint32_t interval) {
+IxManager_Set_Merge_Lock_Interval_IMP(IndexManager *self, uint32_t interval) {
     IxManager_IVARS(self)->merge_lock_interval = interval;
 }
 
 void
-IxManager_set_deletion_lock_timeout(IndexManager *self, uint32_t timeout) {
+IxManager_Set_Deletion_Lock_Timeout_IMP(IndexManager *self,
+                                        uint32_t timeout) {
     IxManager_IVARS(self)->deletion_lock_timeout = timeout;
 }
 
 void
-IxManager_set_deletion_lock_interval(IndexManager *self, uint32_t interval) {
+IxManager_Set_Deletion_Lock_Interval_IMP(IndexManager *self,
+                                         uint32_t interval) {
     IxManager_IVARS(self)->deletion_lock_interval = interval;
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Index/IndexReader.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/IndexReader.c b/core/Lucy/Index/IndexReader.c
index 9f81db2..395bc23 100644
--- a/core/Lucy/Index/IndexReader.c
+++ b/core/Lucy/Index/IndexReader.c
@@ -67,7 +67,7 @@ IxReader_init(IndexReader *self, Schema *schema, Folder *folder,
 }
 
 void
-IxReader_close(IndexReader *self) {
+IxReader_Close_IMP(IndexReader *self) {
     IndexReaderIVARS *const ivars = IxReader_IVARS(self);
     if (ivars->components) {
         CharBuf *key;
@@ -90,7 +90,7 @@ IxReader_close(IndexReader *self) {
 }
 
 void
-IxReader_destroy(IndexReader *self) {
+IxReader_Destroy_IMP(IndexReader *self) {
     IndexReaderIVARS *const ivars = IxReader_IVARS(self);
     DECREF(ivars->components);
     if (ivars->read_lock) {
@@ -103,12 +103,12 @@ IxReader_destroy(IndexReader *self) {
 }
 
 Hash*
-IxReader_get_components(IndexReader *self) {
+IxReader_Get_Components_IMP(IndexReader *self) {
     return IxReader_IVARS(self)->components;
 }
 
 DataReader*
-IxReader_obtain(IndexReader *self, const CharBuf *api) {
+IxReader_Obtain_IMP(IndexReader *self, const CharBuf *api) {
     IndexReaderIVARS *const ivars = IxReader_IVARS(self);
     DataReader *component
         = (DataReader*)Hash_Fetch(ivars->components, (Obj*)api);
@@ -119,7 +119,7 @@ IxReader_obtain(IndexReader *self, const CharBuf *api) {
 }
 
 DataReader*
-IxReader_fetch(IndexReader *self, const CharBuf *api) {
+IxReader_Fetch_IMP(IndexReader *self, const CharBuf *api) {
     IndexReaderIVARS *const ivars = IxReader_IVARS(self);
     return (DataReader*)Hash_Fetch(ivars->components, (Obj*)api);
 }

http://git-wip-us.apache.org/repos/asf/lucy/blob/cb510ae7/core/Lucy/Index/Indexer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/Indexer.c b/core/Lucy/Index/Indexer.c
index ab61d02..c1423b1 100644
--- a/core/Lucy/Index/Indexer.c
+++ b/core/Lucy/Index/Indexer.c
@@ -220,7 +220,7 @@ Indexer_init(Indexer *self, Schema *schema, Obj *index,
 }
 
 void
-Indexer_destroy(Indexer *self) {
+Indexer_Destroy_IMP(Indexer *self) {
     IndexerIVARS *const ivars = Indexer_IVARS(self);
     S_release_merge_lock(self);
     S_release_write_lock(self);
@@ -268,13 +268,13 @@ S_init_folder(Obj *index, bool create) {
 }
 
 void
-Indexer_add_doc(Indexer *self, Doc *doc, float boost) {
+Indexer_Add_Doc_IMP(Indexer *self, Doc *doc, float boost) {
     IndexerIVARS *const ivars = Indexer_IVARS(self);
     SegWriter_Add_Doc(ivars->seg_writer, doc, boost);
 }
 
 void
-Indexer_delete_by_term(Indexer *self, CharBuf *field, Obj *term) {
+Indexer_Delete_By_Term_IMP(Indexer *self, CharBuf *field, Obj *term) {
     IndexerIVARS *const ivars = Indexer_IVARS(self);
     Schema    *schema = ivars->schema;
     FieldType *type   = Schema_Fetch_Type(schema, field);
@@ -302,19 +302,19 @@ Indexer_delete_by_term(Indexer *self, CharBuf *field, Obj *term) {
 }
 
 void
-Indexer_delete_by_query(Indexer *self, Query *query) {
+Indexer_Delete_By_Query_IMP(Indexer *self, Query *query) {
     IndexerIVARS *const ivars = Indexer_IVARS(self);
     DelWriter_Delete_By_Query(ivars->del_writer, query);
 }
 
 void
-Indexer_delete_by_doc_id(Indexer *self, int32_t doc_id) {
+Indexer_Delete_By_Doc_ID_IMP(Indexer *self, int32_t doc_id) {
     IndexerIVARS *const ivars = Indexer_IVARS(self);
     DelWriter_Delete_By_Doc_ID(ivars->del_writer, doc_id);
 }
 
 void
-Indexer_add_index(Indexer *self, Obj *index) {
+Indexer_Add_Index_IMP(Indexer *self, Obj *index) {
     IndexerIVARS *const ivars = Indexer_IVARS(self);
     Folder *other_folder = NULL;
     IndexReader *reader  = NULL;
@@ -374,7 +374,7 @@ Indexer_add_index(Indexer *self, Obj *index) {
 }
 
 void
-Indexer_optimize(Indexer *self) {
+Indexer_Optimize_IMP(Indexer *self) {
     Indexer_IVARS(self)->optimize = true;
 }
 
@@ -480,7 +480,7 @@ S_maybe_merge(Indexer *self, VArray *seg_readers) {
 }
 
 void
-Indexer_prepare_commit(Indexer *self) {
+Indexer_Prepare_Commit_IMP(Indexer *self) {
     IndexerIVARS *const ivars = Indexer_IVARS(self);
     VArray   *seg_readers     = PolyReader_Get_Seg_Readers(ivars->polyreader);
     uint32_t  num_seg_readers = VA_Get_Size(seg_readers);
@@ -538,7 +538,7 @@ Indexer_prepare_commit(Indexer *self) {
 }
 
 void
-Indexer_commit(Indexer *self) {
+Indexer_Commit_IMP(Indexer *self) {
     IndexerIVARS *const ivars = Indexer_IVARS(self);
 
     // Safety check.
@@ -571,17 +571,17 @@ Indexer_commit(Indexer *self) {
 }
 
 Schema*
-Indexer_get_schema(Indexer *self) {
+Indexer_Get_Schema_IMP(Indexer *self) {
     return Indexer_IVARS(self)->schema;
 }
 
 SegWriter*
-Indexer_get_seg_writer(Indexer *self) {
+Indexer_Get_Seg_Writer_IMP(Indexer *self) {
     return Indexer_IVARS(self)->seg_writer;
 }
 
 Doc*
-Indexer_get_stock_doc(Indexer *self) {
+Indexer_Get_Stock_Doc_IMP(Indexer *self) {
     return Indexer_IVARS(self)->stock_doc;
 }
 


Mime
View raw message