Rename C functions and remove functors nested inside modules.

8 files changed, 91 insertions, 92 deletions

diff --git a/include/urweb/types_cpp.h b/include/urweb/types_cpp.h
index 2f154e1f..7b9a90a4 100644
--- a/include/urweb/types_cpp.h
+++ b/include/urweb/types_cpp.h
@@ -123,31 +123,31 @@ typedef struct {
 
 #include "uthash.h"
 
-typedef struct CacheValue {
+typedef struct uw_sqlcache_CacheValue {
   char *result;
   char *output;
-} CacheValue;
+} uw_sqlcache_CacheValue;
 
-typedef struct CacheEntry {
+typedef struct uw_sqlcache_CacheEntry {
   char *key;
   void *value;
   time_t timeValid;
-  struct CacheEntry *prev;
-  struct CacheEntry *next;
+  struct uw_sqlcache_CacheEntry *prev;
+  struct uw_sqlcache_CacheEntry *next;
   UT_hash_handle hh;
-} CacheEntry;
+} uw_sqlcache_CacheEntry;
 
-typedef struct CacheList {
-  CacheEntry *first;
-  CacheEntry *last;
+typedef struct uw_sqlcache_CacheList {
+  uw_sqlcache_CacheEntry *first;
+  uw_sqlcache_CacheEntry *last;
   int size;
-} CacheList;
+} uw_sqlcache_CacheList;
 
-typedef struct Cache {
-  CacheEntry *table;
+typedef struct uw_sqlcache_Cache {
+  uw_sqlcache_CacheEntry *table;
   time_t timeInvalid;
-  CacheList *lru;
+  uw_sqlcache_CacheList *lru;
   int height;
-} Cache;
+} uw_sqlcache_Cache;
 
 #endif
diff --git a/include/urweb/urweb_cpp.h b/include/urweb/urweb_cpp.h
index 3ae5b69e..3fac7041 100644
--- a/include/urweb/urweb_cpp.h
+++ b/include/urweb/urweb_cpp.h
@@ -406,8 +406,8 @@ void uw_Basis_writec(struct uw_context *, char);
 
 #include "uthash.h"
 
-CacheValue *check(Cache *, char **);
-CacheValue *store(Cache *, char **, CacheValue *);
-CacheValue *flush(Cache *, char **);
+uw_sqlcache_CacheValue *uw_sqlcache_check(uw_sqlcache_Cache *, char **);
+uw_sqlcache_CacheValue *uw_sqlcache_store(uw_sqlcache_Cache *, char **, uw_sqlcache_CacheValue *);
+uw_sqlcache_CacheValue *uw_sqlcache_flush(uw_sqlcache_Cache *, char **);
 
 #endif
diff --git a/src/c/urweb.c b/src/c/urweb.c
index e0fd503c..3993448b 100644
--- a/src/c/urweb.c
+++ b/src/c/urweb.c
@@ -4500,7 +4500,7 @@ void uw_set_remoteSock(uw_context ctx, int sock) {
 
 // Sqlcache
 
-void listDelete(CacheList *list, CacheEntry *entry) {
+void uw_sqlcache_listDelete(uw_sqlcache_CacheList *list, uw_sqlcache_CacheEntry *entry) {
   if (list->first == entry) {
     list->first = entry->next;
   }
@@ -4518,7 +4518,7 @@ void listDelete(CacheList *list, CacheEntry *entry) {
   --(list->size);
 }
 
-void listAdd(CacheList *list, CacheEntry *entry) {
+void uw_sqlcache_listAdd(uw_sqlcache_CacheList *list, uw_sqlcache_CacheEntry *entry) {
   if (list->last) {
     list->last->next = entry;
     entry->prev = list->last;
@@ -4530,22 +4530,22 @@ void listAdd(CacheList *list, CacheEntry *entry) {
   ++(list->size);
 }
 
-void listBump(CacheList *list, CacheEntry *entry) {
-  listDelete(list, entry);
-  listAdd(list, entry);
+void uw_sqlcache_listBump(uw_sqlcache_CacheList *list, uw_sqlcache_CacheEntry *entry) {
+  uw_sqlcache_listDelete(list, entry);
+  uw_sqlcache_listAdd(list, entry);
 }
 
 // TODO: deal with time properly.
 
-time_t getTimeNow() {
+time_t uw_sqlcache_getTimeNow() {
   return time(NULL);
 }
 
-time_t timeMax(time_t x, time_t y) {
+time_t uw_sqlcache_timeMax(time_t x, time_t y) {
   return difftime(x, y) > 0 ? x : y;
 }
 
-void freeCacheValue(CacheValue *value) {
+void uw_sqlcache_freeuw_sqlcache_CacheValue(uw_sqlcache_CacheValue *value) {
   if (value) {
     free(value->result);
     free(value->output);
@@ -4553,83 +4553,83 @@ void freeCacheValue(CacheValue *value) {
   }
 }
 
-void delete(Cache *cache, CacheEntry* entry) {
-  //listDelete(cache->lru, entry);
+void uw_sqlcache_delete(uw_sqlcache_Cache *cache, uw_sqlcache_CacheEntry* entry) {
+  //uw_sqlcache_listUw_Sqlcache_Delete(cache->lru, entry);
   HASH_DELETE(hh, cache->table, entry);
-  freeCacheValue(entry->value);
+  uw_sqlcache_freeuw_sqlcache_CacheValue(entry->value);
   free(entry->key);
   free(entry);
 }
 
-CacheValue *checkHelper(Cache *cache, char **keys, int timeInvalid) {
+uw_sqlcache_CacheValue *uw_sqlcache_checkHelper(uw_sqlcache_Cache *cache, char **keys, int timeInvalid) {
   char *key = keys[cache->height];
-  CacheEntry *entry;
+  uw_sqlcache_CacheEntry *entry;
   HASH_FIND(hh, cache->table, key, strlen(key), entry);
-  timeInvalid = timeMax(timeInvalid, cache->timeInvalid);
+  timeInvalid = uw_sqlcache_timeMax(timeInvalid, cache->timeInvalid);
   if (entry && difftime(entry->timeValid, timeInvalid) > 0) {
     if (cache->height == 0) {
       // At height 0, entry->value is the desired value.
-      //listBump(cache->lru, entry);
+      //uw_sqlcache_listBump(cache->lru, entry);
       return entry->value;
     } else {
       // At height n+1, entry->value is a pointer to a cache at heignt n.
-      return checkHelper(entry->value, keys, timeInvalid);
+      return uw_sqlcache_checkHelper(entry->value, keys, timeInvalid);
     }
   } else {
     return NULL;
   }
 }
 
-CacheValue *check(Cache *cache, char **keys) {
-  return checkHelper(cache, keys, 0);
+uw_sqlcache_CacheValue *uw_sqlcache_check(uw_sqlcache_Cache *cache, char **keys) {
+  return uw_sqlcache_checkHelper(cache, keys, 0);
 }
 
-void storeHelper(Cache *cache, char **keys, CacheValue *value, int timeNow) {
-  CacheEntry *entry;
+void uw_sqlcache_storeHelper(uw_sqlcache_Cache *cache, char **keys, uw_sqlcache_CacheValue *value, int timeNow) {
+  uw_sqlcache_CacheEntry *entry;
   char *key = keys[cache->height];
   HASH_FIND(hh, cache->table, key, strlen(key), entry);
   if (!entry) {
-    entry = malloc(sizeof(CacheEntry));
+    entry = malloc(sizeof(uw_sqlcache_CacheEntry));
     entry->key = strdup(key);
     entry->value = NULL;
     HASH_ADD_KEYPTR(hh, cache->table, entry->key, strlen(entry->key), entry);
   }
   entry->timeValid = timeNow;
   if (cache->height == 0) {
-    //listAdd(cache->lru, entry);
-    freeCacheValue(entry->value);
+    //uw_sqlcache_listAdd(cache->lru, entry);
+    uw_sqlcache_freeuw_sqlcache_CacheValue(entry->value);
     entry->value = value;
     //if (cache->lru->size > MAX_SIZE) {
-      //delete(cache, cache->lru->first);
+      //uw_sqlcache_delete(cache, cache->lru->first);
       // TODO: return flushed value.
     //}
   } else {
     if (!entry->value) {
-      Cache *newCache = malloc(sizeof(Cache));
-      newCache->table = NULL;
-      newCache->timeInvalid = timeNow;
-      newCache->lru = cache->lru;
-      newCache->height = cache->height - 1;
-      entry->value = newCache;
+      uw_sqlcache_Cache *newuw_sqlcache_Cache = malloc(sizeof(uw_sqlcache_Cache));
+      newuw_sqlcache_Cache->table = NULL;
+      newuw_sqlcache_Cache->timeInvalid = timeNow;
+      newuw_sqlcache_Cache->lru = cache->lru;
+      newuw_sqlcache_Cache->height = cache->height - 1;
+      entry->value = newuw_sqlcache_Cache;
     }
-    storeHelper(entry->value, keys, value, timeNow);
+    uw_sqlcache_storeHelper(entry->value, keys, value, timeNow);
   }
 }
 
-void store(Cache *cache, char **keys, CacheValue *value) {
-  storeHelper(cache, keys, value, getTimeNow());
+void uw_sqlcache_store(uw_sqlcache_Cache *cache, char **keys, uw_sqlcache_CacheValue *value) {
+  uw_sqlcache_storeHelper(cache, keys, value, uw_sqlcache_getTimeNow());
 }
 
-void flushHelper(Cache *cache, char **keys, int timeNow) {
-  CacheEntry *entry;
+void uw_sqlcache_flushHelper(uw_sqlcache_Cache *cache, char **keys, int timeNow) {
+  uw_sqlcache_CacheEntry *entry;
   char *key = keys[cache->height];
   if (key) {
     HASH_FIND(hh, cache->table, key, strlen(key), entry);
     if (entry) {
       if (cache->height == 0) {
-        delete(cache, entry);
+        uw_sqlcache_delete(cache, entry);
       } else {
-        flushHelper(entry->value, keys, timeNow);
+        uw_sqlcache_flushHelper(entry->value, keys, timeNow);
       }
     }
   } else {
@@ -4638,6 +4638,6 @@ void flushHelper(Cache *cache, char **keys, int timeNow) {
   }
 }
 
-void flush(Cache *cache, char **keys) {
-  flushHelper(cache, keys, getTimeNow());
+void uw_sqlcache_flush(uw_sqlcache_Cache *cache, char **keys) {
+  uw_sqlcache_flushHelper(cache, keys, uw_sqlcache_getTimeNow());
 }
diff --git a/src/lru_cache.sml b/src/lru_cache.sml
index 87e939fa..26590312 100644
--- a/src/lru_cache.sml
+++ b/src/lru_cache.sml
@@ -64,7 +64,7 @@ fun setupQuery {index, params} =
 
     in
         Print.box
-            [string ("static Cache cacheStruct" ^ i ^ " = {"),
+            [string ("static uw_sqlcache_Cache cacheStruct" ^ i ^ " = {"),
              newline,
              string "  .table = NULL,",
              newline,
@@ -74,7 +74,7 @@ fun setupQuery {index, params} =
              newline,
              string ("  .height = " ^ Int.toString (params - 1) ^ "};"),
              newline,
-             string ("static Cache *cache" ^ i ^ " = &cacheStruct" ^ i ^ ";"),
+             string ("static uw_sqlcache_Cache *cache" ^ i ^ " = &cacheStruct" ^ i ^ ";"),
              newline,
              newline,
 
@@ -83,7 +83,7 @@ fun setupQuery {index, params} =
              newline,
              string ("  char *ks[] = {" ^ revArgs ^ "};"),
              newline,
-             string ("  CacheValue *v = check(cache" ^ i ^ ", ks);"),
+             string ("  uw_sqlcache_CacheValue *v = uw_sqlcache_check(cache" ^ i ^ ", ks);"),
              newline,
              string "  if (v) {",
              newline,
@@ -112,7 +112,7 @@ fun setupQuery {index, params} =
              newline,
              string ("  char *ks[] = {" ^ revArgs ^ "};"),
              newline,
-             string ("  CacheValue *v = malloc(sizeof(CacheValue));"),
+             string ("  uw_sqlcache_CacheValue *v = malloc(sizeof(uw_sqlcache_CacheValue));"),
              newline,
              string "  v->result = strdup(s);",
              newline,
@@ -120,7 +120,7 @@ fun setupQuery {index, params} =
              newline,
              string ("  puts(\"SQLCACHE: stored " ^ i ^ ".\");"),
              newline,
-             string ("  store(cache" ^ i ^ ", ks, v);"),
+             string ("  uw_sqlcache_store(cache" ^ i ^ ", ks, v);"),
              newline,
              string "  return uw_unit_v;",
              newline,
@@ -133,7 +133,7 @@ fun setupQuery {index, params} =
              newline,
              string ("  char *ks[] = {" ^ revArgs ^ "};"),
              newline,
-             string ("  flush(cache" ^ i ^ ", ks);"),
+             string ("  uw_sqlcache_flush(cache" ^ i ^ ", ks);"),
              newline,
              string "  return uw_unit_v;",
              newline,
diff --git a/src/option_key_fn.sml b/src/option_key_fn.sml
new file mode 100644
index 00000000..ba636d4e
--- /dev/null
+++ b/src/option_key_fn.sml
@@ -0,0 +1,11 @@
+functor OptionKeyFn(K : ORD_KEY) : ORD_KEY = struct
+
+type ord_key = K.ord_key option
+
+val compare =
+ fn (NONE, NONE) => EQUAL
+  | (NONE, _) => LESS
+  | (_, NONE) => GREATER
+  | (SOME x, SOME y) => K.compare (x, y)
+
+end
diff --git a/src/sources b/src/sources
index 0608d710..f0914bdf 100644
--- a/src/sources
+++ b/src/sources
@@ -172,8 +172,9 @@ $(SRC)/sql.sig
 $(SRC)/sql.sml
 
 $(SRC)/union_find_fn.sml
-
 $(SRC)/multimap_fn.sml
+$(SRC)/option_key_fn.sml
+$(SRC)/triple_key_fn.sml
 
 $(SRC)/cache.sml
 $(SRC)/toy_cache.sml
diff --git a/src/sqlcache.sml b/src/sqlcache.sml
index 5f737ac5..ff58ef77 100644
--- a/src/sqlcache.sml
+++ b/src/sqlcache.sml
@@ -207,7 +207,7 @@ fun mapFormula mf =
 
 (* SQL analysis. *)
 
-structure CmpKey : ORD_KEY = struct
+structure CmpKey = struct
 
     type ord_key = Sql.cmp
 
@@ -247,34 +247,6 @@ functor ListKeyFn (K : ORD_KEY) : ORD_KEY = struct
 end
 *)
 
-functor OptionKeyFn (K : ORD_KEY) : ORD_KEY = struct
-
-    type ord_key = K.ord_key option
-
-    val compare =
-     fn (NONE, NONE) => EQUAL
-      | (NONE, _) => LESS
-      | (_, NONE) => GREATER
-      | (SOME x, SOME y) => K.compare (x, y)
-
-end
-
-functor TripleKeyFn (structure I : ORD_KEY
-                     structure J : ORD_KEY
-                     structure K : ORD_KEY)
-        : ORD_KEY where type ord_key = I.ord_key * J.ord_key * K.ord_key = struct
-
-    type ord_key = I.ord_key * J.ord_key * K.ord_key
-
-    fun compare ((i1, j1, k1), (i2, j2, k2)) =
-        case I.compare (i1, i2) of
-            EQUAL => (case J.compare (j1, j2) of
-                          EQUAL => K.compare (k1, k2)
-                        | ord => ord)
-          | ord => ord
-
-end
-
 val rec chooseTwos : 'a list -> ('a * 'a) list =
  fn [] => []
   | x :: ys => map (fn y => (x, y)) ys @ chooseTwos ys
diff --git a/src/triple_key_fn.sml b/src/triple_key_fn.sml
new file mode 100644
index 00000000..ba77c60b
--- /dev/null
+++ b/src/triple_key_fn.sml
@@ -0,0 +1,15 @@
+functor TripleKeyFn (structure I : ORD_KEY
+                     structure J : ORD_KEY
+                     structure K : ORD_KEY)
+        : ORD_KEY where type ord_key = I.ord_key * J.ord_key * K.ord_key = struct
+
+type ord_key = I.ord_key * J.ord_key * K.ord_key
+
+fun compare ((i1, j1, k1), (i2, j2, k2)) =
+    case I.compare (i1, i2) of
+        EQUAL => (case J.compare (j1, j2) of
+                      EQUAL => K.compare (k1, k2)
+                    | ord => ord)
+      | ord => ord
+
+end