lucy-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mar...@apache.org
Subject [lucy-commits] [7/16] git commit: refs/heads/master - Namespace all static functions.
Date Sat, 03 Nov 2012 18:21:54 GMT
Namespace all static functions.


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

Branch: refs/heads/master
Commit: f64f0e81048a62531b0081a5715f16f8932df2a8
Parents: 8b60c97
Author: Marvin Humphrey <marvin@rectangular.com>
Authored: Sat Nov 3 11:19:46 2012 -0700
Committer: Marvin Humphrey <marvin@rectangular.com>
Committed: Sat Nov 3 11:19:46 2012 -0700

----------------------------------------------------------------------
 charmonizer/src/Charmonizer/Core/Compiler.c       |   20 ++--
 charmonizer/src/Charmonizer/Core/ConfWriterC.c    |  105 ++++++++--------
 charmonizer/src/Charmonizer/Core/ConfWriterPerl.c |   60 +++++-----
 charmonizer/src/Charmonizer/Core/ConfWriterRuby.c |   60 +++++-----
 charmonizer/src/Charmonizer/Core/HeaderChecker.c  |   32 +++---
 charmonizer/src/Charmonizer/Probe.c               |   12 +-
 charmonizer/src/Charmonizer/Probe/DirManip.c      |   26 ++--
 charmonizer/src/Charmonizer/Probe/FuncMacro.c     |    4 +-
 charmonizer/src/Charmonizer/Probe/Headers.c       |   25 ++--
 charmonizer/src/Charmonizer/Probe/Integers.c      |    6 +-
 charmonizer/src/Charmonizer/Probe/LargeFiles.c    |   24 ++--
 11 files changed, 191 insertions(+), 183 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucy/blob/f64f0e81/charmonizer/src/Charmonizer/Core/Compiler.c
----------------------------------------------------------------------
diff --git a/charmonizer/src/Charmonizer/Core/Compiler.c b/charmonizer/src/Charmonizer/Core/Compiler.c
index 062c42f..9fc9790 100644
--- a/charmonizer/src/Charmonizer/Core/Compiler.c
+++ b/charmonizer/src/Charmonizer/Core/Compiler.c
@@ -24,7 +24,7 @@
 /* Detect macros which may help to identify some compilers.
  */
 static void
-S_detect_known_compilers(void);
+chaz_CC_detect_known_compilers(void);
 
 /* Temporary files. */
 #define CHAZ_CC_TRY_SOURCE_PATH  "_charmonizer_try.c"
@@ -119,7 +119,7 @@ chaz_CC_init(const char *compiler_command, const char *compiler_flags)
{
         chaz_Util_die("Failed to compile a small test file");
     }
 
-    S_detect_known_compilers();
+    chaz_CC_detect_known_compilers();
 }
 
 static const char detect_macro_code[] =
@@ -131,7 +131,7 @@ static const char detect_macro_code[] =
     CHAZ_QUOTE(  }                              );
 
 static int
-S_detect_macro(const char *macro) {
+chaz_CC_detect_macro(const char *macro) {
     size_t size = sizeof(detect_macro_code) + strlen(macro) + 20;
     char *code = (char*)malloc(size);
     int retval;
@@ -142,10 +142,10 @@ S_detect_macro(const char *macro) {
 }
 
 static void
-S_detect_known_compilers(void) {
-    chaz_CC.defines___GNUC__  = S_detect_macro("__GNUC__");
-    chaz_CC.defines__MSC_VER  = S_detect_macro("_MSC_VER");
-    chaz_CC.defines___clang__ = S_detect_macro("__clang__");
+chaz_CC_detect_known_compilers(void) {
+    chaz_CC.defines___GNUC__  = chaz_CC_detect_macro("__GNUC__");
+    chaz_CC.defines__MSC_VER  = chaz_CC_detect_macro("_MSC_VER");
+    chaz_CC.defines___clang__ = chaz_CC_detect_macro("__clang__");
 }
 
 void
@@ -165,7 +165,7 @@ chaz_CC_clean_up(void) {
 }
 
 static char*
-S_inc_dir_string(void) {
+chaz_CC_inc_dir_string(void) {
     size_t needed = 0;
     char  *inc_dir_string;
     char **dirs;
@@ -192,7 +192,7 @@ chaz_CC_compile_exe(const char *source_path, const char *exe_name,
     size_t   junk_buf_size     = exe_file_buf_size + 3;
     char    *junk              = (char*)malloc(junk_buf_size);
     size_t   exe_file_buf_len  = sprintf(exe_file, "%s%s", exe_name, exe_ext);
-    char    *inc_dir_string    = S_inc_dir_string();
+    char    *inc_dir_string    = chaz_CC_inc_dir_string();
     size_t   command_max_size  = strlen(chaz_CC.cc_command)
                                  + strlen(chaz_CC.error_flag)
                                  + strlen(source_path)
@@ -250,7 +250,7 @@ chaz_CC_compile_obj(const char *source_path, const char *obj_name,
     size_t   obj_file_buf_size = strlen(obj_name) + strlen(obj_ext) + 1;
     char    *obj_file          = (char*)malloc(obj_file_buf_size);
     size_t   obj_file_buf_len  = sprintf(obj_file, "%s%s", obj_name, obj_ext);
-    char    *inc_dir_string    = S_inc_dir_string();
+    char    *inc_dir_string    = chaz_CC_inc_dir_string();
     size_t   command_max_size  = strlen(chaz_CC.cc_command)
                                  + strlen(chaz_CC.no_link_flag)
                                  + strlen(chaz_CC.error_flag)

http://git-wip-us.apache.org/repos/asf/lucy/blob/f64f0e81/charmonizer/src/Charmonizer/Core/ConfWriterC.c
----------------------------------------------------------------------
diff --git a/charmonizer/src/Charmonizer/Core/ConfWriterC.c b/charmonizer/src/Charmonizer/Core/ConfWriterC.c
index c098b9a..2f1971d 100644
--- a/charmonizer/src/Charmonizer/Core/ConfWriterC.c
+++ b/charmonizer/src/Charmonizer/Core/ConfWriterC.c
@@ -52,51 +52,51 @@ static chaz_ConfWriter CWC_conf_writer;
  * Print an explanatory comment and open the include guard.
  */
 static void
-S_open_charmony_h(const char *charmony_start);
+chaz_ConfWriterC_open_charmony_h(const char *charmony_start);
 
 /* Push a new elem onto the def list. */
 static void
-S_push_def_list_item(const char *str1, const char *str2,
+chaz_ConfWriterC_push_def_list_item(const char *str1, const char *str2,
                      chaz_ConfElemType type);
 
 /* Free the def list. */
 static void
-S_clear_def_list(void);
+chaz_ConfWriterC_clear_def_list(void);
 
 static void
-S_ConfWriterC_clean_up(void);
+chaz_ConfWriterC_clean_up(void);
 static void
-S_ConfWriterC_vappend_conf(const char *fmt, va_list args);
+chaz_ConfWriterC_vappend_conf(const char *fmt, va_list args);
 static void
-S_ConfWriterC_add_def(const char *sym, const char *value);
+chaz_ConfWriterC_add_def(const char *sym, const char *value);
 static void
-S_ConfWriterC_add_typedef(const char *type, const char *alias);
+chaz_ConfWriterC_add_typedef(const char *type, const char *alias);
 static void
-S_ConfWriterC_add_sys_include(const char *header);
+chaz_ConfWriterC_add_sys_include(const char *header);
 static void
-S_ConfWriterC_add_local_include(const char *header);
+chaz_ConfWriterC_add_local_include(const char *header);
 static void
-S_ConfWriterC_start_module(const char *module_name);
+chaz_ConfWriterC_start_module(const char *module_name);
 static void
-S_ConfWriterC_end_module(void);
+chaz_ConfWriterC_end_module(void);
 
 void
 chaz_ConfWriterC_enable(void) {
-    CWC_conf_writer.clean_up          = S_ConfWriterC_clean_up;
-    CWC_conf_writer.vappend_conf      = S_ConfWriterC_vappend_conf;
-    CWC_conf_writer.add_def           = S_ConfWriterC_add_def;
-    CWC_conf_writer.add_typedef       = S_ConfWriterC_add_typedef;
-    CWC_conf_writer.add_sys_include   = S_ConfWriterC_add_sys_include;
-    CWC_conf_writer.add_local_include = S_ConfWriterC_add_local_include;
-    CWC_conf_writer.start_module      = S_ConfWriterC_start_module;
-    CWC_conf_writer.end_module        = S_ConfWriterC_end_module;
-    S_open_charmony_h(NULL);
+    CWC_conf_writer.clean_up          = chaz_ConfWriterC_clean_up;
+    CWC_conf_writer.vappend_conf      = chaz_ConfWriterC_vappend_conf;
+    CWC_conf_writer.add_def           = chaz_ConfWriterC_add_def;
+    CWC_conf_writer.add_typedef       = chaz_ConfWriterC_add_typedef;
+    CWC_conf_writer.add_sys_include   = chaz_ConfWriterC_add_sys_include;
+    CWC_conf_writer.add_local_include = chaz_ConfWriterC_add_local_include;
+    CWC_conf_writer.start_module      = chaz_ConfWriterC_start_module;
+    CWC_conf_writer.end_module        = chaz_ConfWriterC_end_module;
+    chaz_ConfWriterC_open_charmony_h(NULL);
     chaz_ConfWriter_add_writer(&CWC_conf_writer);
     return;
 }
 
 static void
-S_open_charmony_h(const char *charmony_start) {
+chaz_ConfWriterC_open_charmony_h(const char *charmony_start) {
     /* Open the filehandle. */
     chaz_ConfWriterC.fh = fopen("charmony.h", "w+");
     if (chaz_ConfWriterC.fh == NULL) {
@@ -118,7 +118,7 @@ S_open_charmony_h(const char *charmony_start) {
 }
 
 static void
-S_ConfWriterC_clean_up(void) {
+chaz_ConfWriterC_clean_up(void) {
     /* Write the last bit of charmony.h and close. */
     fprintf(chaz_ConfWriterC.fh, "#endif /* H_CHARMONY */\n\n");
     if (fclose(chaz_ConfWriterC.fh)) {
@@ -127,12 +127,12 @@ S_ConfWriterC_clean_up(void) {
 }
 
 static void
-S_ConfWriterC_vappend_conf(const char *fmt, va_list args) {
+chaz_ConfWriterC_vappend_conf(const char *fmt, va_list args) {
     vfprintf(chaz_ConfWriterC.fh, fmt, args);
 }
 
 static int
-S_sym_is_uppercase(const char *sym) {
+chaz_ConfWriterC_sym_is_uppercase(const char *sym) {
     unsigned i;
     for (i = 0; sym[i] != 0; i++) {
         if (!isupper(sym[i])) {
@@ -148,14 +148,14 @@ S_sym_is_uppercase(const char *sym) {
 }
 
 static void
-S_ConfWriterC_add_def(const char *sym, const char *value) {
-    S_push_def_list_item(sym, value, CHAZ_CONFELEM_DEF);
+chaz_ConfWriterC_add_def(const char *sym, const char *value) {
+    chaz_ConfWriterC_push_def_list_item(sym, value, CHAZ_CONFELEM_DEF);
 }
 
 static void
-S_append_def_to_conf(const char *sym, const char *value) {
+chaz_ConfWriterC_append_def_to_conf(const char *sym, const char *value) {
     if (value) {
-        if (S_sym_is_uppercase(sym)) {
+        if (chaz_ConfWriterC_sym_is_uppercase(sym)) {
             fprintf(chaz_ConfWriterC.fh, "#define CHY_%s %s\n", sym, value);
         }
         else {
@@ -163,7 +163,7 @@ S_append_def_to_conf(const char *sym, const char *value) {
         }
     }
     else {
-        if (S_sym_is_uppercase(sym)) {
+        if (chaz_ConfWriterC_sym_is_uppercase(sym)) {
             fprintf(chaz_ConfWriterC.fh, "#define CHY_%s\n", sym);
         }
         else {
@@ -173,13 +173,13 @@ S_append_def_to_conf(const char *sym, const char *value) {
 }
 
 static void
-S_ConfWriterC_add_typedef(const char *type, const char *alias) {
-    S_push_def_list_item(alias, type, CHAZ_CONFELEM_TYPEDEF);
+chaz_ConfWriterC_add_typedef(const char *type, const char *alias) {
+    chaz_ConfWriterC_push_def_list_item(alias, type, CHAZ_CONFELEM_TYPEDEF);
 }
 
 static void
-S_append_typedef_to_conf(const char *type, const char *alias) {
-    if (S_sym_is_uppercase(alias)) {
+chaz_ConfWriterC_append_typedef_to_conf(const char *type, const char *alias) {
+    if (chaz_ConfWriterC_sym_is_uppercase(alias)) {
         fprintf(chaz_ConfWriterC.fh, "typedef %s CHY_%s;\n", type, alias);
     }
     else {
@@ -188,47 +188,51 @@ S_append_typedef_to_conf(const char *type, const char *alias) {
 }
 
 static void
-S_ConfWriterC_add_sys_include(const char *header) {
-    S_push_def_list_item(header, NULL, CHAZ_CONFELEM_SYS_INCLUDE);
+chaz_ConfWriterC_add_sys_include(const char *header) {
+    chaz_ConfWriterC_push_def_list_item(header, NULL,
+                                        CHAZ_CONFELEM_SYS_INCLUDE);
 }
 
 static void
-S_append_sys_include_to_conf(const char *header) {
+chaz_ConfWriterC_append_sys_include_to_conf(const char *header) {
     fprintf(chaz_ConfWriterC.fh, "#include <%s>\n", header);
 }
 
 static void
-S_ConfWriterC_add_local_include(const char *header) {
-    S_push_def_list_item(header, NULL, CHAZ_CONFELEM_LOCAL_INCLUDE);
+chaz_ConfWriterC_add_local_include(const char *header) {
+    chaz_ConfWriterC_push_def_list_item(header, NULL,
+                                        CHAZ_CONFELEM_LOCAL_INCLUDE);
 }
 
 static void
-S_append_local_include_to_conf(const char *header) {
+chaz_ConfWriterC_append_local_include_to_conf(const char *header) {
     fprintf(chaz_ConfWriterC.fh, "#include \"%s\"\n", header);
 }
 
 static void
-S_ConfWriterC_start_module(const char *module_name) {
+chaz_ConfWriterC_start_module(const char *module_name) {
     fprintf(chaz_ConfWriterC.fh, "\n/* %s */\n", module_name);
 }
 
 static void
-S_ConfWriterC_end_module(void) {
+chaz_ConfWriterC_end_module(void) {
     size_t i;
     chaz_ConfElem *defs = chaz_ConfWriterC.defs;
     for (i = 0; i < chaz_ConfWriterC.def_count; i++) {
         switch (defs[i].type) {
             case CHAZ_CONFELEM_DEF:
-                S_append_def_to_conf(defs[i].str1, defs[i].str2);
+                chaz_ConfWriterC_append_def_to_conf(defs[i].str1,
+                                                    defs[i].str2);
                 break;
             case CHAZ_CONFELEM_TYPEDEF:
-                S_append_typedef_to_conf(defs[i].str2, defs[i].str1);
+                chaz_ConfWriterC_append_typedef_to_conf(defs[i].str2,
+                                                        defs[i].str1);
                 break;
             case CHAZ_CONFELEM_SYS_INCLUDE:
-                S_append_sys_include_to_conf(defs[i].str1);
+                chaz_ConfWriterC_append_sys_include_to_conf(defs[i].str1);
                 break;
             case CHAZ_CONFELEM_LOCAL_INCLUDE:
-                S_append_local_include_to_conf(defs[i].str1);
+                chaz_ConfWriterC_append_local_include_to_conf(defs[i].str1);
                 break;
             default:
                 chaz_Util_die("Internal error: bad element type %d",
@@ -249,8 +253,9 @@ S_ConfWriterC_end_module(void) {
                     const char *sym = defs[i].str1;
                     const char *value = defs[i].str2;
                     if (!value || strcmp(sym, value) != 0) {
-                        const char *prefix = S_sym_is_uppercase(sym)
-                                             ? "CHY_" : "chy_";
+                        const char *prefix
+                            = chaz_ConfWriterC_sym_is_uppercase(sym)
+                              ? "CHY_" : "chy_";
                         fprintf(chaz_ConfWriterC.fh, "  #define %s %s%s\n",
                                 sym, prefix, sym);
                     }
@@ -269,11 +274,11 @@ S_ConfWriterC_end_module(void) {
     fprintf(chaz_ConfWriterC.fh, "#endif /* USE_SHORT_NAMES */\n");
     fprintf(chaz_ConfWriterC.fh, "\n");
 
-    S_clear_def_list();
+    chaz_ConfWriterC_clear_def_list();
 }
 
 static void
-S_push_def_list_item(const char *str1, const char *str2,
+chaz_ConfWriterC_push_def_list_item(const char *str1, const char *str2,
                      chaz_ConfElemType type) {
     if (chaz_ConfWriterC.def_count >= chaz_ConfWriterC.def_cap) { 
         size_t amount;
@@ -291,7 +296,7 @@ S_push_def_list_item(const char *str1, const char *str2,
 }
 
 static void
-S_clear_def_list(void) {
+chaz_ConfWriterC_clear_def_list(void) {
     size_t i;
     for (i = 0; i < chaz_ConfWriterC.def_count; i++) {
         free(chaz_ConfWriterC.defs[i].str1);

http://git-wip-us.apache.org/repos/asf/lucy/blob/f64f0e81/charmonizer/src/Charmonizer/Core/ConfWriterPerl.c
----------------------------------------------------------------------
diff --git a/charmonizer/src/Charmonizer/Core/ConfWriterPerl.c b/charmonizer/src/Charmonizer/Core/ConfWriterPerl.c
index 0e5914c..550b409 100644
--- a/charmonizer/src/Charmonizer/Core/ConfWriterPerl.c
+++ b/charmonizer/src/Charmonizer/Core/ConfWriterPerl.c
@@ -32,42 +32,42 @@ static chaz_ConfWriter CWPerl_conf_writer;
 /* Open the Charmony.pm file handle.
  */
 static void
-S_open_config_pm(void);
+chaz_ConfWriterPerl_open_config_pm(void);
 
 static void
-S_ConfWriterPerl_clean_up(void);
+chaz_ConfWriterPerl_clean_up(void);
 static void
-S_ConfWriterPerl_vappend_conf(const char *fmt, va_list args);
+chaz_ConfWriterPerl_vappend_conf(const char *fmt, va_list args);
 static void
-S_ConfWriterPerl_add_def(const char *sym, const char *value);
+chaz_ConfWriterPerl_add_def(const char *sym, const char *value);
 static void
-S_ConfWriterPerl_add_typedef(const char *type, const char *alias);
+chaz_ConfWriterPerl_add_typedef(const char *type, const char *alias);
 static void
-S_ConfWriterPerl_add_sys_include(const char *header);
+chaz_ConfWriterPerl_add_sys_include(const char *header);
 static void
-S_ConfWriterPerl_add_local_include(const char *header);
+chaz_ConfWriterPerl_add_local_include(const char *header);
 static void
-S_ConfWriterPerl_start_module(const char *module_name);
+chaz_ConfWriterPerl_start_module(const char *module_name);
 static void
-S_ConfWriterPerl_end_module(void);
+chaz_ConfWriterPerl_end_module(void);
 
 void
 chaz_ConfWriterPerl_enable(void) {
-    CWPerl_conf_writer.clean_up          = S_ConfWriterPerl_clean_up;
-    CWPerl_conf_writer.vappend_conf      = S_ConfWriterPerl_vappend_conf;
-    CWPerl_conf_writer.add_def           = S_ConfWriterPerl_add_def;
-    CWPerl_conf_writer.add_typedef       = S_ConfWriterPerl_add_typedef;
-    CWPerl_conf_writer.add_sys_include   = S_ConfWriterPerl_add_sys_include;
-    CWPerl_conf_writer.add_local_include = S_ConfWriterPerl_add_local_include;
-    CWPerl_conf_writer.start_module      = S_ConfWriterPerl_start_module;
-    CWPerl_conf_writer.end_module        = S_ConfWriterPerl_end_module;
-    S_open_config_pm();
+    CWPerl_conf_writer.clean_up          = chaz_ConfWriterPerl_clean_up;
+    CWPerl_conf_writer.vappend_conf      = chaz_ConfWriterPerl_vappend_conf;
+    CWPerl_conf_writer.add_def           = chaz_ConfWriterPerl_add_def;
+    CWPerl_conf_writer.add_typedef       = chaz_ConfWriterPerl_add_typedef;
+    CWPerl_conf_writer.add_sys_include   = chaz_ConfWriterPerl_add_sys_include;
+    CWPerl_conf_writer.add_local_include = chaz_ConfWriterPerl_add_local_include;
+    CWPerl_conf_writer.start_module      = chaz_ConfWriterPerl_start_module;
+    CWPerl_conf_writer.end_module        = chaz_ConfWriterPerl_end_module;
+    chaz_ConfWriterPerl_open_config_pm();
     chaz_ConfWriter_add_writer(&CWPerl_conf_writer);
     return;
 }
 
 static void
-S_open_config_pm(void) {
+chaz_ConfWriterPerl_open_config_pm(void) {
     /* Open the filehandle. */
     chaz_CWPerl.fh = fopen("Charmony.pm", "w+");
     if (chaz_CWPerl.fh == NULL) {
@@ -91,7 +91,7 @@ S_open_config_pm(void) {
 }
 
 static void
-S_ConfWriterPerl_clean_up(void) {
+chaz_ConfWriterPerl_clean_up(void) {
     /* Write the last bit of Charmony.pm and close. */
     fprintf(chaz_CWPerl.fh, "\n1;\n\n");
     if (fclose(chaz_CWPerl.fh)) {
@@ -100,13 +100,13 @@ S_ConfWriterPerl_clean_up(void) {
 }
 
 static void
-S_ConfWriterPerl_vappend_conf(const char *fmt, va_list args) {
+chaz_ConfWriterPerl_vappend_conf(const char *fmt, va_list args) {
     (void)fmt;
     (void)args;
 }
 
 static char*
-S_ConfWriterPerl_quotify(const char *string, char *buf, size_t buf_size) {
+chaz_ConfWriterPerl_quotify(const char *string, char *buf, size_t buf_size) {
     char *quoted = buf;
 
     /* Don't bother with undef values here. */
@@ -151,7 +151,7 @@ S_ConfWriterPerl_quotify(const char *string, char *buf, size_t buf_size)
{
 
 #define CFPERL_MAX_BUF 100
 static void
-S_ConfWriterPerl_add_def(const char *sym, const char *value) {
+chaz_ConfWriterPerl_add_def(const char *sym, const char *value) {
     char sym_buf[CFPERL_MAX_BUF + 1];
     char value_buf[CFPERL_MAX_BUF + 1];
     char *quoted_sym;
@@ -161,7 +161,7 @@ S_ConfWriterPerl_add_def(const char *sym, const char *value) {
     if (!sym) {
         chaz_Util_die("Can't handle NULL key");
     }
-    quoted_sym = S_ConfWriterPerl_quotify(sym, sym_buf, CFPERL_MAX_BUF);
+    quoted_sym = chaz_ConfWriterPerl_quotify(sym, sym_buf, CFPERL_MAX_BUF);
 
     /* Quote value or use "undef". */
     if (!value) {
@@ -169,7 +169,7 @@ S_ConfWriterPerl_add_def(const char *sym, const char *value) {
         quoted_value = value_buf;
     }
     else {
-        quoted_value = S_ConfWriterPerl_quotify(value, value_buf,
+        quoted_value = chaz_ConfWriterPerl_quotify(value, value_buf,
                                                 CFPERL_MAX_BUF);
     }
 
@@ -180,28 +180,28 @@ S_ConfWriterPerl_add_def(const char *sym, const char *value) {
 }
 
 static void
-S_ConfWriterPerl_add_typedef(const char *type, const char *alias) {
+chaz_ConfWriterPerl_add_typedef(const char *type, const char *alias) {
     (void)type;
     (void)alias;
 }
 
 static void
-S_ConfWriterPerl_add_sys_include(const char *header) {
+chaz_ConfWriterPerl_add_sys_include(const char *header) {
     (void)header;
 }
 
 static void
-S_ConfWriterPerl_add_local_include(const char *header) {
+chaz_ConfWriterPerl_add_local_include(const char *header) {
     (void)header;
 }
 
 static void
-S_ConfWriterPerl_start_module(const char *module_name) {
+chaz_ConfWriterPerl_start_module(const char *module_name) {
     fprintf(chaz_CWPerl.fh, "# %s\n", module_name);
 }
 
 static void
-S_ConfWriterPerl_end_module(void) {
+chaz_ConfWriterPerl_end_module(void) {
     fprintf(chaz_CWPerl.fh, "\n");
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/f64f0e81/charmonizer/src/Charmonizer/Core/ConfWriterRuby.c
----------------------------------------------------------------------
diff --git a/charmonizer/src/Charmonizer/Core/ConfWriterRuby.c b/charmonizer/src/Charmonizer/Core/ConfWriterRuby.c
index 040b53a..86a37a3 100644
--- a/charmonizer/src/Charmonizer/Core/ConfWriterRuby.c
+++ b/charmonizer/src/Charmonizer/Core/ConfWriterRuby.c
@@ -32,42 +32,42 @@ static chaz_ConfWriter CWRuby_conf_writer;
 /* Open the Charmony.rb file handle.
  */
 static void
-S_open_config_rb(void);
+chaz_ConfWriterRuby_open_config_rb(void);
 
 static void
-S_ConfWriterRuby_clean_up(void);
+chaz_ConfWriterRuby_clean_up(void);
 static void
-S_ConfWriterRuby_vappend_conf(const char *fmt, va_list args);
+chaz_ConfWriterRuby_vappend_conf(const char *fmt, va_list args);
 static void
-S_ConfWriterRuby_add_def(const char *sym, const char *value);
+chaz_ConfWriterRuby_add_def(const char *sym, const char *value);
 static void
-S_ConfWriterRuby_add_typedef(const char *type, const char *alias);
+chaz_ConfWriterRuby_add_typedef(const char *type, const char *alias);
 static void
-S_ConfWriterRuby_add_sys_include(const char *header);
+chaz_ConfWriterRuby_add_sys_include(const char *header);
 static void
-S_ConfWriterRuby_add_local_include(const char *header);
+chaz_ConfWriterRuby_add_local_include(const char *header);
 static void
-S_ConfWriterRuby_start_module(const char *module_name);
+chaz_ConfWriterRuby_start_module(const char *module_name);
 static void
-S_ConfWriterRuby_end_module(void);
+chaz_ConfWriterRuby_end_module(void);
 
 void
 chaz_ConfWriterRuby_enable(void) {
-    CWRuby_conf_writer.clean_up          = S_ConfWriterRuby_clean_up;
-    CWRuby_conf_writer.vappend_conf      = S_ConfWriterRuby_vappend_conf;
-    CWRuby_conf_writer.add_def           = S_ConfWriterRuby_add_def;
-    CWRuby_conf_writer.add_typedef       = S_ConfWriterRuby_add_typedef;
-    CWRuby_conf_writer.add_sys_include   = S_ConfWriterRuby_add_sys_include;
-    CWRuby_conf_writer.add_local_include = S_ConfWriterRuby_add_local_include;
-    CWRuby_conf_writer.start_module      = S_ConfWriterRuby_start_module;
-    CWRuby_conf_writer.end_module        = S_ConfWriterRuby_end_module;
-    S_open_config_rb();
+    CWRuby_conf_writer.clean_up          = chaz_ConfWriterRuby_clean_up;
+    CWRuby_conf_writer.vappend_conf      = chaz_ConfWriterRuby_vappend_conf;
+    CWRuby_conf_writer.add_def           = chaz_ConfWriterRuby_add_def;
+    CWRuby_conf_writer.add_typedef       = chaz_ConfWriterRuby_add_typedef;
+    CWRuby_conf_writer.add_sys_include   = chaz_ConfWriterRuby_add_sys_include;
+    CWRuby_conf_writer.add_local_include = chaz_ConfWriterRuby_add_local_include;
+    CWRuby_conf_writer.start_module      = chaz_ConfWriterRuby_start_module;
+    CWRuby_conf_writer.end_module        = chaz_ConfWriterRuby_end_module;
+    chaz_ConfWriterRuby_open_config_rb();
     chaz_ConfWriter_add_writer(&CWRuby_conf_writer);
     return;
 }
 
 static void
-S_open_config_rb(void) {
+chaz_ConfWriterRuby_open_config_rb(void) {
     /* Open the filehandle. */
     chaz_CWRuby.fh = fopen("Charmony.rb", "w+");
     if (chaz_CWRuby.fh == NULL) {
@@ -89,7 +89,7 @@ S_open_config_rb(void) {
 }
 
 static void
-S_ConfWriterRuby_clean_up(void) {
+chaz_ConfWriterRuby_clean_up(void) {
     /* Write the last bit of Charmony.rb and close. */
     fprintf(chaz_CWRuby.fh, "\nend\n\n");
     if (fclose(chaz_CWRuby.fh)) {
@@ -98,13 +98,13 @@ S_ConfWriterRuby_clean_up(void) {
 }
 
 static void
-S_ConfWriterRuby_vappend_conf(const char *fmt, va_list args) {
+chaz_ConfWriterRuby_vappend_conf(const char *fmt, va_list args) {
     (void)fmt;
     (void)args;
 }
 
 static char*
-S_ConfWriterRuby_quotify(const char *string, char *buf, size_t buf_size) {
+chaz_ConfWriterRuby_quotify(const char *string, char *buf, size_t buf_size) {
     char *quoted = buf;
 
     /* Don't bother with undef values here. */
@@ -149,7 +149,7 @@ S_ConfWriterRuby_quotify(const char *string, char *buf, size_t buf_size)
{
 
 #define CFRUBY_MAX_BUF 100
 static void
-S_ConfWriterRuby_add_def(const char *sym, const char *value) {
+chaz_ConfWriterRuby_add_def(const char *sym, const char *value) {
     char sym_buf[CFRUBY_MAX_BUF + 1];
     char value_buf[CFRUBY_MAX_BUF + 1];
     char *quoted_sym;
@@ -159,7 +159,7 @@ S_ConfWriterRuby_add_def(const char *sym, const char *value) {
     if (!sym) {
         chaz_Util_die("Can't handle NULL key");
     }
-    quoted_sym = S_ConfWriterRuby_quotify(sym, sym_buf, CFRUBY_MAX_BUF);
+    quoted_sym = chaz_ConfWriterRuby_quotify(sym, sym_buf, CFRUBY_MAX_BUF);
 
     /* Quote value or use "nil". */
     if (!value) {
@@ -167,7 +167,7 @@ S_ConfWriterRuby_add_def(const char *sym, const char *value) {
         quoted_value = value_buf;
     }
     else {
-        quoted_value = S_ConfWriterRuby_quotify(value, value_buf,
+        quoted_value = chaz_ConfWriterRuby_quotify(value, value_buf,
                                                 CFRUBY_MAX_BUF);
     }
 
@@ -178,28 +178,28 @@ S_ConfWriterRuby_add_def(const char *sym, const char *value) {
 }
 
 static void
-S_ConfWriterRuby_add_typedef(const char *type, const char *alias) {
+chaz_ConfWriterRuby_add_typedef(const char *type, const char *alias) {
     (void)type;
     (void)alias;
 }
 
 static void
-S_ConfWriterRuby_add_sys_include(const char *header) {
+chaz_ConfWriterRuby_add_sys_include(const char *header) {
     (void)header;
 }
 
 static void
-S_ConfWriterRuby_add_local_include(const char *header) {
+chaz_ConfWriterRuby_add_local_include(const char *header) {
     (void)header;
 }
 
 static void
-S_ConfWriterRuby_start_module(const char *module_name) {
+chaz_ConfWriterRuby_start_module(const char *module_name) {
     fprintf(chaz_CWRuby.fh, "# %s\n", module_name);
 }
 
 static void
-S_ConfWriterRuby_end_module(void) {
+chaz_ConfWriterRuby_end_module(void) {
     fprintf(chaz_CWRuby.fh, "\n");
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/f64f0e81/charmonizer/src/Charmonizer/Core/HeaderChecker.c
----------------------------------------------------------------------
diff --git a/charmonizer/src/Charmonizer/Core/HeaderChecker.c b/charmonizer/src/Charmonizer/Core/HeaderChecker.c
index 1e4c675..7445976 100644
--- a/charmonizer/src/Charmonizer/Core/HeaderChecker.c
+++ b/charmonizer/src/Charmonizer/Core/HeaderChecker.c
@@ -37,24 +37,24 @@ static struct {
 /* Comparison function to feed to qsort, bsearch, etc.
  */
 static int
-S_compare_headers(const void *vptr_a, const void *vptr_b);
+chaz_HeadCheck_compare_headers(const void *vptr_a, const void *vptr_b);
 
 /* Run a test compilation and return a new chaz_CHeader object encapsulating
  * the results.
  */
 static chaz_CHeader*
-S_discover_header(const char *header_name);
+chaz_HeadCheck_discover_header(const char *header_name);
 
 /* Extend the cache, add this chaz_CHeader object to it, and sort.
  */
 static void
-S_add_to_cache(chaz_CHeader *header);
+chaz_HeadCheck_add_to_cache(chaz_CHeader *header);
 
 /* Like add_to_cache, but takes a individual elements instead of a
  * chaz_CHeader* and checks if header exists in array first.
  */
 static void
-S_maybe_add_to_cache(const char *header_name, int exists);
+chaz_HeadCheck_maybe_add_to_cache(const char *header_name, int exists);
 
 void
 chaz_HeadCheck_init(void) {
@@ -81,12 +81,13 @@ chaz_HeadCheck_check_header(const char *header_name) {
     key.exists = false;
     header_ptr = (chaz_CHeader**)bsearch(&fake, chaz_HeadCheck.header_cache,
                                          chaz_HeadCheck.cache_size,
-                                         sizeof(void*), S_compare_headers);
+                                         sizeof(void*),
+                                         chaz_HeadCheck_compare_headers);
 
     /* If it's not there, go try a test compile. */
     if (header_ptr == NULL) {
-        header = S_discover_header(header_name);
-        S_add_to_cache(header);
+        header = chaz_HeadCheck_discover_header(header_name);
+        chaz_HeadCheck_add_to_cache(header);
     }
     else {
         header = *header_ptr;
@@ -121,7 +122,7 @@ chaz_HeadCheck_check_many_headers(const char **header_names) {
     success = chaz_CC_test_compile(code_buf);
     if (success) {
         for (i = 0; header_names[i] != NULL; i++) {
-            S_maybe_add_to_cache(header_names[i], true);
+            chaz_HeadCheck_maybe_add_to_cache(header_names[i], true);
         }
     }
 
@@ -150,7 +151,7 @@ chaz_HeadCheck_contains_member(const char *struct_name, const char *member,
 }
 
 static int
-S_compare_headers(const void *vptr_a, const void *vptr_b) {
+chaz_HeadCheck_compare_headers(const void *vptr_a, const void *vptr_b) {
     chaz_CHeader *const *const a = (chaz_CHeader*const*)vptr_a;
     chaz_CHeader *const *const b = (chaz_CHeader*const*)vptr_b;
 
@@ -161,7 +162,7 @@ S_compare_headers(const void *vptr_a, const void *vptr_b) {
 }
 
 static chaz_CHeader*
-S_discover_header(const char *header_name) {
+chaz_HeadCheck_discover_header(const char *header_name) {
     static const char test_code[] = "int main() { return 0; }\n";
     chaz_CHeader* header = (chaz_CHeader*)malloc(sizeof(chaz_CHeader));
     size_t  needed = strlen(header_name) + sizeof(test_code) + 50;
@@ -179,7 +180,7 @@ S_discover_header(const char *header_name) {
 }
 
 static void
-S_add_to_cache(chaz_CHeader *header) {
+chaz_HeadCheck_add_to_cache(chaz_CHeader *header) {
     size_t amount;
 
     /* Realloc array -- inefficient, but this isn't a bottleneck. */
@@ -190,11 +191,12 @@ S_add_to_cache(chaz_CHeader *header) {
 
     /* Keep the list of headers sorted. */
     qsort(chaz_HeadCheck.header_cache, chaz_HeadCheck.cache_size,
-          sizeof(*(chaz_HeadCheck.header_cache)), S_compare_headers);
+          sizeof(*(chaz_HeadCheck.header_cache)),
+          chaz_HeadCheck_compare_headers);
 }
 
 static void
-S_maybe_add_to_cache(const char *header_name, int exists) {
+chaz_HeadCheck_maybe_add_to_cache(const char *header_name, int exists) {
     chaz_CHeader *header;
     chaz_CHeader  key;
     chaz_CHeader *fake = &key;
@@ -204,14 +206,14 @@ S_maybe_add_to_cache(const char *header_name, int exists) {
     key.exists = exists;
     header = (chaz_CHeader*)bsearch(&fake, chaz_HeadCheck.header_cache,
                                     chaz_HeadCheck.cache_size, sizeof(void*),
-                                    S_compare_headers);
+                                    chaz_HeadCheck_compare_headers);
 
     /* We've already done the test compile, so skip that step and add it. */
     if (header == NULL) {
         header = (chaz_CHeader*)malloc(sizeof(chaz_CHeader));
         header->name   = chaz_Util_strdup(header_name);
         header->exists = exists;
-        S_add_to_cache(header);
+        chaz_HeadCheck_add_to_cache(header);
     }
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/f64f0e81/charmonizer/src/Charmonizer/Probe.c
----------------------------------------------------------------------
diff --git a/charmonizer/src/Charmonizer/Probe.c b/charmonizer/src/Charmonizer/Probe.c
index d1c3152..84009a1 100644
--- a/charmonizer/src/Charmonizer/Probe.c
+++ b/charmonizer/src/Charmonizer/Probe.c
@@ -27,10 +27,10 @@
 /* Write the "_charm.h" file used by every probe.
  */
 static void
-S_write_charm_h(void);
+chaz_Probe_write_charm_h(void);
 
 static void
-S_remove_charm_h(void);
+chaz_Probe_remove_charm_h(void);
 
 void
 chaz_Probe_init(const char *cc_command, const char *cc_flags) {
@@ -45,7 +45,7 @@ chaz_Probe_init(const char *cc_command, const char *cc_flags) {
     chaz_CC_init(cc_command, cc_flags);
     chaz_ConfWriter_init();
     chaz_HeadCheck_init();
-    S_write_charm_h();
+    chaz_Probe_write_charm_h();
 
     if (chaz_Util_verbosity) { printf("Initialization complete.\n"); }
 }
@@ -55,7 +55,7 @@ chaz_Probe_clean_up(void) {
     if (chaz_Util_verbosity) { printf("Cleaning up...\n"); }
 
     /* Dispatch various clean up routines. */
-    S_remove_charm_h();
+    chaz_Probe_remove_charm_h();
     chaz_ConfWriter_clean_up();
     chaz_CC_clean_up();
 
@@ -63,7 +63,7 @@ chaz_Probe_clean_up(void) {
 }
 
 static void
-S_write_charm_h(void) {
+chaz_Probe_write_charm_h(void) {
     static const char charm_h_code[] =
         CHAZ_QUOTE(  #ifndef CHARM_H                                                  )
         CHAZ_QUOTE(  #define CHARM_H 1                                                )
@@ -74,7 +74,7 @@ S_write_charm_h(void) {
 }
 
 static void
-S_remove_charm_h(void) {
+chaz_Probe_remove_charm_h(void) {
     chaz_Util_remove_and_verify("_charm.h");
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/f64f0e81/charmonizer/src/Charmonizer/Probe/DirManip.c
----------------------------------------------------------------------
diff --git a/charmonizer/src/Charmonizer/Probe/DirManip.c b/charmonizer/src/Charmonizer/Probe/DirManip.c
index 1df66e1..bb6071c 100644
--- a/charmonizer/src/Charmonizer/Probe/DirManip.c
+++ b/charmonizer/src/Charmonizer/Probe/DirManip.c
@@ -31,7 +31,7 @@ static struct {
 
 /* Source code for rmdir. */
 static int
-S_compile_posix_mkdir(const char *header) {
+chaz_DirManip_compile_posix_mkdir(const char *header) {
     static const char posix_mkdir_code[] =
         CHAZ_QUOTE(  #include <%s>                                      )
         CHAZ_QUOTE(  int main(int argc, char **argv) {                  )
@@ -64,7 +64,7 @@ S_compile_posix_mkdir(const char *header) {
 }
 
 static int
-S_compile_win_mkdir(void) {
+chaz_DirManip_compile_win_mkdir(void) {
     static const char win_mkdir_code[] =
         CHAZ_QUOTE(  #include <direct.h>                                )
         CHAZ_QUOTE(  int main(int argc, char **argv) {                  )
@@ -83,16 +83,16 @@ S_compile_win_mkdir(void) {
 }
 
 static void
-S_try_mkdir(void) {
+chaz_DirManip_try_mkdir(void) {
     if (chaz_HeadCheck_check_header("windows.h")) {
-        if (S_compile_win_mkdir())               { return; }
-        if (S_compile_posix_mkdir("direct.h"))   { return; }
+        if (chaz_DirManip_compile_win_mkdir())               { return; }
+        if (chaz_DirManip_compile_posix_mkdir("direct.h"))   { return; }
     }
-    if (S_compile_posix_mkdir("sys/stat.h")) { return; }
+    if (chaz_DirManip_compile_posix_mkdir("sys/stat.h")) { return; }
 }
 
 static int
-S_compile_rmdir(const char *header) {
+chaz_DirManip_compile_rmdir(const char *header) {
     static const char rmdir_code[] =
         CHAZ_QUOTE(  #include <%s>                                      )
         CHAZ_QUOTE(  int main(int argc, char **argv) {                  )
@@ -111,10 +111,10 @@ S_compile_rmdir(const char *header) {
 }
 
 static void
-S_try_rmdir(void) {
-    if (S_compile_rmdir("unistd.h"))   { return; }
-    if (S_compile_rmdir("dirent.h"))   { return; }
-    if (S_compile_rmdir("direct.h"))   { return; }
+chaz_DirManip_try_rmdir(void) {
+    if (chaz_DirManip_compile_rmdir("unistd.h"))   { return; }
+    if (chaz_DirManip_compile_rmdir("dirent.h"))   { return; }
+    if (chaz_DirManip_compile_rmdir("direct.h"))   { return; }
 }
 
 static int
@@ -141,8 +141,8 @@ chaz_DirManip_run(void) {
     int has_dirent_d_type   = false;
 
     chaz_ConfWriter_start_module("DirManip");
-    S_try_mkdir();
-    S_try_rmdir();
+    chaz_DirManip_try_mkdir();
+    chaz_DirManip_try_rmdir();
 
     /* Header checks. */
     if (has_dirent_h) {

http://git-wip-us.apache.org/repos/asf/lucy/blob/f64f0e81/charmonizer/src/Charmonizer/Probe/FuncMacro.c
----------------------------------------------------------------------
diff --git a/charmonizer/src/Charmonizer/Probe/FuncMacro.c b/charmonizer/src/Charmonizer/Probe/FuncMacro.c
index 69ef04f..c0024b8 100644
--- a/charmonizer/src/Charmonizer/Probe/FuncMacro.c
+++ b/charmonizer/src/Charmonizer/Probe/FuncMacro.c
@@ -70,7 +70,7 @@ chaz_FuncMacro_probe_gnu() {
 
 /* Attempt to verify inline keyword. */
 static char*
-S_try_inline(const char *keyword, size_t *output_len) {
+chaz_FuncMacro_try_inline(const char *keyword, size_t *output_len) {
     static const char inline_code[] =
         CHAZ_QUOTE(  #include "_charm.h"               )
         CHAZ_QUOTE(  static %s int foo() { return 1; } )
@@ -98,7 +98,7 @@ chaz_FuncMacro_probe_inline(void) {
     for (i = 0; i < num_inline_options; i++) {
         const char *inline_option = inline_options[i];
         size_t output_len;
-        char *output = S_try_inline(inline_option, &output_len);
+        char *output = chaz_FuncMacro_try_inline(inline_option, &output_len);
         if (output != NULL) {
             has_inline = true;
             chaz_ConfWriter_add_def("INLINE", inline_option);

http://git-wip-us.apache.org/repos/asf/lucy/blob/f64f0e81/charmonizer/src/Charmonizer/Probe/Headers.c
----------------------------------------------------------------------
diff --git a/charmonizer/src/Charmonizer/Probe/Headers.c b/charmonizer/src/Charmonizer/Probe/Headers.c
index 75d1d2d..18974f3 100644
--- a/charmonizer/src/Charmonizer/Probe/Headers.c
+++ b/charmonizer/src/Charmonizer/Probe/Headers.c
@@ -34,13 +34,14 @@ static struct {
 /* Add a header to the keepers array.
  */
 static void
-S_keep(const char *header_name);
+chaz_Headers_keep(const char *header_name);
 
 /* Transform "header.h" into "CHY_HAS_HEADER_H, storing the result into
  * `buffer`.
  */
 static void
-S_encode_affirmation(const char *header_name, char *buffer, size_t buf_size);
+chaz_Headers_encode_affirmation(const char *header_name, char *buffer,
+                                size_t buf_size);
 
 /* Probe for all C89 headers. */
 static void
@@ -71,13 +72,13 @@ chaz_Headers_run(void) {
 
     /* One-offs. */
     if (chaz_HeadCheck_check_header("pthread.h")) {
-        S_keep("pthread.h");
+        chaz_Headers_keep("pthread.h");
     }
 
     /* Append the config with every header detected so far. */
     for (i = 0; chaz_Headers.keepers[i] != NULL; i++) {
         char aff_buf[200];
-        S_encode_affirmation(chaz_Headers.keepers[i], aff_buf, 200);
+        chaz_Headers_encode_affirmation(chaz_Headers.keepers[i], aff_buf, 200);
         chaz_ConfWriter_add_def(aff_buf, NULL);
     }
 
@@ -85,7 +86,7 @@ chaz_Headers_run(void) {
 }
 
 static void
-S_keep(const char *header_name) {
+chaz_Headers_keep(const char *header_name) {
     if (chaz_Headers.keeper_count >= CHAZ_HEADERS_MAX_KEEPERS) {
         chaz_Util_die("Too many keepers -- increase MAX_KEEPER_COUNT");
     }
@@ -94,7 +95,7 @@ S_keep(const char *header_name) {
 }
 
 static void
-S_encode_affirmation(const char *header_name, char *buffer, size_t buf_size) {
+chaz_Headers_encode_affirmation(const char *header_name, char *buffer, size_t buf_size) {
     char *buf, *buf_end;
     size_t len = strlen(header_name) + sizeof("HAS_");
     if (len + 1 > buf_size) {
@@ -149,14 +150,14 @@ chaz_Headers_probe_c89(void) {
         chaz_ConfWriter_add_def("HAS_C89", NULL);
         chaz_ConfWriter_add_def("HAS_C90", NULL);
         for (i = 0; c89_headers[i] != NULL; i++) {
-            S_keep(c89_headers[i]);
+            chaz_Headers_keep(c89_headers[i]);
         }
     }
     /* Test one-at-a-time. */
     else {
         for (i = 0; c89_headers[i] != NULL; i++) {
             if (chaz_HeadCheck_check_header(c89_headers[i])) {
-                S_keep(c89_headers[i]);
+                chaz_Headers_keep(c89_headers[i]);
             }
         }
     }
@@ -187,14 +188,14 @@ chaz_Headers_probe_posix(void) {
     if (chaz_HeadCheck_check_many_headers((const char**)posix_headers)) {
         chaz_ConfWriter_add_def("HAS_POSIX", NULL);
         for (i = 0; posix_headers[i] != NULL; i++) {
-            S_keep(posix_headers[i]);
+            chaz_Headers_keep(posix_headers[i]);
         }
     }
     /* Test one-at-a-time. */
     else {
         for (i = 0; posix_headers[i] != NULL; i++) {
             if (chaz_HeadCheck_check_header(posix_headers[i])) {
-                S_keep(posix_headers[i]);
+                chaz_Headers_keep(posix_headers[i]);
             }
         }
     }
@@ -214,14 +215,14 @@ chaz_Headers_probe_win(void) {
     /* Test for all Windows headers in one blast */
     if (chaz_HeadCheck_check_many_headers((const char**)win_headers)) {
         for (i = 0; win_headers[i] != NULL; i++) {
-            S_keep(win_headers[i]);
+            chaz_Headers_keep(win_headers[i]);
         }
     }
     /* Test one-at-a-time. */
     else {
         for (i = 0; win_headers[i] != NULL; i++) {
             if (chaz_HeadCheck_check_header(win_headers[i])) {
-                S_keep(win_headers[i]);
+                chaz_Headers_keep(win_headers[i]);
             }
         }
     }

http://git-wip-us.apache.org/repos/asf/lucy/blob/f64f0e81/charmonizer/src/Charmonizer/Probe/Integers.c
----------------------------------------------------------------------
diff --git a/charmonizer/src/Charmonizer/Probe/Integers.c b/charmonizer/src/Charmonizer/Probe/Integers.c
index 11e6fa8..3c5cb55 100644
--- a/charmonizer/src/Charmonizer/Probe/Integers.c
+++ b/charmonizer/src/Charmonizer/Probe/Integers.c
@@ -26,7 +26,7 @@
 /* Determine endian-ness of this machine.
  */
 static int
-S_machine_is_big_endian(void);
+chaz_Integers_machine_is_big_endian(void);
 
 static const char chaz_Integers_sizes_code[] =
     CHAZ_QUOTE(  #include "_charm.h"                       )
@@ -91,7 +91,7 @@ chaz_Integers_run(void) {
     chaz_ConfWriter_start_module("Integers");
 
     /* Document endian-ness. */
-    if (S_machine_is_big_endian()) {
+    if (chaz_Integers_machine_is_big_endian()) {
         chaz_ConfWriter_add_def("BIG_END", NULL);
     }
     else {
@@ -401,7 +401,7 @@ chaz_Integers_run(void) {
 }
 
 static int
-S_machine_is_big_endian(void) {
+chaz_Integers_machine_is_big_endian(void) {
     long one = 1;
     return !(*((char*)(&one)));
 }

http://git-wip-us.apache.org/repos/asf/lucy/blob/f64f0e81/charmonizer/src/Charmonizer/Probe/LargeFiles.c
----------------------------------------------------------------------
diff --git a/charmonizer/src/Charmonizer/Probe/LargeFiles.c b/charmonizer/src/Charmonizer/Probe/LargeFiles.c
index b6ece76..e171f84 100644
--- a/charmonizer/src/Charmonizer/Probe/LargeFiles.c
+++ b/charmonizer/src/Charmonizer/Probe/LargeFiles.c
@@ -48,14 +48,14 @@ typedef struct chaz_LargeFiles_unbuff_combo {
 /* Check for a 64-bit file pointer type.
  */
 static const int
-S_probe_off64(void);
+chaz_LargeFiles_probe_off64(void);
 
 /* Check what name 64-bit ftell, fseek go by.
  */
 static void
 chaz_LargeFiles_probe_stdio64(void);
 static int
-S_probe_stdio64(chaz_LargeFiles_stdio64_combo *combo);
+chaz_LargeFiles_try_stdio64(chaz_LargeFiles_stdio64_combo *combo);
 
 /* Probe for 64-bit unbuffered i/o.
  */
@@ -65,12 +65,12 @@ chaz_LargeFiles_probe_unbuff(void);
 /* Check for a 64-bit lseek.
  */
 static int
-S_probe_lseek(chaz_LargeFiles_unbuff_combo *combo);
+chaz_LargeFiles_probe_lseek(chaz_LargeFiles_unbuff_combo *combo);
 
 /* Check for a 64-bit pread.
  */
 static int
-S_probe_pread64(chaz_LargeFiles_unbuff_combo *combo);
+chaz_LargeFiles_probe_pread64(chaz_LargeFiles_unbuff_combo *combo);
 
 void
 chaz_LargeFiles_run(void) {
@@ -81,7 +81,7 @@ chaz_LargeFiles_run(void) {
     chaz_ConfWriter_start_module("LargeFiles");
 
     /* Find off64_t or equivalent. */
-    found_off64_t = S_probe_off64();
+    found_off64_t = chaz_LargeFiles_probe_off64();
     if (found_off64_t) {
         chaz_ConfWriter_add_def("HAS_64BIT_OFFSET_TYPE", NULL);
         chaz_ConfWriter_add_def("off64_t",  chaz_LargeFiles.off64_type);
@@ -116,7 +116,7 @@ chaz_LargeFiles_run(void) {
 }
 
 static const int
-S_probe_off64(void) {
+chaz_LargeFiles_probe_off64(void) {
     static const char off64_code[] =
         CHAZ_QUOTE(  %s                                        )
         CHAZ_QUOTE(  #include "_charm.h"                       )
@@ -163,7 +163,7 @@ S_probe_off64(void) {
 }
 
 static int
-S_probe_stdio64(chaz_LargeFiles_stdio64_combo *combo) {
+chaz_LargeFiles_try_stdio64(chaz_LargeFiles_stdio64_combo *combo) {
     static const char stdio64_code[] =
         CHAZ_QUOTE(  %s                                         )
         CHAZ_QUOTE(  #include "_charm.h"                        )
@@ -221,7 +221,7 @@ chaz_LargeFiles_probe_stdio64(void) {
 
     for (i = 0; stdio64_combos[i].includes != NULL; i++) {
         chaz_LargeFiles_stdio64_combo combo = stdio64_combos[i];
-        if (S_probe_stdio64(&combo)) {
+        if (chaz_LargeFiles_try_stdio64(&combo)) {
             chaz_ConfWriter_add_def("HAS_64BIT_STDIO", NULL);
             chaz_ConfWriter_add_def("fopen64",  combo.fopen_command);
             chaz_ConfWriter_add_def("ftello64", combo.ftell_command);
@@ -232,7 +232,7 @@ chaz_LargeFiles_probe_stdio64(void) {
 }
 
 static int
-S_probe_lseek(chaz_LargeFiles_unbuff_combo *combo) {
+chaz_LargeFiles_probe_lseek(chaz_LargeFiles_unbuff_combo *combo) {
     static const char lseek_code[] =
         CHAZ_QUOTE( %s                                                       )
         CHAZ_QUOTE( #include "_charm.h"                                      )
@@ -267,7 +267,7 @@ S_probe_lseek(chaz_LargeFiles_unbuff_combo *combo) {
 }
 
 static int
-S_probe_pread64(chaz_LargeFiles_unbuff_combo *combo) {
+chaz_LargeFiles_probe_pread64(chaz_LargeFiles_unbuff_combo *combo) {
     /* Code for checking 64-bit pread.  The pread call will fail, but that's
      * fine as long as it compiles. */
     static const char pread64_code[] =
@@ -309,7 +309,7 @@ chaz_LargeFiles_probe_unbuff(void) {
 
     for (i = 0; unbuff_combos[i].lseek_command != NULL; i++) {
         chaz_LargeFiles_unbuff_combo combo = unbuff_combos[i];
-        if (S_probe_lseek(&combo)) {
+        if (chaz_LargeFiles_probe_lseek(&combo)) {
             chaz_ConfWriter_add_def("HAS_64BIT_LSEEK", NULL);
             chaz_ConfWriter_add_def("lseek64", combo.lseek_command);
             break;
@@ -317,7 +317,7 @@ chaz_LargeFiles_probe_unbuff(void) {
     }
     for (i = 0; unbuff_combos[i].pread64_command != NULL; i++) {
         chaz_LargeFiles_unbuff_combo combo = unbuff_combos[i];
-        if (S_probe_pread64(&combo)) {
+        if (chaz_LargeFiles_probe_pread64(&combo)) {
             chaz_ConfWriter_add_def("HAS_64BIT_PREAD", NULL);
             chaz_ConfWriter_add_def("pread64", combo.pread64_command);
             break;


Mime
View raw message