lucy-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mar...@apache.org
Subject [lucy-commits] [2/5] git commit: refs/heads/master - Migrate "Lucy_" to "LUCY_".
Date Fri, 23 Aug 2013 00:01:29 GMT
Migrate "Lucy_" to "LUCY_".

Change method prefixes from mixed-case "Lucy_" to all-caps "LUCY_".


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

Branch: refs/heads/master
Commit: a0f24e5e9ea815f50235b7894d8408f3caa27f47
Parents: 392ed53
Author: Marvin Humphrey <marvin@rectangular.com>
Authored: Wed Aug 21 17:46:17 2013 -0700
Committer: Marvin Humphrey <marvin@rectangular.com>
Committed: Thu Aug 22 16:57:50 2013 -0700

----------------------------------------------------------------------
 core/Lucy/Analysis/CaseFolder.c               |  4 +--
 core/Lucy/Analysis/EasyAnalyzer.c             |  4 +--
 core/Lucy/Analysis/Normalizer.c               |  4 +--
 core/Lucy/Analysis/PolyAnalyzer.c             |  4 +--
 core/Lucy/Analysis/RegexTokenizer.c           |  4 +--
 core/Lucy/Analysis/SnowballStemmer.c          |  4 +--
 core/Lucy/Analysis/SnowballStopFilter.c       |  4 +--
 core/Lucy/Document/HitDoc.c                   | 10 +++---
 core/Lucy/Highlight/Highlighter.c             |  4 +--
 core/Lucy/Index/DeletionsWriter.c             |  2 +-
 core/Lucy/Index/LexiconWriter.c               |  2 +-
 core/Lucy/Index/PolyReader.c                  |  2 +-
 core/Lucy/Index/SortFieldWriter.c             |  2 +-
 core/Lucy/Index/SortWriter.c                  |  2 +-
 core/Lucy/Plan/BlobType.c                     |  2 +-
 core/Lucy/Plan/FieldType.cfh                  |  2 +-
 core/Lucy/Plan/FullTextType.c                 |  2 +-
 core/Lucy/Plan/NumericType.c                  |  8 ++---
 core/Lucy/Plan/StringType.c                   |  2 +-
 core/Lucy/Search/ANDQuery.c                   |  2 +-
 core/Lucy/Search/Collector/SortCollector.c    |  2 +-
 core/Lucy/Search/HitQueue.c                   |  2 +-
 core/Lucy/Search/LeafQuery.c                  |  4 +--
 core/Lucy/Search/NOTQuery.c                   |  2 +-
 core/Lucy/Search/NoMatchQuery.c               |  4 +--
 core/Lucy/Search/ORQuery.c                    |  2 +-
 core/Lucy/Search/PhraseQuery.c                | 10 +++---
 core/Lucy/Search/PolyQuery.c                  |  8 ++---
 core/Lucy/Search/RangeQuery.c                 |  4 +--
 core/Lucy/Search/RequiredOptionalQuery.c      |  2 +-
 core/Lucy/Search/TermQuery.c                  | 10 +++---
 core/Lucy/Store/CompoundFileReader.c          |  2 +-
 core/Lucy/Store/SharedLock.c                  |  4 +--
 core/Lucy/Test/Index/TestTermInfo.c           |  2 +-
 core/Lucy/Test/Search/TestQueryParserLogic.c  | 14 ++++----
 core/Lucy/Test/Search/TestQueryParserSyntax.c | 10 +++---
 core/Lucy/Test/Store/TestFileHandle.c         |  2 +-
 core/Lucy/Test/Store/TestFolderCommon.c       |  4 +--
 core/Lucy/Test/Store/TestFolderCommon.cfh     | 12 +++----
 core/Lucy/Util/BBSortEx.c                     |  4 +--
 core/Lucy/Util/SortExternal.c                 |  6 ++--
 core/LucyX/Search/ProximityQuery.c            | 10 +++---
 perl/buildlib/Lucy/Build/Binding/Analysis.pm  |  4 +--
 perl/buildlib/Lucy/Build/Binding/Document.pm  |  4 +--
 perl/buildlib/Lucy/Build/Binding/Index.pm     | 16 ++++-----
 perl/buildlib/Lucy/Build/Binding/Misc.pm      |  4 +--
 perl/buildlib/Lucy/Build/Binding/Object.pm    |  4 +--
 perl/buildlib/Lucy/Build/Binding/Store.pm     | 14 ++++----
 perl/buildlib/Lucy/Build/Binding/Util.pm      |  6 ++--
 perl/xs/Lucy/Analysis/RegexTokenizer.c        |  8 ++---
 perl/xs/Lucy/Document/Doc.c                   | 40 +++++++++++-----------
 perl/xs/Lucy/Index/DocReader.c                | 36 +++++++++----------
 perl/xs/Lucy/Index/Inverter.c                 | 16 ++++-----
 53 files changed, 171 insertions(+), 171 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Analysis/CaseFolder.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/CaseFolder.c b/core/Lucy/Analysis/CaseFolder.c
index 6f113e0..643cb8f 100644
--- a/core/Lucy/Analysis/CaseFolder.c
+++ b/core/Lucy/Analysis/CaseFolder.c
@@ -64,14 +64,14 @@ CaseFolder_Equals_IMP(CaseFolder *self, Obj *other) {
 Hash*
 CaseFolder_Dump_IMP(CaseFolder *self) {
     CaseFolder_Dump_t super_dump
-        = SUPER_METHOD_PTR(CASEFOLDER, Lucy_CaseFolder_Dump);
+        = SUPER_METHOD_PTR(CASEFOLDER, LUCY_CaseFolder_Dump);
     return super_dump(self);
 }
 
 CaseFolder*
 CaseFolder_Load_IMP(CaseFolder *self, Obj *dump) {
     CaseFolder_Load_t super_load
-        = SUPER_METHOD_PTR(CASEFOLDER, Lucy_CaseFolder_Load);
+        = SUPER_METHOD_PTR(CASEFOLDER, LUCY_CaseFolder_Load);
     CaseFolder *loaded = super_load(self, dump);
     return CaseFolder_init(loaded);
 }

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Analysis/EasyAnalyzer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/EasyAnalyzer.c b/core/Lucy/Analysis/EasyAnalyzer.c
index 1a676fe..4604c82 100644
--- a/core/Lucy/Analysis/EasyAnalyzer.c
+++ b/core/Lucy/Analysis/EasyAnalyzer.c
@@ -76,7 +76,7 @@ Hash*
 EasyAnalyzer_Dump_IMP(EasyAnalyzer *self) {
     EasyAnalyzerIVARS *const ivars = EasyAnalyzer_IVARS(self);
     EasyAnalyzer_Dump_t super_dump
-        = SUPER_METHOD_PTR(EASYANALYZER, Lucy_EasyAnalyzer_Dump);
+        = SUPER_METHOD_PTR(EASYANALYZER, LUCY_EasyAnalyzer_Dump);
     Hash *dump = super_dump(self);
     Hash_Store_Str(dump, "language", 8, (Obj*)CB_Clone(ivars->language));
     return dump;
@@ -85,7 +85,7 @@ EasyAnalyzer_Dump_IMP(EasyAnalyzer *self) {
 EasyAnalyzer*
 EasyAnalyzer_Load_IMP(EasyAnalyzer *self, Obj *dump) {
     EasyAnalyzer_Load_t super_load
-        = SUPER_METHOD_PTR(EASYANALYZER, Lucy_EasyAnalyzer_Load);
+        = SUPER_METHOD_PTR(EASYANALYZER, LUCY_EasyAnalyzer_Load);
     EasyAnalyzer *loaded = super_load(self, dump);
     Hash    *source = (Hash*)CERTIFY(dump, HASH);
     CharBuf *language

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Analysis/Normalizer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/Normalizer.c b/core/Lucy/Analysis/Normalizer.c
index 1b72d73..af60f1b 100644
--- a/core/Lucy/Analysis/Normalizer.c
+++ b/core/Lucy/Analysis/Normalizer.c
@@ -121,7 +121,7 @@ Normalizer_Transform_IMP(Normalizer *self, Inversion *inversion) {
 Hash*
 Normalizer_Dump_IMP(Normalizer *self) {
     Normalizer_Dump_t super_dump
-        = SUPER_METHOD_PTR(NORMALIZER, Lucy_Normalizer_Dump);
+        = SUPER_METHOD_PTR(NORMALIZER, LUCY_Normalizer_Dump);
     Hash *dump = super_dump(self);
     int options = Normalizer_IVARS(self)->options;
 
@@ -147,7 +147,7 @@ Normalizer_Dump_IMP(Normalizer *self) {
 Normalizer*
 Normalizer_Load_IMP(Normalizer *self, Obj *dump) {
     Normalizer_Load_t super_load
-        = SUPER_METHOD_PTR(NORMALIZER, Lucy_Normalizer_Load);
+        = SUPER_METHOD_PTR(NORMALIZER, LUCY_Normalizer_Load);
     Normalizer *loaded = super_load(self, dump);
     Hash    *source = (Hash*)CERTIFY(dump, HASH);
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Analysis/PolyAnalyzer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/PolyAnalyzer.c b/core/Lucy/Analysis/PolyAnalyzer.c
index 2e35c36..761173a 100644
--- a/core/Lucy/Analysis/PolyAnalyzer.c
+++ b/core/Lucy/Analysis/PolyAnalyzer.c
@@ -125,7 +125,7 @@ Obj*
 PolyAnalyzer_Dump_IMP(PolyAnalyzer *self) {
     PolyAnalyzerIVARS *const ivars = PolyAnalyzer_IVARS(self);
     PolyAnalyzer_Dump_t super_dump
-        = SUPER_METHOD_PTR(POLYANALYZER, Lucy_PolyAnalyzer_Dump);
+        = SUPER_METHOD_PTR(POLYANALYZER, LUCY_PolyAnalyzer_Dump);
     Hash *dump = (Hash*)CERTIFY(super_dump(self), HASH);
     if (ivars->analyzers) {
         Hash_Store_Str(dump, "analyzers", 9,
@@ -138,7 +138,7 @@ PolyAnalyzer*
 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);
+        = SUPER_METHOD_PTR(POLYANALYZER, LUCY_PolyAnalyzer_Load);
     PolyAnalyzer *loaded = super_load(self, dump);
     VArray *analyzer_dumps
         = (VArray*)CERTIFY(Hash_Fetch_Str(source, "analyzers", 9), VARRAY);

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Analysis/RegexTokenizer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/RegexTokenizer.c b/core/Lucy/Analysis/RegexTokenizer.c
index cfb989c..8f2e855 100644
--- a/core/Lucy/Analysis/RegexTokenizer.c
+++ b/core/Lucy/Analysis/RegexTokenizer.c
@@ -54,7 +54,7 @@ Obj*
 RegexTokenizer_Dump_IMP(RegexTokenizer *self) {
     RegexTokenizerIVARS *const ivars = RegexTokenizer_IVARS(self);
     RegexTokenizer_Dump_t super_dump
-        = SUPER_METHOD_PTR(REGEXTOKENIZER, Lucy_RegexTokenizer_Dump);
+        = SUPER_METHOD_PTR(REGEXTOKENIZER, LUCY_RegexTokenizer_Dump);
     Hash *dump = (Hash*)CERTIFY(super_dump(self), HASH);
     Hash_Store_Str(dump, "pattern", 7, (Obj*)CB_Clone(ivars->pattern));
     return (Obj*)dump;
@@ -64,7 +64,7 @@ RegexTokenizer*
 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);
+        = SUPER_METHOD_PTR(REGEXTOKENIZER, LUCY_RegexTokenizer_Load);
     RegexTokenizer *loaded = super_load(self, dump);
     CharBuf *pattern 
         = (CharBuf*)CERTIFY(Hash_Fetch_Str(source, "pattern", 7), CHARBUF);

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Analysis/SnowballStemmer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/SnowballStemmer.c b/core/Lucy/Analysis/SnowballStemmer.c
index c048fda..1c5a632 100644
--- a/core/Lucy/Analysis/SnowballStemmer.c
+++ b/core/Lucy/Analysis/SnowballStemmer.c
@@ -88,7 +88,7 @@ Hash*
 SnowStemmer_Dump_IMP(SnowballStemmer *self) {
     SnowballStemmerIVARS *const ivars = SnowStemmer_IVARS(self);
     SnowStemmer_Dump_t super_dump
-        = SUPER_METHOD_PTR(SNOWBALLSTEMMER, Lucy_SnowStemmer_Dump);
+        = SUPER_METHOD_PTR(SNOWBALLSTEMMER, LUCY_SnowStemmer_Dump);
     Hash *dump = super_dump(self);
     Hash_Store_Str(dump, "language", 8, (Obj*)CB_Clone(ivars->language));
     return dump;
@@ -97,7 +97,7 @@ SnowStemmer_Dump_IMP(SnowballStemmer *self) {
 SnowballStemmer*
 SnowStemmer_Load_IMP(SnowballStemmer *self, Obj *dump) {
     SnowStemmer_Load_t super_load
-        = SUPER_METHOD_PTR(SNOWBALLSTEMMER, Lucy_SnowStemmer_Load);
+        = SUPER_METHOD_PTR(SNOWBALLSTEMMER, LUCY_SnowStemmer_Load);
     SnowballStemmer *loaded = super_load(self, dump);
     Hash    *source = (Hash*)CERTIFY(dump, HASH);
     CharBuf *language 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Analysis/SnowballStopFilter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/SnowballStopFilter.c b/core/Lucy/Analysis/SnowballStopFilter.c
index 8a299c8..8a903b7 100644
--- a/core/Lucy/Analysis/SnowballStopFilter.c
+++ b/core/Lucy/Analysis/SnowballStopFilter.c
@@ -94,7 +94,7 @@ Obj*
 SnowStop_Dump_IMP(SnowballStopFilter *self) {
     SnowballStopFilterIVARS *ivars = SnowStop_IVARS(self);
     SnowStop_Dump_t super_dump
-        = SUPER_METHOD_PTR(SNOWBALLSTOPFILTER, Lucy_SnowStop_Dump);
+        = SUPER_METHOD_PTR(SNOWBALLSTOPFILTER, LUCY_SnowStop_Dump);
     Hash *dump = (Hash*)CERTIFY(super_dump(self), HASH);
     if (ivars->stoplist) {
         Hash_Store_Str(dump, "stoplist", 8,
@@ -107,7 +107,7 @@ Obj*
 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);
+        = SUPER_METHOD_PTR(SNOWBALLSTOPFILTER, LUCY_SnowStop_Load);
     SnowballStopFilter *loaded = (SnowballStopFilter*)super_load(self, dump);
     Obj *stoplist = Hash_Fetch_Str(source, "stoplist", 8);
     if (stoplist) {

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Document/HitDoc.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Document/HitDoc.c b/core/Lucy/Document/HitDoc.c
index 973c7e2..f7216fb 100644
--- a/core/Lucy/Document/HitDoc.c
+++ b/core/Lucy/Document/HitDoc.c
@@ -49,7 +49,7 @@ void
 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);
+        = SUPER_METHOD_PTR(HITDOC, LUCY_HitDoc_Serialize);
     super_serialize(self, outstream);
     OutStream_Write_F32(outstream, ivars->score);
 }
@@ -57,7 +57,7 @@ HitDoc_Serialize_IMP(HitDoc *self, OutStream *outstream) {
 HitDoc*
 HitDoc_Deserialize_IMP(HitDoc *self, InStream *instream) {
     HitDoc_Deserialize_t super_deserialize
-        = SUPER_METHOD_PTR(HITDOC, Lucy_HitDoc_Deserialize);
+        = SUPER_METHOD_PTR(HITDOC, LUCY_HitDoc_Deserialize);
     self = super_deserialize(self, instream);
     HitDocIVARS *const ivars = HitDoc_IVARS(self);
     ivars->score = InStream_Read_F32(instream);
@@ -68,7 +68,7 @@ Hash*
 HitDoc_Dump_IMP(HitDoc *self) {
     HitDocIVARS *const ivars = HitDoc_IVARS(self);
     HitDoc_Dump_t super_dump
-        = SUPER_METHOD_PTR(HITDOC, Lucy_HitDoc_Dump);
+        = SUPER_METHOD_PTR(HITDOC, LUCY_HitDoc_Dump);
     Hash *dump = super_dump(self);
     Hash_Store_Str(dump, "score", 5, (Obj*)CB_newf("%f64", ivars->score));
     return dump;
@@ -78,7 +78,7 @@ HitDoc*
 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);
+        = SUPER_METHOD_PTR(HITDOC, LUCY_HitDoc_Load);
     HitDoc *loaded = super_load(self, dump);
     HitDocIVARS *const loaded_ivars = HitDoc_IVARS(loaded);
     Obj *score = CERTIFY(Hash_Fetch_Str(source, "score", 5), OBJ);
@@ -91,7 +91,7 @@ HitDoc_Equals_IMP(HitDoc *self, Obj *other) {
     if ((HitDoc*)other == self)           { return true;  }
     if (!Obj_Is_A(other, HITDOC))         { return false; }
     HitDoc_Equals_t super_equals
-        = (HitDoc_Equals_t)SUPER_METHOD_PTR(HITDOC, Lucy_HitDoc_Equals);
+        = (HitDoc_Equals_t)SUPER_METHOD_PTR(HITDOC, LUCY_HitDoc_Equals);
     if (!super_equals(self, other))       { return false; }
     HitDocIVARS *const ivars = HitDoc_IVARS(self);
     HitDocIVARS *const ovars = HitDoc_IVARS((HitDoc*)other);

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Highlight/Highlighter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Highlight/Highlighter.c b/core/Lucy/Highlight/Highlighter.c
index 7481500..b4526ea 100644
--- a/core/Lucy/Highlight/Highlighter.c
+++ b/core/Lucy/Highlight/Highlighter.c
@@ -682,9 +682,9 @@ static CharBuf*
 S_do_encode(Highlighter *self, CharBuf *text, CharBuf **encode_buf) {
     VTable *vtable = Highlighter_Get_VTable(self);
     Highlighter_Encode_t my_meth
-        = (Highlighter_Encode_t)METHOD_PTR(vtable, Lucy_Highlighter_Encode);
+        = (Highlighter_Encode_t)METHOD_PTR(vtable, LUCY_Highlighter_Encode);
     Highlighter_Encode_t orig_meth
-        = (Highlighter_Encode_t)METHOD_PTR(HIGHLIGHTER, Lucy_Highlighter_Encode);
+        = (Highlighter_Encode_t)METHOD_PTR(HIGHLIGHTER, LUCY_Highlighter_Encode);
 
     if (my_meth != orig_meth) {
         return my_meth(self, text);

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Index/DeletionsWriter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DeletionsWriter.c b/core/Lucy/Index/DeletionsWriter.c
index 89e9807..39aa896 100644
--- a/core/Lucy/Index/DeletionsWriter.c
+++ b/core/Lucy/Index/DeletionsWriter.c
@@ -177,7 +177,7 @@ DefDelWriter_Metadata_IMP(DefaultDeletionsWriter *self) {
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
     DefDelWriter_Metadata_t super_meta
         = (DefDelWriter_Metadata_t)SUPER_METHOD_PTR(DEFAULTDELETIONSWRITER,
-                                                    Lucy_DefDelWriter_Metadata);
+                                                    LUCY_DefDelWriter_Metadata);
     Hash    *const metadata = super_meta(self);
     Hash    *const files    = Hash_new(0);
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Index/LexiconWriter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/LexiconWriter.c b/core/Lucy/Index/LexiconWriter.c
index cd122ec..6b33fb6 100644
--- a/core/Lucy/Index/LexiconWriter.c
+++ b/core/Lucy/Index/LexiconWriter.c
@@ -236,7 +236,7 @@ LexWriter_Metadata_IMP(LexiconWriter *self) {
     LexiconWriterIVARS *const ivars = LexWriter_IVARS(self);
     LexWriter_Metadata_t super_meta
         = (LexWriter_Metadata_t)SUPER_METHOD_PTR(LEXICONWRITER,
-                                                 Lucy_LexWriter_Metadata);
+                                                 LUCY_LexWriter_Metadata);
     Hash *const metadata  = super_meta(self);
     Hash *const counts    = (Hash*)INCREF(ivars->counts);
     Hash *const ix_counts = (Hash*)INCREF(ivars->ix_counts);

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Index/PolyReader.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/PolyReader.c b/core/Lucy/Index/PolyReader.c
index 6e97628..13c3709 100644
--- a/core/Lucy/Index/PolyReader.c
+++ b/core/Lucy/Index/PolyReader.c
@@ -187,7 +187,7 @@ void
 PolyReader_Close_IMP(PolyReader *self) {
     PolyReaderIVARS *const ivars = PolyReader_IVARS(self);
     PolyReader_Close_t super_close
-        = SUPER_METHOD_PTR(POLYREADER, Lucy_PolyReader_Close);
+        = SUPER_METHOD_PTR(POLYREADER, LUCY_PolyReader_Close);
     for (uint32_t i = 0, max = VA_Get_Size(ivars->sub_readers); i < max; i++) {
         SegReader *seg_reader = (SegReader*)VA_Fetch(ivars->sub_readers, i);
         SegReader_Close(seg_reader);

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Index/SortFieldWriter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/SortFieldWriter.c b/core/Lucy/Index/SortFieldWriter.c
index b205b10..9e9ee04 100644
--- a/core/Lucy/Index/SortFieldWriter.c
+++ b/core/Lucy/Index/SortFieldWriter.c
@@ -131,7 +131,7 @@ SortFieldWriter_Clear_Cache_IMP(SortFieldWriter *self) {
         Hash_Clear(ivars->uniq_vals);
     }
     SortFieldWriter_Clear_Cache_t super_clear_cache
-        = SUPER_METHOD_PTR(SORTFIELDWRITER, Lucy_SortFieldWriter_Clear_Cache);
+        = SUPER_METHOD_PTR(SORTFIELDWRITER, LUCY_SortFieldWriter_Clear_Cache);
     super_clear_cache(self);
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Index/SortWriter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/SortWriter.c b/core/Lucy/Index/SortWriter.c
index f7b0af1..6f375fd 100644
--- a/core/Lucy/Index/SortWriter.c
+++ b/core/Lucy/Index/SortWriter.c
@@ -257,7 +257,7 @@ SortWriter_Metadata_IMP(SortWriter *self) {
     SortWriterIVARS *const ivars = SortWriter_IVARS(self);
     SortWriter_Metadata_t super_meta
         = (SortWriter_Metadata_t)SUPER_METHOD_PTR(SORTWRITER,
-                                                  Lucy_SortWriter_Metadata);
+                                                  LUCY_SortWriter_Metadata);
     Hash *const metadata = super_meta(self);
     Hash_Store_Str(metadata, "counts", 6, INCREF(ivars->counts));
     Hash_Store_Str(metadata, "null_ords", 9, INCREF(ivars->null_ords));

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Plan/BlobType.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Plan/BlobType.c b/core/Lucy/Plan/BlobType.c
index 9b2f5e7..5bdb337 100644
--- a/core/Lucy/Plan/BlobType.c
+++ b/core/Lucy/Plan/BlobType.c
@@ -62,7 +62,7 @@ BlobType_Equals_IMP(BlobType *self, Obj *other) {
     if ((BlobType*)other == self)   { return true; }
     if (!Obj_Is_A(other, BLOBTYPE)) { return false; }
     BlobType_Equals_t super_equals
-        = (BlobType_Equals_t)SUPER_METHOD_PTR(BLOBTYPE, Lucy_BlobType_Equals);
+        = (BlobType_Equals_t)SUPER_METHOD_PTR(BLOBTYPE, LUCY_BlobType_Equals);
     return super_equals(self, other);
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Plan/FieldType.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Plan/FieldType.cfh b/core/Lucy/Plan/FieldType.cfh
index 1581928..94859c5 100644
--- a/core/Lucy/Plan/FieldType.cfh
+++ b/core/Lucy/Plan/FieldType.cfh
@@ -184,7 +184,7 @@ lucy_FType_null_back_compare_values(lucy_FieldType *self,
         return -1;
     }
     else {
-        return Lucy_FType_Compare_Values(self, a, b);
+        return LUCY_FType_Compare_Values(self, a, b);
     }
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Plan/FullTextType.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Plan/FullTextType.c b/core/Lucy/Plan/FullTextType.c
index 267fb91..3117037 100644
--- a/core/Lucy/Plan/FullTextType.c
+++ b/core/Lucy/Plan/FullTextType.c
@@ -67,7 +67,7 @@ FullTextType_Equals_IMP(FullTextType *self, Obj *other) {
     FullTextTypeIVARS *const ovars = FullTextType_IVARS((FullTextType*)other);
     FullTextType_Equals_t super_equals
         = (FullTextType_Equals_t)SUPER_METHOD_PTR(FULLTEXTTYPE,
-                                                  Lucy_FullTextType_Equals);
+                                                  LUCY_FullTextType_Equals);
     if (!super_equals(self, other))                       { return false; }
     if (!!ivars->sortable      != !!ovars->sortable)      { return false; }
     if (!!ivars->highlightable != !!ovars->highlightable) { return false; }

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Plan/NumericType.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Plan/NumericType.c b/core/Lucy/Plan/NumericType.c
index a459bf1..6c26419 100644
--- a/core/Lucy/Plan/NumericType.c
+++ b/core/Lucy/Plan/NumericType.c
@@ -159,7 +159,7 @@ Float64Type_Equals_IMP(Float64Type *self, Obj *other) {
     if (!other) { return false; }
     if (!Obj_Is_A(other, FLOAT64TYPE)) { return false; }
     Float64Type_Equals_t super_equals
-        = SUPER_METHOD_PTR(FLOAT64TYPE, Lucy_Float64Type_Equals);
+        = SUPER_METHOD_PTR(FLOAT64TYPE, LUCY_Float64Type_Equals);
     return super_equals(self, other);
 }
 
@@ -201,7 +201,7 @@ Float32Type_Equals_IMP(Float32Type *self, Obj *other) {
     if (!other) { return false; }
     if (!Obj_Is_A(other, FLOAT32TYPE)) { return false; }
     Float32Type_Equals_t super_equals
-        = SUPER_METHOD_PTR(FLOAT32TYPE, Lucy_Float32Type_Equals);
+        = SUPER_METHOD_PTR(FLOAT32TYPE, LUCY_Float32Type_Equals);
     return super_equals(self, other);
 }
 
@@ -243,7 +243,7 @@ Int32Type_Equals_IMP(Int32Type *self, Obj *other) {
     if (!other) { return false; }
     if (!Obj_Is_A(other, INT32TYPE)) { return false; }
     Int32Type_Equals_t super_equals
-        = SUPER_METHOD_PTR(INT32TYPE, Lucy_Int32Type_Equals);
+        = SUPER_METHOD_PTR(INT32TYPE, LUCY_Int32Type_Equals);
     return super_equals(self, other);
 }
 
@@ -285,7 +285,7 @@ Int64Type_Equals_IMP(Int64Type *self, Obj *other) {
     if (!other) { return false; }
     if (!Obj_Is_A(other, INT64TYPE)) { return false; }
     Int64Type_Equals_t super_equals
-        = SUPER_METHOD_PTR(INT64TYPE, Lucy_Int64Type_Equals);
+        = SUPER_METHOD_PTR(INT64TYPE, LUCY_Int64Type_Equals);
     return super_equals(self, other);
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Plan/StringType.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Plan/StringType.c b/core/Lucy/Plan/StringType.c
index 359a0ba..a6b2f7f 100644
--- a/core/Lucy/Plan/StringType.c
+++ b/core/Lucy/Plan/StringType.c
@@ -49,7 +49,7 @@ StringType_Equals_IMP(StringType *self, Obj *other) {
     if ((StringType*)other == self) { return true; }
     StringType_Equals_t super_equals
         = (StringType_Equals_t)SUPER_METHOD_PTR(STRINGTYPE,
-                                                Lucy_StringType_Equals);
+                                                LUCY_StringType_Equals);
     if (!super_equals(self, other)) { return false; }
     return true;
 }

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Search/ANDQuery.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/ANDQuery.c b/core/Lucy/Search/ANDQuery.c
index fc6df36..0b06785 100644
--- a/core/Lucy/Search/ANDQuery.c
+++ b/core/Lucy/Search/ANDQuery.c
@@ -69,7 +69,7 @@ ANDQuery_Equals_IMP(ANDQuery *self, Obj *other) {
     if ((ANDQuery*)other == self)   { return true; }
     if (!Obj_Is_A(other, ANDQUERY)) { return false; }
     ANDQuery_Equals_t super_equals
-        = (ANDQuery_Equals_t)SUPER_METHOD_PTR(ANDQUERY, Lucy_ANDQuery_Equals);
+        = (ANDQuery_Equals_t)SUPER_METHOD_PTR(ANDQUERY, LUCY_ANDQuery_Equals);
     return super_equals(self, other);
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Search/Collector/SortCollector.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Collector/SortCollector.c b/core/Lucy/Search/Collector/SortCollector.c
index 65b2238..63d0989 100644
--- a/core/Lucy/Search/Collector/SortCollector.c
+++ b/core/Lucy/Search/Collector/SortCollector.c
@@ -252,7 +252,7 @@ SortColl_Set_Reader_IMP(SortCollector *self, SegReader *reader) {
     ivars->seg_doc_max = reader ? SegReader_Doc_Max(reader) : 0;
     SortColl_Set_Reader_t super_set_reader
         = (SortColl_Set_Reader_t)SUPER_METHOD_PTR(SORTCOLLECTOR,
-                                                  Lucy_SortColl_Set_Reader);
+                                                  LUCY_SortColl_Set_Reader);
     super_set_reader(self, reader);
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Search/HitQueue.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/HitQueue.c b/core/Lucy/Search/HitQueue.c
index 4cc4bf0..97b920e 100644
--- a/core/Lucy/Search/HitQueue.c
+++ b/core/Lucy/Search/HitQueue.c
@@ -123,7 +123,7 @@ HitQ_Jostle_IMP(HitQueue *self, Obj *element) {
     HitQueueIVARS *const ivars = HitQ_IVARS(self);
     MatchDoc *match_doc = (MatchDoc*)CERTIFY(element, MATCHDOC);
     HitQ_Jostle_t super_jostle
-        = SUPER_METHOD_PTR(HITQUEUE, Lucy_HitQ_Jostle);
+        = SUPER_METHOD_PTR(HITQUEUE, LUCY_HitQ_Jostle);
     if (ivars->need_values) {
         MatchDocIVARS *const match_doc_ivars = MatchDoc_IVARS(match_doc);
         CERTIFY(match_doc_ivars->values, VARRAY);

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Search/LeafQuery.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/LeafQuery.c b/core/Lucy/Search/LeafQuery.c
index 9db068d..3901b43 100644
--- a/core/Lucy/Search/LeafQuery.c
+++ b/core/Lucy/Search/LeafQuery.c
@@ -115,7 +115,7 @@ Obj*
 LeafQuery_Dump_IMP(LeafQuery *self) {
     LeafQueryIVARS *ivars = LeafQuery_IVARS(self);
     LeafQuery_Dump_t super_dump
-        = SUPER_METHOD_PTR(LEAFQUERY, Lucy_LeafQuery_Dump);
+        = SUPER_METHOD_PTR(LEAFQUERY, LUCY_LeafQuery_Dump);
     Hash *dump = (Hash*)CERTIFY(super_dump(self), HASH);
     if (ivars->field) {
         Hash_Store_Str(dump, "field", 5, Freezer_dump((Obj*)ivars->field));
@@ -128,7 +128,7 @@ Obj*
 LeafQuery_Load_IMP(LeafQuery *self, Obj *dump) {
     Hash *source = (Hash*)CERTIFY(dump, HASH);
     LeafQuery_Load_t super_load
-        = SUPER_METHOD_PTR(LEAFQUERY, Lucy_LeafQuery_Load);
+        = SUPER_METHOD_PTR(LEAFQUERY, LUCY_LeafQuery_Load);
     LeafQuery *loaded = (LeafQuery*)super_load(self, dump);
     LeafQueryIVARS *loaded_ivars = LeafQuery_IVARS(loaded);
     Obj *field = Hash_Fetch_Str(source, "field", 5);

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Search/NOTQuery.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/NOTQuery.c b/core/Lucy/Search/NOTQuery.c
index 5f7832c..d328f61 100644
--- a/core/Lucy/Search/NOTQuery.c
+++ b/core/Lucy/Search/NOTQuery.c
@@ -67,7 +67,7 @@ NOTQuery_Equals_IMP(NOTQuery *self, Obj *other) {
     if ((NOTQuery*)other == self)   { return true; }
     if (!Obj_Is_A(other, NOTQUERY)) { return false; }
     NOTQuery_Equals_t super_equals
-        = (NOTQuery_Equals_t)SUPER_METHOD_PTR(NOTQUERY, Lucy_NOTQuery_Equals);
+        = (NOTQuery_Equals_t)SUPER_METHOD_PTR(NOTQUERY, LUCY_NOTQuery_Equals);
     return super_equals(self, other);
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Search/NoMatchQuery.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/NoMatchQuery.c b/core/Lucy/Search/NoMatchQuery.c
index ce09145..70f422f 100644
--- a/core/Lucy/Search/NoMatchQuery.c
+++ b/core/Lucy/Search/NoMatchQuery.c
@@ -81,7 +81,7 @@ Obj*
 NoMatchQuery_Dump_IMP(NoMatchQuery *self) {
     NoMatchQueryIVARS *const ivars = NoMatchQuery_IVARS(self);
     NoMatchQuery_Dump_t super_dump
-        = SUPER_METHOD_PTR(NOMATCHQUERY, Lucy_NoMatchQuery_Dump);
+        = SUPER_METHOD_PTR(NOMATCHQUERY, LUCY_NoMatchQuery_Dump);
     Hash *dump = (Hash*)CERTIFY(super_dump(self), HASH);
     Hash_Store_Str(dump, "fails_to_match", 14,
                    (Obj*)Bool_singleton(ivars->fails_to_match));
@@ -92,7 +92,7 @@ NoMatchQuery*
 NoMatchQuery_Load_IMP(NoMatchQuery *self, Obj *dump) {
     Hash *source = (Hash*)CERTIFY(dump, HASH);
     NoMatchQuery_Load_t super_load
-        = SUPER_METHOD_PTR(NOMATCHQUERY, Lucy_NoMatchQuery_Load);
+        = SUPER_METHOD_PTR(NOMATCHQUERY, LUCY_NoMatchQuery_Load);
     NoMatchQuery *loaded = super_load(self, dump);
     Obj *fails = CFISH_Hash_Fetch_Str(source, "fails_to_match", 14);
     NoMatchQuery_IVARS(loaded)->fails_to_match

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Search/ORQuery.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/ORQuery.c b/core/Lucy/Search/ORQuery.c
index 10f59e8..61c0668 100644
--- a/core/Lucy/Search/ORQuery.c
+++ b/core/Lucy/Search/ORQuery.c
@@ -52,7 +52,7 @@ ORQuery_Equals_IMP(ORQuery *self, Obj *other) {
     if ((ORQuery*)other == self)   { return true;  }
     if (!Obj_Is_A(other, ORQUERY)) { return false; }
     ORQuery_Equals_t super_equals
-        = (ORQuery_Equals_t)SUPER_METHOD_PTR(ORQUERY, Lucy_ORQuery_Equals);
+        = (ORQuery_Equals_t)SUPER_METHOD_PTR(ORQUERY, LUCY_ORQuery_Equals);
     return super_equals(self, other);
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Search/PhraseQuery.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/PhraseQuery.c b/core/Lucy/Search/PhraseQuery.c
index d049559..4eac2d7 100644
--- a/core/Lucy/Search/PhraseQuery.c
+++ b/core/Lucy/Search/PhraseQuery.c
@@ -94,7 +94,7 @@ Obj*
 PhraseQuery_Dump_IMP(PhraseQuery *self) {
     PhraseQueryIVARS *ivars = PhraseQuery_IVARS(self);
     PhraseQuery_Dump_t super_dump
-        = SUPER_METHOD_PTR(PHRASEQUERY, Lucy_PhraseQuery_Dump);
+        = SUPER_METHOD_PTR(PHRASEQUERY, LUCY_PhraseQuery_Dump);
     Hash *dump = (Hash*)CERTIFY(super_dump(self), HASH);
     Hash_Store_Str(dump, "field", 5, Freezer_dump((Obj*)ivars->field));
     Hash_Store_Str(dump, "terms", 5, Freezer_dump((Obj*)ivars->terms));
@@ -105,7 +105,7 @@ Obj*
 PhraseQuery_Load_IMP(PhraseQuery *self, Obj *dump) {
     Hash *source = (Hash*)CERTIFY(dump, HASH);
     PhraseQuery_Load_t super_load
-        = SUPER_METHOD_PTR(PHRASEQUERY, Lucy_PhraseQuery_Load);
+        = SUPER_METHOD_PTR(PHRASEQUERY, LUCY_PhraseQuery_Load);
     PhraseQuery *loaded = (PhraseQuery*)super_load(self, dump);
     PhraseQueryIVARS *loaded_ivars = PhraseQuery_IVARS(loaded);
     Obj *field = CERTIFY(Hash_Fetch_Str(source, "field", 5), OBJ);
@@ -231,7 +231,7 @@ PhraseCompiler_Serialize_IMP(PhraseCompiler *self, OutStream *outstream) {
     PhraseCompilerIVARS *const ivars = PhraseCompiler_IVARS(self);
     PhraseCompiler_Serialize_t super_serialize
         = (PhraseCompiler_Serialize_t)SUPER_METHOD_PTR(PHRASECOMPILER,
-                                                       Lucy_PhraseCompiler_Serialize);
+                                                       LUCY_PhraseCompiler_Serialize);
     super_serialize(self, outstream);
     OutStream_Write_F32(outstream, ivars->idf);
     OutStream_Write_F32(outstream, ivars->raw_weight);
@@ -242,7 +242,7 @@ PhraseCompiler_Serialize_IMP(PhraseCompiler *self, OutStream *outstream) {
 PhraseCompiler*
 PhraseCompiler_Deserialize_IMP(PhraseCompiler *self, InStream *instream) {
     PhraseCompiler_Deserialize_t super_deserialize
-        = SUPER_METHOD_PTR(PHRASECOMPILER, Lucy_PhraseCompiler_Deserialize);
+        = SUPER_METHOD_PTR(PHRASECOMPILER, LUCY_PhraseCompiler_Deserialize);
     self = super_deserialize(self, instream);
     PhraseCompilerIVARS *const ivars = PhraseCompiler_IVARS(self);
     ivars->idf               = InStream_Read_F32(instream);
@@ -257,7 +257,7 @@ PhraseCompiler_Equals_IMP(PhraseCompiler *self, Obj *other) {
     if (!Obj_Is_A(other, PHRASECOMPILER))                     { return false; }
     PhraseCompiler_Equals_t super_equals
         = (PhraseCompiler_Equals_t)SUPER_METHOD_PTR(PHRASECOMPILER,
-                                                    Lucy_PhraseCompiler_Equals);
+                                                    LUCY_PhraseCompiler_Equals);
     if (!super_equals(self, other))                           { return false; }
     PhraseCompilerIVARS *const ivars = PhraseCompiler_IVARS(self);
     PhraseCompilerIVARS *const ovars

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Search/PolyQuery.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/PolyQuery.c b/core/Lucy/Search/PolyQuery.c
index 76414ce..063888e 100644
--- a/core/Lucy/Search/PolyQuery.c
+++ b/core/Lucy/Search/PolyQuery.c
@@ -96,7 +96,7 @@ Obj*
 PolyQuery_Dump_IMP(PolyQuery *self) {
     PolyQueryIVARS *ivars = PolyQuery_IVARS(self);
     PolyQuery_Dump_t super_dump
-        = SUPER_METHOD_PTR(POLYQUERY, Lucy_PolyQuery_Dump);
+        = SUPER_METHOD_PTR(POLYQUERY, LUCY_PolyQuery_Dump);
     Hash *dump = (Hash*)CERTIFY(super_dump(self), HASH);
     Hash_Store_Str(dump, "children", 8, Freezer_dump((Obj*)ivars->children));
     return (Obj*)dump;
@@ -106,7 +106,7 @@ Obj*
 PolyQuery_Load_IMP(PolyQuery *self, Obj *dump) {
     Hash *source = (Hash*)CERTIFY(dump, HASH);
     PolyQuery_Load_t super_load
-        = SUPER_METHOD_PTR(POLYQUERY, Lucy_PolyQuery_Load);
+        = SUPER_METHOD_PTR(POLYQUERY, LUCY_PolyQuery_Load);
     PolyQuery *loaded = (PolyQuery*)super_load(self, dump);
     Obj *children = CERTIFY(Hash_Fetch_Str(source, "children", 8), OBJ);
     PolyQuery_IVARS(loaded)->children
@@ -206,7 +206,7 @@ PolyCompiler_Serialize_IMP(PolyCompiler *self, OutStream *outstream) {
     Freezer_serialize_charbuf(PolyCompiler_Get_Class_Name(self), outstream);
     Freezer_serialize_varray(ivars->children, outstream);
     PolyCompiler_Serialize_t super_serialize
-        = SUPER_METHOD_PTR(POLYCOMPILER, Lucy_PolyCompiler_Serialize);
+        = SUPER_METHOD_PTR(POLYCOMPILER, LUCY_PolyCompiler_Serialize);
     super_serialize(self, outstream);
 }
 
@@ -217,7 +217,7 @@ PolyCompiler_Deserialize_IMP(PolyCompiler *self, InStream *instream) {
     DECREF(class_name); // TODO Don't serialize class name.
     ivars->children = Freezer_read_varray(instream);
     PolyCompiler_Deserialize_t super_deserialize
-        = SUPER_METHOD_PTR(POLYCOMPILER, Lucy_PolyCompiler_Deserialize);
+        = SUPER_METHOD_PTR(POLYCOMPILER, LUCY_PolyCompiler_Deserialize);
     return super_deserialize(self, instream);
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Search/RangeQuery.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/RangeQuery.c b/core/Lucy/Search/RangeQuery.c
index 61fd2f3..5d792bc 100644
--- a/core/Lucy/Search/RangeQuery.c
+++ b/core/Lucy/Search/RangeQuery.c
@@ -164,7 +164,7 @@ Obj*
 RangeQuery_Dump_IMP(RangeQuery *self) {
     RangeQueryIVARS *ivars = RangeQuery_IVARS(self);
     RangeQuery_Dump_t super_dump
-        = SUPER_METHOD_PTR(RANGEQUERY, Lucy_RangeQuery_Dump);
+        = SUPER_METHOD_PTR(RANGEQUERY, LUCY_RangeQuery_Dump);
     Hash *dump = (Hash*)CERTIFY(super_dump(self), HASH);
     Hash_Store_Str(dump, "field", 5, Freezer_dump((Obj*)ivars->field));
     if (ivars->lower_term) {
@@ -186,7 +186,7 @@ Obj*
 RangeQuery_Load_IMP(RangeQuery *self, Obj *dump) {
     Hash *source = (Hash*)CERTIFY(dump, HASH);
     RangeQuery_Load_t super_load
-        = SUPER_METHOD_PTR(RANGEQUERY, Lucy_RangeQuery_Load);
+        = SUPER_METHOD_PTR(RANGEQUERY, LUCY_RangeQuery_Load);
     RangeQuery *loaded = (RangeQuery*)super_load(self, dump);
     RangeQueryIVARS *loaded_ivars = RangeQuery_IVARS(loaded);
     Obj *field = CERTIFY(Hash_Fetch_Str(source, "field", 5), OBJ);

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Search/RequiredOptionalQuery.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/RequiredOptionalQuery.c b/core/Lucy/Search/RequiredOptionalQuery.c
index ef666b2..5e1659d 100644
--- a/core/Lucy/Search/RequiredOptionalQuery.c
+++ b/core/Lucy/Search/RequiredOptionalQuery.c
@@ -85,7 +85,7 @@ ReqOptQuery_Equals_IMP(RequiredOptionalQuery *self, Obj *other) {
     if (!Obj_Is_A(other, REQUIREDOPTIONALQUERY)) { return false; }
     ReqOptQuery_Equals_t super_equals
         = (ReqOptQuery_Equals_t)SUPER_METHOD_PTR(REQUIREDOPTIONALQUERY,
-                                                 Lucy_ReqOptQuery_Equals);
+                                                 LUCY_ReqOptQuery_Equals);
     return super_equals(self, other);
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Search/TermQuery.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/TermQuery.c b/core/Lucy/Search/TermQuery.c
index 43549c3..0454be8 100644
--- a/core/Lucy/Search/TermQuery.c
+++ b/core/Lucy/Search/TermQuery.c
@@ -78,7 +78,7 @@ Obj*
 TermQuery_Dump_IMP(TermQuery *self) {
     TermQueryIVARS *ivars = TermQuery_IVARS(self);
     TermQuery_Dump_t super_dump
-        = SUPER_METHOD_PTR(TERMQUERY, Lucy_TermQuery_Dump);
+        = SUPER_METHOD_PTR(TERMQUERY, LUCY_TermQuery_Dump);
     Hash *dump = (Hash*)CERTIFY(super_dump(self), HASH);
     Hash_Store_Str(dump, "field", 5, Freezer_dump((Obj*)ivars->field));
     Hash_Store_Str(dump, "term", 4, Freezer_dump(ivars->term));
@@ -89,7 +89,7 @@ Obj*
 TermQuery_Load_IMP(TermQuery *self, Obj *dump) {
     Hash *source = (Hash*)CERTIFY(dump, HASH);
     TermQuery_Load_t super_load
-        = SUPER_METHOD_PTR(TERMQUERY, Lucy_TermQuery_Load);
+        = SUPER_METHOD_PTR(TERMQUERY, LUCY_TermQuery_Load);
     TermQuery *loaded = (TermQuery*)super_load(self, dump);
     TermQueryIVARS *loaded_ivars = TermQuery_IVARS(loaded);
     Obj *field = CERTIFY(Hash_Fetch_Str(source, "field", 5), OBJ);
@@ -191,7 +191,7 @@ bool
 TermCompiler_Equals_IMP(TermCompiler *self, Obj *other) {
     TermCompiler_Equals_t super_equals
         = (TermCompiler_Equals_t)SUPER_METHOD_PTR(TERMCOMPILER,
-                                                  Lucy_TermCompiler_Equals);
+                                                  LUCY_TermCompiler_Equals);
     if (!super_equals(self, other))                           { return false; }
     if (!Obj_Is_A(other, TERMCOMPILER))                       { return false; }
     TermCompilerIVARS *const ivars = TermCompiler_IVARS(self);
@@ -207,7 +207,7 @@ void
 TermCompiler_Serialize_IMP(TermCompiler *self, OutStream *outstream) {
     TermCompilerIVARS *const ivars = TermCompiler_IVARS(self);
     TermCompiler_Serialize_t super_serialize
-        = SUPER_METHOD_PTR(TERMCOMPILER, Lucy_TermCompiler_Serialize);
+        = SUPER_METHOD_PTR(TERMCOMPILER, LUCY_TermCompiler_Serialize);
     super_serialize(self, outstream);
     OutStream_Write_F32(outstream, ivars->idf);
     OutStream_Write_F32(outstream, ivars->raw_weight);
@@ -218,7 +218,7 @@ TermCompiler_Serialize_IMP(TermCompiler *self, OutStream *outstream) {
 TermCompiler*
 TermCompiler_Deserialize_IMP(TermCompiler *self, InStream *instream) {
     TermCompiler_Deserialize_t super_deserialize
-        = SUPER_METHOD_PTR(TERMCOMPILER, Lucy_TermCompiler_Deserialize);
+        = SUPER_METHOD_PTR(TERMCOMPILER, LUCY_TermCompiler_Deserialize);
     self = super_deserialize(self, instream);
     TermCompilerIVARS *const ivars = TermCompiler_IVARS(self);
     ivars->idf               = InStream_Read_F32(instream);

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Store/CompoundFileReader.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/CompoundFileReader.c b/core/Lucy/Store/CompoundFileReader.c
index 9161644..e76c6d3 100644
--- a/core/Lucy/Store/CompoundFileReader.c
+++ b/core/Lucy/Store/CompoundFileReader.c
@@ -128,7 +128,7 @@ CFReader_Set_Path_IMP(CompoundFileReader *self, const CharBuf *path) {
     Folder_Set_Path(ivars->real_folder, path);
     CFReader_Set_Path_t super_set_path
         = (CFReader_Set_Path_t)SUPER_METHOD_PTR(COMPOUNDFILEREADER,
-                                                Lucy_CFReader_Set_Path);
+                                                LUCY_CFReader_Set_Path);
     super_set_path(self, path);
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Store/SharedLock.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/SharedLock.c b/core/Lucy/Store/SharedLock.c
index 9374cce..420076f 100644
--- a/core/Lucy/Store/SharedLock.c
+++ b/core/Lucy/Store/SharedLock.c
@@ -57,7 +57,7 @@ ShLock_Request_IMP(SharedLock *self) {
     SharedLockIVARS *const ivars = ShLock_IVARS(self);
     uint32_t i = 0;
     ShLock_Request_t super_request
-        = SUPER_METHOD_PTR(SHAREDLOCK, Lucy_ShLock_Request);
+        = SUPER_METHOD_PTR(SHAREDLOCK, LUCY_ShLock_Request);
 
     // Empty lock_path indicates whether this particular instance is locked.
     if (ivars->lock_path
@@ -86,7 +86,7 @@ ShLock_Release_IMP(SharedLock *self) {
     SharedLockIVARS *const ivars = ShLock_IVARS(self);
     if (ivars->lock_path && !CB_Equals_Str(ivars->lock_path, "", 0)) {
         ShLock_Release_t super_release
-            = SUPER_METHOD_PTR(SHAREDLOCK, Lucy_ShLock_Release);
+            = SUPER_METHOD_PTR(SHAREDLOCK, LUCY_ShLock_Release);
         super_release(self);
 
         // Empty out lock_path.

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Test/Index/TestTermInfo.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Index/TestTermInfo.c b/core/Lucy/Test/Index/TestTermInfo.c
index d903292..5a9cc38 100644
--- a/core/Lucy/Test/Index/TestTermInfo.c
+++ b/core/Lucy/Test/Index/TestTermInfo.c
@@ -37,7 +37,7 @@ test_freqfilepos(TestBatchRunner *runner) {
 
     TermInfo* cloned_tinfo = TInfo_Clone(tinfo);
 
-    TEST_FALSE(runner, Lucy_TInfo_Equals(tinfo, (Obj*)cloned_tinfo),"the clone should be a separate C struct");
+    TEST_FALSE(runner, LUCY_TInfo_Equals(tinfo, (Obj*)cloned_tinfo),"the clone should be a separate C struct");
     TEST_INT_EQ(runner, TInfo_Get_Doc_Freq(tinfo), 10, "new sets doc_freq correctly" );
     TEST_INT_EQ(runner, TInfo_Get_Doc_Freq(tinfo), 10, "... doc_freq cloned" );
     TEST_INT_EQ(runner, TInfo_Get_Post_FilePos(tinfo), 20, "... post_filepos cloned" );

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Test/Search/TestQueryParserLogic.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Search/TestQueryParserLogic.c b/core/Lucy/Test/Search/TestQueryParserLogic.c
index ad4ca55..3ebe792 100644
--- a/core/Lucy/Test/Search/TestQueryParserLogic.c
+++ b/core/Lucy/Test/Search/TestQueryParserLogic.c
@@ -775,9 +775,9 @@ prune_test_not_and_not() {
 /***************************************************************************/
 
 typedef TestQueryParser*
-(*Lucy_TestQPLogic_Logical_Test_t)(uint32_t boolop_sym);
+(*LUCY_TestQPLogic_Logical_Test_t)(uint32_t boolop_sym);
 
-static Lucy_TestQPLogic_Logical_Test_t logical_test_funcs[] = {
+static LUCY_TestQPLogic_Logical_Test_t logical_test_funcs[] = {
     logical_test_empty_phrase,
     logical_test_empty_parens,
     logical_test_nested_empty_parens,
@@ -843,9 +843,9 @@ static Lucy_TestQPLogic_Logical_Test_t logical_test_funcs[] = {
 };
 
 typedef TestQueryParser*
-(*Lucy_TestQPLogic_Prune_Test_t)();
+(*LUCY_TestQPLogic_Prune_Test_t)();
 
-static Lucy_TestQPLogic_Prune_Test_t prune_test_funcs[] = {
+static LUCY_TestQPLogic_Prune_Test_t prune_test_funcs[] = {
     prune_test_null_querystring,
     prune_test_matchall,
     prune_test_nomatch,
@@ -898,7 +898,7 @@ TestQPLogic_Run_IMP(TestQueryParserLogic *self, TestBatchRunner *runner) {
 
     // Run logical tests with default boolop of OR.
     for (i = 0; logical_test_funcs[i] != NULL; i++) {
-        Lucy_TestQPLogic_Logical_Test_t test_func = logical_test_funcs[i];
+        LUCY_TestQPLogic_Logical_Test_t test_func = logical_test_funcs[i];
         TestQueryParser *test_case_obj = test_func(BOOLOP_OR);
         TestQueryParserIVARS *test_case = TestQP_IVARS(test_case_obj);
         Query *tree     = QParser_Tree(or_parser, test_case->query_string);
@@ -917,7 +917,7 @@ TestQPLogic_Run_IMP(TestQueryParserLogic *self, TestBatchRunner *runner) {
 
     // Run logical tests with default boolop of AND.
     for (i = 0; logical_test_funcs[i] != NULL; i++) {
-        Lucy_TestQPLogic_Logical_Test_t test_func = logical_test_funcs[i];
+        LUCY_TestQPLogic_Logical_Test_t test_func = logical_test_funcs[i];
         TestQueryParser *test_case_obj = test_func(BOOLOP_AND);
         TestQueryParserIVARS *test_case = TestQP_IVARS(test_case_obj);
         Query *tree     = QParser_Tree(and_parser, test_case->query_string);
@@ -936,7 +936,7 @@ TestQPLogic_Run_IMP(TestQueryParserLogic *self, TestBatchRunner *runner) {
 
     // Run tests for QParser_Prune().
     for (i = 0; prune_test_funcs[i] != NULL; i++) {
-        Lucy_TestQPLogic_Prune_Test_t test_func = prune_test_funcs[i];
+        LUCY_TestQPLogic_Prune_Test_t test_func = prune_test_funcs[i];
         TestQueryParser *test_case_obj = test_func();
         TestQueryParserIVARS *test_case = TestQP_IVARS(test_case_obj);
         CharBuf *qstring = test_case->tree

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Test/Search/TestQueryParserSyntax.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Search/TestQueryParserSyntax.c b/core/Lucy/Test/Search/TestQueryParserSyntax.c
index 3274da5..91fb30c 100644
--- a/core/Lucy/Test/Search/TestQueryParserSyntax.c
+++ b/core/Lucy/Test/Search/TestQueryParserSyntax.c
@@ -335,9 +335,9 @@ syntax_test_double_colon() {
 /***************************************************************************/
 
 typedef TestQueryParser*
-(*Lucy_TestQPSyntax_Test_t)();
+(*LUCY_TestQPSyntax_Test_t)();
 
-static Lucy_TestQPSyntax_Test_t leaf_test_funcs[] = {
+static LUCY_TestQPSyntax_Test_t leaf_test_funcs[] = {
     leaf_test_simple_term,
     leaf_test_simple_phrase,
     leaf_test_unclosed_quote,
@@ -355,7 +355,7 @@ static Lucy_TestQPSyntax_Test_t leaf_test_funcs[] = {
     NULL
 };
 
-static Lucy_TestQPSyntax_Test_t syntax_test_funcs[] = {
+static LUCY_TestQPSyntax_Test_t syntax_test_funcs[] = {
     syntax_test_minus_plus,
     syntax_test_plus_minus,
     syntax_test_minus_minus,
@@ -396,7 +396,7 @@ test_query_parser_syntax(TestBatchRunner *runner) {
     QParser_Set_Heed_Colons(qparser, true);
 
     for (uint32_t i = 0; leaf_test_funcs[i] != NULL; i++) {
-        Lucy_TestQPSyntax_Test_t test_func = leaf_test_funcs[i];
+        LUCY_TestQPSyntax_Test_t test_func = leaf_test_funcs[i];
         TestQueryParser *test_case = test_func();
         TestQueryParserIVARS *ivars = TestQP_IVARS(test_case);
         Query *tree     = QParser_Tree(qparser, ivars->query_string);
@@ -418,7 +418,7 @@ test_query_parser_syntax(TestBatchRunner *runner) {
     }
 
     for (uint32_t i = 0; syntax_test_funcs[i] != NULL; i++) {
-        Lucy_TestQPSyntax_Test_t test_func = syntax_test_funcs[i];
+        LUCY_TestQPSyntax_Test_t test_func = syntax_test_funcs[i];
         TestQueryParser *test_case = test_func();
         TestQueryParserIVARS *ivars = TestQP_IVARS(test_case);
         Query *tree   = QParser_Tree(qparser, ivars->query_string);

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Test/Store/TestFileHandle.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Store/TestFileHandle.c b/core/Lucy/Test/Store/TestFileHandle.c
index a3b2caf..8e5e4d8 100644
--- a/core/Lucy/Test/Store/TestFileHandle.c
+++ b/core/Lucy/Test/Store/TestFileHandle.c
@@ -44,7 +44,7 @@ S_new_filehandle() {
     if (!vtable) {
         vtable = VTable_singleton((CharBuf*)klass, FILEHANDLE);
     }
-    VTable_Override(vtable, S_no_op_method, Lucy_FH_Close_OFFSET);
+    VTable_Override(vtable, S_no_op_method, LUCY_FH_Close_OFFSET);
     fh = (FileHandle*)VTable_Make_Obj(vtable);
     return FH_do_open(fh, NULL, 0);
 }

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Test/Store/TestFolderCommon.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Store/TestFolderCommon.c b/core/Lucy/Test/Store/TestFolderCommon.c
index d902bb6..f1a89a7 100644
--- a/core/Lucy/Test/Store/TestFolderCommon.c
+++ b/core/Lucy/Test/Store/TestFolderCommon.c
@@ -26,8 +26,8 @@
 #include "Lucy/Store/InStream.h"
 #include "Lucy/Store/OutStream.h"
 
-#define set_up_t    Lucy_TestFolderCommon_Set_Up_t
-#define tear_down_t Lucy_TestFolderCommon_Tear_Down_t
+#define set_up_t    LUCY_TestFolderCommon_Set_Up_t
+#define tear_down_t LUCY_TestFolderCommon_Tear_Down_t
 
 static CharBuf *foo           = NULL;
 static CharBuf *bar           = NULL;

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Test/Store/TestFolderCommon.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Store/TestFolderCommon.cfh b/core/Lucy/Test/Store/TestFolderCommon.cfh
index e75dce4..75042f0 100644
--- a/core/Lucy/Test/Store/TestFolderCommon.cfh
+++ b/core/Lucy/Test/Store/TestFolderCommon.cfh
@@ -18,12 +18,12 @@ parcel TestLucy;
 
 __C__
 typedef lucy_Folder*
-Lucy_TestFolderCommon_Set_Up_t(void);
+LUCY_TestFolderCommon_Set_Up_t(void);
 typedef void
-Lucy_TestFolderCommon_Tear_Down_t(void);
+LUCY_TestFolderCommon_Tear_Down_t(void);
 #ifdef LUCY_USE_SHORT_NAMES
-  #define TestFolderCommon_Set_Up_t    Lucy_TestFolderCommon_Set_Up_t
-  #define TestFolderCommon_Tear_Down_t Lucy_TestFolderCommon_Tear_Down_t
+  #define TestFolderCommon_Set_Up_t    LUCY_TestFolderCommon_Set_Up_t
+  #define TestFolderCommon_Tear_Down_t LUCY_TestFolderCommon_Tear_Down_t
 #endif
 __END_C__
 
@@ -33,8 +33,8 @@ inert class Lucy::Test::Store::TestFolderCommon {
 
     inert void
     run_tests(TestBatchRunner *runner,
-              Lucy_TestFolderCommon_Set_Up_t set_up,
-              Lucy_TestFolderCommon_Tear_Down_t tear_down);
+              LUCY_TestFolderCommon_Set_Up_t set_up,
+              LUCY_TestFolderCommon_Tear_Down_t tear_down);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Util/BBSortEx.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Util/BBSortEx.c b/core/Lucy/Util/BBSortEx.c
index fe0df5e..92d80a5 100644
--- a/core/Lucy/Util/BBSortEx.c
+++ b/core/Lucy/Util/BBSortEx.c
@@ -58,7 +58,7 @@ BBSortEx_Clear_Cache_IMP(BBSortEx *self) {
     }
     ivars->mem_consumed = 0;
     BBSortEx_Clear_Cache_t super_clear_cache
-        = SUPER_METHOD_PTR(BBSORTEX, Lucy_BBSortEx_Clear_Cache);
+        = SUPER_METHOD_PTR(BBSORTEX, LUCY_BBSortEx_Clear_Cache);
     super_clear_cache(self);
 }
 
@@ -66,7 +66,7 @@ void
 BBSortEx_Feed_IMP(BBSortEx *self, void *data) {
     BBSortExIVARS *const ivars = BBSortEx_IVARS(self);
     BBSortEx_Feed_t super_feed
-        = SUPER_METHOD_PTR(BBSORTEX, Lucy_BBSortEx_Feed);
+        = SUPER_METHOD_PTR(BBSORTEX, LUCY_BBSortEx_Feed);
     super_feed(self, data);
 
     // Flush() if necessary.

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/Lucy/Util/SortExternal.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Util/SortExternal.c b/core/Lucy/Util/SortExternal.c
index e2648dc..fc86556 100644
--- a/core/Lucy/Util/SortExternal.c
+++ b/core/Lucy/Util/SortExternal.c
@@ -135,7 +135,7 @@ SortEx_Sort_Cache_IMP(SortExternal *self) {
     if (ivars->cache_max != 0) {
         VTable *vtable = SortEx_Get_VTable(self);
         CFISH_Sort_Compare_t compare
-            = (CFISH_Sort_Compare_t)METHOD_PTR(vtable, Lucy_SortEx_Compare);
+            = (CFISH_Sort_Compare_t)METHOD_PTR(vtable, LUCY_SortEx_Compare);
         if (ivars->scratch_cap < ivars->cache_cap) {
             ivars->scratch_cap = ivars->cache_cap;
             ivars->scratch
@@ -232,7 +232,7 @@ S_absorb_slices(SortExternal *self, SortExternalIVARS *ivars,
     uint32_t   *slice_sizes  = ivars->slice_sizes;
     VTable     *vtable       = SortEx_Get_VTable(self);
     CFISH_Sort_Compare_t compare
-        = (CFISH_Sort_Compare_t)METHOD_PTR(vtable, Lucy_SortEx_Compare);
+        = (CFISH_Sort_Compare_t)METHOD_PTR(vtable, LUCY_SortEx_Compare);
 
     if (ivars->cache_max != 0) { THROW(ERR, "Can't refill unless empty"); }
 
@@ -325,7 +325,7 @@ S_find_slice_size(SortExternal *self, SortExternalIVARS *ivars,
     uint8_t *const   cache   = ivars->cache;
     const size_t     width   = ivars->width;
     SortEx_Compare_t compare
-        = METHOD_PTR(SortEx_Get_VTable(self), Lucy_SortEx_Compare);
+        = METHOD_PTR(SortEx_Get_VTable(self), LUCY_SortEx_Compare);
 
     // Binary search.
     while (hi - lo > 1) {

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/core/LucyX/Search/ProximityQuery.c
----------------------------------------------------------------------
diff --git a/core/LucyX/Search/ProximityQuery.c b/core/LucyX/Search/ProximityQuery.c
index be63a40..771dbfa 100644
--- a/core/LucyX/Search/ProximityQuery.c
+++ b/core/LucyX/Search/ProximityQuery.c
@@ -100,7 +100,7 @@ Obj*
 ProximityQuery_Dump_IMP(ProximityQuery *self) {
     ProximityQueryIVARS *ivars = ProximityQuery_IVARS(self);
     ProximityQuery_Dump_t super_dump
-        = SUPER_METHOD_PTR(PROXIMITYQUERY, Lucy_ProximityQuery_Dump);
+        = SUPER_METHOD_PTR(PROXIMITYQUERY, LUCY_ProximityQuery_Dump);
     Hash *dump = (Hash*)CERTIFY(super_dump(self), HASH);
     Hash_Store_Str(dump, "field", 5, Freezer_dump((Obj*)ivars->field));
     Hash_Store_Str(dump, "terms", 5, Freezer_dump((Obj*)ivars->terms));
@@ -113,7 +113,7 @@ Obj*
 ProximityQuery_Load_IMP(ProximityQuery *self, Obj *dump) {
     Hash *source = (Hash*)CERTIFY(dump, HASH);
     ProximityQuery_Load_t super_load
-        = SUPER_METHOD_PTR(PROXIMITYQUERY, Lucy_ProximityQuery_Load);
+        = SUPER_METHOD_PTR(PROXIMITYQUERY, LUCY_ProximityQuery_Load);
     ProximityQuery *loaded = (ProximityQuery*)super_load(self, dump);
     ProximityQueryIVARS *loaded_ivars = ProximityQuery_IVARS(loaded);
     Obj *field = CERTIFY(Hash_Fetch_Str(source, "field", 5), OBJ);
@@ -251,7 +251,7 @@ void
 ProximityCompiler_Serialize_IMP(ProximityCompiler *self,
                                 OutStream *outstream) {
     ProximityCompiler_Serialize_t super_serialize
-            = SUPER_METHOD_PTR(PROXIMITYCOMPILER, Lucy_ProximityCompiler_Serialize);
+            = SUPER_METHOD_PTR(PROXIMITYCOMPILER, LUCY_ProximityCompiler_Serialize);
     super_serialize(self, outstream);
     ProximityCompilerIVARS *const ivars = ProximityCompiler_IVARS(self);
     OutStream_Write_F32(outstream, ivars->idf);
@@ -265,7 +265,7 @@ ProximityCompiler*
 ProximityCompiler_Deserialize_IMP(ProximityCompiler *self,
                                   InStream *instream) {
     ProximityCompiler_Deserialize_t super_deserialize
-            = SUPER_METHOD_PTR(PROXIMITYCOMPILER, Lucy_ProximityCompiler_Deserialize);
+            = SUPER_METHOD_PTR(PROXIMITYCOMPILER, LUCY_ProximityCompiler_Deserialize);
     self = super_deserialize(self, instream);
     ProximityCompilerIVARS *const ivars = ProximityCompiler_IVARS(self);
     ivars->idf               = InStream_Read_F32(instream);
@@ -282,7 +282,7 @@ ProximityCompiler_Equals_IMP(ProximityCompiler *self, Obj *other) {
     if (!Obj_Is_A(other, PROXIMITYCOMPILER))      { return false; }
     ProximityCompiler_Equals_t super_equals
         = (ProximityCompiler_Equals_t)SUPER_METHOD_PTR(PROXIMITYCOMPILER,
-                                                       Lucy_ProximityCompiler_Equals);
+                                                       LUCY_ProximityCompiler_Equals);
     if (!super_equals(self, other)) { return false; }
     ProximityCompilerIVARS *const ivars = ProximityCompiler_IVARS(self);
     ProximityCompilerIVARS *const ovars

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/perl/buildlib/Lucy/Build/Binding/Analysis.pm
----------------------------------------------------------------------
diff --git a/perl/buildlib/Lucy/Build/Binding/Analysis.pm b/perl/buildlib/Lucy/Build/Binding/Analysis.pm
index 42dc232..53681bf 100644
--- a/perl/buildlib/Lucy/Build/Binding/Analysis.pm
+++ b/perl/buildlib/Lucy/Build/Binding/Analysis.pm
@@ -378,7 +378,7 @@ SV*
 get_text(self)
     lucy_Token *self;
 CODE:
-    RETVAL = newSVpvn(Lucy_Token_Get_Text(self), Lucy_Token_Get_Len(self));
+    RETVAL = newSVpvn(LUCY_Token_Get_Text(self), LUCY_Token_Get_Len(self));
     SvUTF8_on(RETVAL);
 OUTPUT: RETVAL
 
@@ -390,7 +390,7 @@ PPCODE:
 {
     STRLEN len;
     char *ptr = SvPVutf8(sv, len);
-    Lucy_Token_Set_Text(self, ptr, len);
+    LUCY_Token_Set_Text(self, ptr, len);
 }
 END_XS
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/perl/buildlib/Lucy/Build/Binding/Document.pm
----------------------------------------------------------------------
diff --git a/perl/buildlib/Lucy/Build/Binding/Document.pm b/perl/buildlib/Lucy/Build/Binding/Document.pm
index 640c685..e75e1db 100644
--- a/perl/buildlib/Lucy/Build/Binding/Document.pm
+++ b/perl/buildlib/Lucy/Build/Binding/Document.pm
@@ -90,7 +90,7 @@ get_fields(self, ...)
     lucy_Doc *self;
 CODE:
     CFISH_UNUSED_VAR(items);
-    RETVAL = newRV_inc((SV*)Lucy_Doc_Get_Fields(self));
+    RETVAL = newRV_inc((SV*)LUCY_Doc_Get_Fields(self));
 OUTPUT: RETVAL
 
 void
@@ -98,7 +98,7 @@ set_fields(self, fields)
     lucy_Doc *self;
     HV *fields;
 PPCODE:
-    Lucy_Doc_Set_Fields_IMP(self, fields);
+    LUCY_Doc_Set_Fields_IMP(self, fields);
 END_XS_CODE
 
     my $binding = Clownfish::CFC::Binding::Perl::Class->new(

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/perl/buildlib/Lucy/Build/Binding/Index.pm
----------------------------------------------------------------------
diff --git a/perl/buildlib/Lucy/Build/Binding/Index.pm b/perl/buildlib/Lucy/Build/Binding/Index.pm
index 9f84043..5825d4a 100644
--- a/perl/buildlib/Lucy/Build/Binding/Index.pm
+++ b/perl/buildlib/Lucy/Build/Binding/Index.pm
@@ -493,8 +493,8 @@ PPCODE:
     else if (XSBind_sv_defined(doc_sv) && SvROK(doc_sv)) {
         HV *maybe_fields = (HV*)SvRV(doc_sv);
         if (SvTYPE((SV*)maybe_fields) == SVt_PVHV) {
-            doc = Lucy_Indexer_Get_Stock_Doc(self);
-            Lucy_Doc_Set_Fields(doc, maybe_fields);
+            doc = LUCY_Indexer_Get_Stock_Doc(self);
+            LUCY_Doc_Set_Fields(doc, maybe_fields);
         }
     }
     if (!doc) {
@@ -502,7 +502,7 @@ PPCODE:
               CFISH_VTable_Get_Name(LUCY_DOC));
     }
 
-    Lucy_Indexer_Add_Doc(self, doc, boost);
+    LUCY_Indexer_Add_Doc(self, doc, boost);
 }
 END_XS_CODE
 
@@ -616,10 +616,10 @@ get_prox(self)
 CODE:
 {
     AV *out_av            = newAV();
-    uint32_t *positions  = Lucy_ScorePost_Get_Prox(self);
+    uint32_t *positions  = LUCY_ScorePost_Get_Prox(self);
     uint32_t i, max;
 
-    for (i = 0, max = Lucy_ScorePost_Get_Freq(self); i < max; i++) {
+    for (i = 0, max = LUCY_ScorePost_Get_Freq(self); i < max; i++) {
         SV *pos_sv = newSVuv(positions[i]);
         av_push(out_av, pos_sv);
     }
@@ -861,7 +861,7 @@ SV*
 get_norm_decoder(self)
     lucy_Similarity *self;
 CODE:
-    RETVAL = newSVpvn((char*)Lucy_Sim_Get_Norm_Decoder(self),
+    RETVAL = newSVpvn((char*)LUCY_Sim_Get_Norm_Decoder(self),
                       (256 * sizeof(float)));
 OUTPUT: RETVAL
 END_XS_CODE
@@ -936,8 +936,8 @@ CODE:
         CFISH_RETHROW(CFISH_INCREF(cfish_Err_get_error()));
     }
     {
-        cfish_Obj *blank = Lucy_SortCache_Make_Blank(self);
-        cfish_Obj *value = Lucy_SortCache_Value(self, ord, blank);
+        cfish_Obj *blank = LUCY_SortCache_Make_Blank(self);
+        cfish_Obj *value = LUCY_SortCache_Value(self, ord, blank);
         RETVAL = XSBind_cfish_to_perl(value);
         CFISH_DECREF(blank);
     }

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/perl/buildlib/Lucy/Build/Binding/Misc.pm
----------------------------------------------------------------------
diff --git a/perl/buildlib/Lucy/Build/Binding/Misc.pm b/perl/buildlib/Lucy/Build/Binding/Misc.pm
index 83fc45e..947d97d 100644
--- a/perl/buildlib/Lucy/Build/Binding/Misc.pm
+++ b/perl/buildlib/Lucy/Build/Binding/Misc.pm
@@ -108,9 +108,9 @@ PPCODE:
 
         lucy_Freezer_serialize(self, target);
 
-        Lucy_OutStream_Close(target);
+        LUCY_OutStream_Close(target);
         serialized_bb
-            = Lucy_RAMFile_Get_Contents(Lucy_RAMFH_Get_File(file_handle));
+            = LUCY_RAMFile_Get_Contents(LUCY_RAMFH_Get_File(file_handle));
         retval = XSBind_bb_to_sv(serialized_bb);
         CFISH_DECREF(file_handle);
         CFISH_DECREF(target);

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/perl/buildlib/Lucy/Build/Binding/Object.pm
----------------------------------------------------------------------
diff --git a/perl/buildlib/Lucy/Build/Binding/Object.pm b/perl/buildlib/Lucy/Build/Binding/Object.pm
index 5f04fe2..a5b94ab 100644
--- a/perl/buildlib/Lucy/Build/Binding/Object.pm
+++ b/perl/buildlib/Lucy/Build/Binding/Object.pm
@@ -123,11 +123,11 @@ CODE:
 {
     AV *out_av = newAV();
     uint32_t i;
-    uint32_t size = Lucy_I32Arr_Get_Size(self);
+    uint32_t size = LUCY_I32Arr_Get_Size(self);
 
     av_extend(out_av, size);
     for (i = 0; i < size; i++) {
-        int32_t result = Lucy_I32Arr_Get(self, i);
+        int32_t result = LUCY_I32Arr_Get(self, i);
         SV* result_sv = result == -1 ? newSV(0) : newSViv(result);
         av_push(out_av, result_sv);
     }

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/perl/buildlib/Lucy/Build/Binding/Store.pm
----------------------------------------------------------------------
diff --git a/perl/buildlib/Lucy/Build/Binding/Store.pm b/perl/buildlib/Lucy/Build/Binding/Store.pm
index 008f1e8..daec00d 100644
--- a/perl/buildlib/Lucy/Build/Binding/Store.pm
+++ b/perl/buildlib/Lucy/Build/Binding/Store.pm
@@ -161,7 +161,7 @@ PPCODE:
     (void)SvUPGRADE(buffer_sv, SVt_PV);
     if (!SvPOK(buffer_sv)) { SvCUR_set(buffer_sv, 0); }
     ptr = SvGROW(buffer_sv, total_len + 1);
-    Lucy_InStream_Read_Bytes(self, ptr + offset, len);
+    LUCY_InStream_Read_Bytes(self, ptr + offset, len);
     SvPOK_on(buffer_sv);
     if (SvCUR(buffer_sv) < total_len) {
         SvCUR_set(buffer_sv, total_len);
@@ -175,14 +175,14 @@ read_string(self)
 CODE:
 {
     char *ptr;
-    size_t len = Lucy_InStream_Read_C32(self);
+    size_t len = LUCY_InStream_Read_C32(self);
     RETVAL = newSV(len + 1);
     SvCUR_set(RETVAL, len);
     SvPOK_on(RETVAL);
     SvUTF8_on(RETVAL); // Trust source.  Reconsider if API goes public.
     *SvEND(RETVAL) = '\0';
     ptr = SvPVX(RETVAL);
-    Lucy_InStream_Read_Bytes(self, ptr, len);
+    LUCY_InStream_Read_Bytes(self, ptr, len);
 }
 OUTPUT: RETVAL
 
@@ -195,7 +195,7 @@ CODE:
     char *ptr;
     (void)SvUPGRADE(buffer_sv, SVt_PV);
     ptr = SvGROW(buffer_sv, 10 + 1);
-    RETVAL = Lucy_InStream_Read_Raw_C64(self, ptr);
+    RETVAL = LUCY_InStream_Read_Raw_C64(self, ptr);
     SvPOK_on(buffer_sv);
     SvCUR_set(buffer_sv, RETVAL);
 }
@@ -337,7 +337,7 @@ PPCODE:
     for (i = 1; i < items; i++) {
         STRLEN len;
         char *ptr = SvPV(ST(i), len);
-        Lucy_OutStream_Write_Bytes(self, ptr, len);
+        LUCY_OutStream_Write_Bytes(self, ptr, len);
     }
 }
 
@@ -349,8 +349,8 @@ PPCODE:
 {
     STRLEN len = 0;
     char *ptr = SvPVutf8(aSV, len);
-    Lucy_OutStream_Write_C32(self, len);
-    Lucy_OutStream_Write_Bytes(self, ptr, len);
+    LUCY_OutStream_Write_C32(self, len);
+    LUCY_OutStream_Write_Bytes(self, ptr, len);
 }
 END_XS_CODE
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/perl/buildlib/Lucy/Build/Binding/Util.pm
----------------------------------------------------------------------
diff --git a/perl/buildlib/Lucy/Build/Binding/Util.pm b/perl/buildlib/Lucy/Build/Binding/Util.pm
index 8505efd..6d6ee2d 100644
--- a/perl/buildlib/Lucy/Build/Binding/Util.pm
+++ b/perl/buildlib/Lucy/Build/Binding/Util.pm
@@ -42,7 +42,7 @@ fetch(self)
     lucy_BBSortEx *self;
 CODE:
 {
-    void *address = Lucy_BBSortEx_Fetch(self);
+    void *address = LUCY_BBSortEx_Fetch(self);
     if (address) {
         RETVAL = XSBind_cfish_to_perl(*(cfish_Obj**)address);
         CFISH_DECREF(*(cfish_Obj**)address);
@@ -58,7 +58,7 @@ peek(self)
     lucy_BBSortEx *self;
 CODE:
 {
-    void *address = Lucy_BBSortEx_Peek(self);
+    void *address = LUCY_BBSortEx_Peek(self);
     if (address) {
         RETVAL = XSBind_cfish_to_perl(*(cfish_Obj**)address);
     }
@@ -74,7 +74,7 @@ feed(self, bb)
     cfish_ByteBuf *bb;
 CODE:
     CFISH_INCREF(bb);
-    Lucy_BBSortEx_Feed(self, &bb);
+    LUCY_BBSortEx_Feed(self, &bb);
 
 END_XS_CODE
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/perl/xs/Lucy/Analysis/RegexTokenizer.c
----------------------------------------------------------------------
diff --git a/perl/xs/Lucy/Analysis/RegexTokenizer.c b/perl/xs/Lucy/Analysis/RegexTokenizer.c
index eb6c015..e8ccf7d 100644
--- a/perl/xs/Lucy/Analysis/RegexTokenizer.c
+++ b/perl/xs/Lucy/Analysis/RegexTokenizer.c
@@ -120,7 +120,7 @@ S_set_pattern_from_token_re(lucy_RegexTokenizer *self, void *token_re) {
 }
 
 void
-Lucy_RegexTokenizer_Set_Token_RE_IMP(lucy_RegexTokenizer *self,
+LUCY_RegexTokenizer_Set_Token_RE_IMP(lucy_RegexTokenizer *self,
                                      void *token_re) {
     S_set_token_re_but_not_pattern(self, token_re);
     // Set pattern as a side effect.
@@ -128,7 +128,7 @@ Lucy_RegexTokenizer_Set_Token_RE_IMP(lucy_RegexTokenizer *self,
 }
 
 void
-Lucy_RegexTokenizer_Destroy_IMP(lucy_RegexTokenizer *self) {
+LUCY_RegexTokenizer_Destroy_IMP(lucy_RegexTokenizer *self) {
     lucy_RegexTokenizerIVARS *const ivars = lucy_RegexTokenizer_IVARS(self);
     CFISH_DECREF(ivars->pattern);
     ReREFCNT_dec(((REGEXP*)ivars->token_re));
@@ -136,7 +136,7 @@ Lucy_RegexTokenizer_Destroy_IMP(lucy_RegexTokenizer *self) {
 }
 
 void
-Lucy_RegexTokenizer_Tokenize_Str_IMP(lucy_RegexTokenizer *self,
+LUCY_RegexTokenizer_Tokenize_Str_IMP(lucy_RegexTokenizer *self,
                                      const char *string, size_t string_len,
                                      lucy_Inversion *inversion) {
     lucy_RegexTokenizerIVARS *const ivars = lucy_RegexTokenizer_IVARS(self);
@@ -192,7 +192,7 @@ Lucy_RegexTokenizer_Tokenize_Str_IMP(lucy_RegexTokenizer *self,
         end = num_code_points;
 
         // Add a token to the new inversion.
-        Lucy_Inversion_Append(inversion,
+        LUCY_Inversion_Append(inversion,
                               lucy_Token_new(
                                   start_ptr,
                                   (end_ptr - start_ptr),

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/perl/xs/Lucy/Document/Doc.c
----------------------------------------------------------------------
diff --git a/perl/xs/Lucy/Document/Doc.c b/perl/xs/Lucy/Document/Doc.c
index c460cdf..f262884 100644
--- a/perl/xs/Lucy/Document/Doc.c
+++ b/perl/xs/Lucy/Document/Doc.c
@@ -39,20 +39,20 @@ lucy_Doc_init(lucy_Doc *self, void *fields, int32_t doc_id) {
 }
 
 void
-Lucy_Doc_Set_Fields_IMP(lucy_Doc *self, void *fields) {
+LUCY_Doc_Set_Fields_IMP(lucy_Doc *self, void *fields) {
     lucy_DocIVARS *const ivars = lucy_Doc_IVARS(self);
     if (ivars->fields) { SvREFCNT_dec((SV*)ivars->fields); }
     ivars->fields = SvREFCNT_inc((SV*)fields);
 }
 
 uint32_t
-Lucy_Doc_Get_Size_IMP(lucy_Doc *self) {
+LUCY_Doc_Get_Size_IMP(lucy_Doc *self) {
     lucy_DocIVARS *const ivars = lucy_Doc_IVARS(self);
     return ivars->fields ? HvKEYS((HV*)ivars->fields) : 0;
 }
 
 void
-Lucy_Doc_Store_IMP(lucy_Doc *self, const cfish_CharBuf *field, cfish_Obj *value) {
+LUCY_Doc_Store_IMP(lucy_Doc *self, const cfish_CharBuf *field, cfish_Obj *value) {
     lucy_DocIVARS *const ivars = lucy_Doc_IVARS(self);
     char   *key      = (char*)CFISH_CB_Get_Ptr8(field);
     size_t  key_size = CFISH_CB_Get_Size(field);
@@ -89,26 +89,26 @@ S_nfreeze_fields(lucy_Doc *self) {
 }
 
 void
-Lucy_Doc_Serialize_IMP(lucy_Doc *self, lucy_OutStream *outstream) {
+LUCY_Doc_Serialize_IMP(lucy_Doc *self, lucy_OutStream *outstream) {
     lucy_DocIVARS *const ivars = lucy_Doc_IVARS(self);
-    Lucy_OutStream_Write_C32(outstream, ivars->doc_id);
+    LUCY_OutStream_Write_C32(outstream, ivars->doc_id);
     SV *frozen = S_nfreeze_fields(self);
     STRLEN len;
     char *buf = SvPV(frozen, len);
-    Lucy_OutStream_Write_C64(outstream, len);
-    Lucy_OutStream_Write_Bytes(outstream, buf, len);
+    LUCY_OutStream_Write_C64(outstream, len);
+    LUCY_OutStream_Write_Bytes(outstream, buf, len);
     SvREFCNT_dec(frozen);
 }
 
 static HV*
 S_thaw_fields(lucy_InStream *instream) {
     // Read frozen data into an SV buffer.
-    size_t len = (size_t)Lucy_InStream_Read_C64(instream);
+    size_t len = (size_t)LUCY_InStream_Read_C64(instream);
     SV *buf_sv = newSV(len + 1);
     SvPOK_on(buf_sv);
     SvCUR_set(buf_sv, len);
     char *buf = SvPVX(buf_sv);
-    Lucy_InStream_Read_Bytes(instream, buf, len);
+    LUCY_InStream_Read_Bytes(instream, buf, len);
 
     // Call back to Storable to thaw the frozen hash.
     dSP;
@@ -134,8 +134,8 @@ S_thaw_fields(lucy_InStream *instream) {
 }
 
 lucy_Doc*
-Lucy_Doc_Deserialize_IMP(lucy_Doc *self, lucy_InStream *instream) {
-    int32_t doc_id = (int32_t)Lucy_InStream_Read_C32(instream);
+LUCY_Doc_Deserialize_IMP(lucy_Doc *self, lucy_InStream *instream) {
+    int32_t doc_id = (int32_t)LUCY_InStream_Read_C32(instream);
     HV *fields = S_thaw_fields(instream);
     lucy_Doc_init(self, fields, doc_id);
     SvREFCNT_dec(fields);
@@ -143,7 +143,7 @@ Lucy_Doc_Deserialize_IMP(lucy_Doc *self, lucy_InStream *instream) {
 }
 
 cfish_Obj*
-Lucy_Doc_Extract_IMP(lucy_Doc *self, cfish_CharBuf *field,
+LUCY_Doc_Extract_IMP(lucy_Doc *self, cfish_CharBuf *field,
                      cfish_ViewCharBuf *target) {
     lucy_DocIVARS *const ivars = lucy_Doc_IVARS(self);
     cfish_Obj *retval = NULL;
@@ -168,20 +168,20 @@ Lucy_Doc_Extract_IMP(lucy_Doc *self, cfish_CharBuf *field,
 }
 
 void*
-Lucy_Doc_To_Host_IMP(lucy_Doc *self) {
-    Lucy_Doc_To_Host_t super_to_host
-        = CFISH_SUPER_METHOD_PTR(LUCY_DOC, Lucy_Doc_To_Host);
+LUCY_Doc_To_Host_IMP(lucy_Doc *self) {
+    LUCY_Doc_To_Host_t super_to_host
+        = CFISH_SUPER_METHOD_PTR(LUCY_DOC, LUCY_Doc_To_Host);
     SV *perl_obj = (SV*)super_to_host(self);
     XSBind_enable_overload(perl_obj);
     return perl_obj;
 }
 
 cfish_Hash*
-Lucy_Doc_Dump_IMP(lucy_Doc *self) {
+LUCY_Doc_Dump_IMP(lucy_Doc *self) {
     lucy_DocIVARS *const ivars = lucy_Doc_IVARS(self);
     cfish_Hash *dump = cfish_Hash_new(0);
     CFISH_Hash_Store_Str(dump, "_class", 6,
-                        (cfish_Obj*)CFISH_CB_Clone(Lucy_Doc_Get_Class_Name(self)));
+                        (cfish_Obj*)CFISH_CB_Clone(LUCY_Doc_Get_Class_Name(self)));
     CFISH_Hash_Store_Str(dump, "doc_id", 7,
                         (cfish_Obj*)cfish_CB_newf("%i32", ivars->doc_id));
     CFISH_Hash_Store_Str(dump, "fields", 6,
@@ -190,7 +190,7 @@ Lucy_Doc_Dump_IMP(lucy_Doc *self) {
 }
 
 lucy_Doc*
-Lucy_Doc_Load_IMP(lucy_Doc *self, cfish_Obj *dump) {
+LUCY_Doc_Load_IMP(lucy_Doc *self, cfish_Obj *dump) {
     cfish_Hash *source = (cfish_Hash*)CFISH_CERTIFY(dump, CFISH_HASH);
     cfish_CharBuf *class_name = (cfish_CharBuf*)CFISH_CERTIFY(
                                    CFISH_Hash_Fetch_Str(source, "_class", 6),
@@ -215,7 +215,7 @@ Lucy_Doc_Load_IMP(lucy_Doc *self, cfish_Obj *dump) {
 }
 
 bool
-Lucy_Doc_Equals_IMP(lucy_Doc *self, cfish_Obj *other) {
+LUCY_Doc_Equals_IMP(lucy_Doc *self, cfish_Obj *other) {
     if ((lucy_Doc*)other  == self)        { return true;  }
     if (!CFISH_Obj_Is_A(other, LUCY_DOC)) { return false; }
     lucy_DocIVARS *const ivars = lucy_Doc_IVARS(self);
@@ -243,7 +243,7 @@ Lucy_Doc_Equals_IMP(lucy_Doc *self, cfish_Obj *other) {
 }
 
 void
-Lucy_Doc_Destroy_IMP(lucy_Doc *self) {
+LUCY_Doc_Destroy_IMP(lucy_Doc *self) {
     lucy_DocIVARS *const ivars = lucy_Doc_IVARS(self);
     if (ivars->fields) { SvREFCNT_dec((SV*)ivars->fields); }
     CFISH_SUPER_DESTROY(self, LUCY_DOC);

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/perl/xs/Lucy/Index/DocReader.c
----------------------------------------------------------------------
diff --git a/perl/xs/Lucy/Index/DocReader.c b/perl/xs/Lucy/Index/DocReader.c
index 55104b2..d2b8e3d 100644
--- a/perl/xs/Lucy/Index/DocReader.c
+++ b/perl/xs/Lucy/Index/DocReader.c
@@ -28,7 +28,7 @@
 #include "Lucy/Store/InStream.h"
 
 lucy_HitDoc*
-Lucy_DefDocReader_Fetch_Doc_IMP(lucy_DefaultDocReader *self, int32_t doc_id) {
+LUCY_DefDocReader_Fetch_Doc_IMP(lucy_DefaultDocReader *self, int32_t doc_id) {
     lucy_DefaultDocReaderIVARS *const ivars = lucy_DefDocReader_IVARS(self);
     lucy_Schema   *const schema = ivars->schema;
     lucy_InStream *const dat_in = ivars->dat_in;
@@ -39,10 +39,10 @@ Lucy_DefDocReader_Fetch_Doc_IMP(lucy_DefaultDocReader *self, int32_t doc_id) {
     SV *field_name_sv = newSV(1);
 
     // Get data file pointer from index, read number of fields.
-    Lucy_InStream_Seek(ix_in, (int64_t)doc_id * 8);
-    start = Lucy_InStream_Read_U64(ix_in);
-    Lucy_InStream_Seek(dat_in, start);
-    num_fields = Lucy_InStream_Read_C32(dat_in);
+    LUCY_InStream_Seek(ix_in, (int64_t)doc_id * 8);
+    start = LUCY_InStream_Read_U64(ix_in);
+    LUCY_InStream_Seek(dat_in, start);
+    num_fields = LUCY_InStream_Read_C32(dat_in);
 
     // Decode stored data and build up the doc field by field.
     while (num_fields--) {
@@ -52,9 +52,9 @@ Lucy_DefDocReader_Fetch_Doc_IMP(lucy_DefaultDocReader *self, int32_t doc_id) {
         lucy_FieldType *type;
 
         // Read field name.
-        field_name_len = Lucy_InStream_Read_C32(dat_in);
+        field_name_len = LUCY_InStream_Read_C32(dat_in);
         field_name_ptr = SvGROW(field_name_sv, field_name_len + 1);
-        Lucy_InStream_Read_Bytes(dat_in, field_name_ptr, field_name_len);
+        LUCY_InStream_Read_Bytes(dat_in, field_name_ptr, field_name_len);
         SvPOK_on(field_name_sv);
         SvCUR_set(field_name_sv, field_name_len);
         SvUTF8_on(field_name_sv);
@@ -64,14 +64,14 @@ Lucy_DefDocReader_Fetch_Doc_IMP(lucy_DefaultDocReader *self, int32_t doc_id) {
         cfish_ZombieCharBuf *field_name_zcb
             = CFISH_ZCB_WRAP_STR(field_name_ptr, field_name_len);
         CFISH_ZCB_Assign_Str(field_name_zcb, field_name_ptr, field_name_len);
-        type = Lucy_Schema_Fetch_Type(schema, (cfish_CharBuf*)field_name_zcb);
+        type = LUCY_Schema_Fetch_Type(schema, (cfish_CharBuf*)field_name_zcb);
 
         // Read the field value.
-        switch (Lucy_FType_Primitive_ID(type) & lucy_FType_PRIMITIVE_ID_MASK) {
+        switch (LUCY_FType_Primitive_ID(type) & lucy_FType_PRIMITIVE_ID_MASK) {
             case lucy_FType_TEXT: {
-                    STRLEN value_len = Lucy_InStream_Read_C32(dat_in);
+                    STRLEN value_len = LUCY_InStream_Read_C32(dat_in);
                     value_sv = newSV((value_len ? value_len : 1));
-                    Lucy_InStream_Read_Bytes(dat_in, SvPVX(value_sv), value_len);
+                    LUCY_InStream_Read_Bytes(dat_in, SvPVX(value_sv), value_len);
                     SvCUR_set(value_sv, value_len);
                     *SvEND(value_sv) = '\0';
                     SvPOK_on(value_sv);
@@ -79,30 +79,30 @@ Lucy_DefDocReader_Fetch_Doc_IMP(lucy_DefaultDocReader *self, int32_t doc_id) {
                     break;
                 }
             case lucy_FType_BLOB: {
-                    STRLEN value_len = Lucy_InStream_Read_C32(dat_in);
+                    STRLEN value_len = LUCY_InStream_Read_C32(dat_in);
                     value_sv = newSV((value_len ? value_len : 1));
-                    Lucy_InStream_Read_Bytes(dat_in, SvPVX(value_sv), value_len);
+                    LUCY_InStream_Read_Bytes(dat_in, SvPVX(value_sv), value_len);
                     SvCUR_set(value_sv, value_len);
                     *SvEND(value_sv) = '\0';
                     SvPOK_on(value_sv);
                     break;
                 }
             case lucy_FType_FLOAT32:
-                value_sv = newSVnv(Lucy_InStream_Read_F32(dat_in));
+                value_sv = newSVnv(LUCY_InStream_Read_F32(dat_in));
                 break;
             case lucy_FType_FLOAT64:
-                value_sv = newSVnv(Lucy_InStream_Read_F64(dat_in));
+                value_sv = newSVnv(LUCY_InStream_Read_F64(dat_in));
                 break;
             case lucy_FType_INT32:
-                value_sv = newSViv((int32_t)Lucy_InStream_Read_C32(dat_in));
+                value_sv = newSViv((int32_t)LUCY_InStream_Read_C32(dat_in));
                 break;
             case lucy_FType_INT64:
                 if (sizeof(IV) == 8) {
-                    int64_t val = (int64_t)Lucy_InStream_Read_C64(dat_in);
+                    int64_t val = (int64_t)LUCY_InStream_Read_C64(dat_in);
                     value_sv = newSViv((IV)val);
                 }
                 else { // (lossy)
-                    int64_t val = (int64_t)Lucy_InStream_Read_C64(dat_in);
+                    int64_t val = (int64_t)LUCY_InStream_Read_C64(dat_in);
                     value_sv = newSVnv((double)val);
                 }
                 break;

http://git-wip-us.apache.org/repos/asf/lucy/blob/a0f24e5e/perl/xs/Lucy/Index/Inverter.c
----------------------------------------------------------------------
diff --git a/perl/xs/Lucy/Index/Inverter.c b/perl/xs/Lucy/Index/Inverter.c
index 8eeb3d4..3fcb14f 100644
--- a/perl/xs/Lucy/Index/Inverter.c
+++ b/perl/xs/Lucy/Index/Inverter.c
@@ -52,13 +52,13 @@ S_fetch_entry(lucy_Inverter *self, HE *hash_entry) {
 
     cfish_ZombieCharBuf *field = CFISH_ZCB_WRAP_STR(key, key_len);
     int32_t field_num
-        = Lucy_Seg_Field_Num(ivars->segment, (cfish_CharBuf*)field);
+        = LUCY_Seg_Field_Num(ivars->segment, (cfish_CharBuf*)field);
     if (!field_num) {
         // This field seems not to be in the segment yet.  Try to find it in
         // the Schema.
-        if (Lucy_Schema_Fetch_Type(schema, (cfish_CharBuf*)field)) {
+        if (LUCY_Schema_Fetch_Type(schema, (cfish_CharBuf*)field)) {
             // The field is in the Schema.  Get a field num from the Segment.
-            field_num = Lucy_Seg_Add_Field(ivars->segment,
+            field_num = LUCY_Seg_Add_Field(ivars->segment,
                                            (cfish_CharBuf*)field);
         }
         else {
@@ -78,12 +78,12 @@ S_fetch_entry(lucy_Inverter *self, HE *hash_entry) {
 }
 
 void
-Lucy_Inverter_Invert_Doc_IMP(lucy_Inverter *self, lucy_Doc *doc) {
-    HV  *const fields = (HV*)Lucy_Doc_Get_Fields(doc);
+LUCY_Inverter_Invert_Doc_IMP(lucy_Inverter *self, lucy_Doc *doc) {
+    HV  *const fields = (HV*)LUCY_Doc_Get_Fields(doc);
     I32  num_keys     = hv_iterinit(fields);
 
     // Prepare for the new doc.
-    Lucy_Inverter_Set_Doc(self, doc);
+    LUCY_Inverter_Set_Doc(self, doc);
 
     // Extract and invert the doc's fields.
     while (num_keys--) {
@@ -95,7 +95,7 @@ Lucy_Inverter_Invert_Doc_IMP(lucy_Inverter *self, lucy_Doc *doc) {
         lucy_FieldType *type = entry_ivars->type;
 
         // Get the field value, forcing text fields to UTF-8.
-        switch (Lucy_FType_Primitive_ID(type) & lucy_FType_PRIMITIVE_ID_MASK) {
+        switch (LUCY_FType_Primitive_ID(type) & lucy_FType_PRIMITIVE_ID_MASK) {
             case lucy_FType_TEXT: {
                     STRLEN val_len;
                     char *val_ptr = SvPVutf8(value_sv, val_len);
@@ -139,7 +139,7 @@ Lucy_Inverter_Invert_Doc_IMP(lucy_Inverter *self, lucy_Doc *doc) {
                 THROW(CFISH_ERR, "Unrecognized type: %o", type);
         }
 
-        Lucy_Inverter_Add_Field(self, inv_entry);
+        LUCY_Inverter_Add_Field(self, inv_entry);
     }
 }
 


Mime
View raw message