reduce C usage

Author: maxbachmann

src/Levenshtein/Levenshtein-c/_levenshtein.cpp

@@ -87,16 +87,15 @@ make_symlistset(size_t n, const size_t *lengths,
   return symlist;
 }
 
-lev_byte*
+std::basic_string<lev_byte>
 lev_quick_median(size_t n,
                  const size_t *lengths,
                  const lev_byte *strings[],
-                 const double *weights,
-                 size_t *medlength)
+                 const double *weights)
 {
   size_t symlistlen, len, i, j, k;
   lev_byte *symlist;
-  lev_byte *median;  /* the resulting string */
+  std::basic_string<lev_byte> median;  /* the resulting string */
   double *symset;
 
   /* first check whether the result would be an empty string 
@@ -105,27 +104,25 @@ lev_quick_median(size_t n,
   double wl = std::accumulate(   weights, weights + n, 0.0);
 
   if (wl == 0.0)
-    return (lev_byte*)calloc(1, sizeof(lev_byte));
+    return std::basic_string<lev_byte>();
+
   ml = floor(ml/wl + 0.499999);
-  *medlength = len = (size_t)ml;
+  len = (size_t)ml;
   if (!len)
-    return (lev_byte*)calloc(1, sizeof(lev_byte));
-  median = (lev_byte*)safe_malloc(len, sizeof(lev_byte));
-  if (!median)
-    return NULL;
+    return std::basic_string<lev_byte>();
+
+  median.resize(len);
 
   /* find the symbol set;
    * now an empty symbol set is really a failure */
   symset = (double*)calloc(0x100, sizeof(double));
-  if (!symset) {
-    free(median);
-    return NULL;
-  }
+  if (!symset)
+    throw std::bad_alloc();
+
   symlist = make_symlistset(n, lengths, strings, &symlistlen, symset);
   if (!symlist) {
-    free(median);
     free(symset);
-    return NULL;
+    throw std::bad_alloc();
   }
 
   for (j = 0; j < len; j++) {
@@ -269,16 +266,15 @@ make_usymlistset(size_t n, const size_t *lengths,
   return symlist;
 }
 
-lev_wchar*
+std::basic_string<lev_wchar>
 lev_u_quick_median(size_t n,
                    const size_t *lengths,
                    const lev_wchar *strings[],
-                   const double *weights,
-                   size_t *medlength)
+                   const double *weights)
 {
   size_t symlistlen, len, i, j, k;
   lev_wchar *symlist;
-  lev_wchar *median;  /* the resulting string */
+  std::basic_string<lev_wchar> median;  /* the resulting string */
   HQItem *symmap;
 
   /* first check whether the result would be an empty string 
@@ -287,27 +283,23 @@ lev_u_quick_median(size_t n,
   double wl = std::accumulate(   weights, weights + n, 0.0);
 
   if (wl == 0.0)
-    return (lev_wchar*)calloc(1, sizeof(lev_wchar));
+    return std::basic_string<lev_wchar>();
   ml = floor(ml/wl + 0.499999);
-  *medlength = len = (size_t)ml;
+  len = (size_t)ml;
   if (!len)
-    return (lev_wchar*)calloc(1, sizeof(lev_wchar));
-  median = (lev_wchar*)safe_malloc(len, sizeof(lev_wchar));
-  if (!median)
-    return NULL;
+    return std::basic_string<lev_wchar>();
+  median.resize(len);
 
   /* find the symbol set;
    * now an empty symbol set is really a failure */
   symmap = (HQItem*)safe_malloc(0x100, sizeof(HQItem));
-  if (!symmap) {
-    free(median);
-    return NULL;
-  }
+  if (!symmap)
+    throw std::bad_alloc();
+
   symlist = make_usymlistset(n, lengths, strings, &symlistlen, symmap);
   if (!symlist) {
-    free(median);
     free_usymlistset_hash(symmap);
-    return NULL;
+    throw std::bad_alloc();
   }
 
   for (j = 0; j < len; j++) {

src/Levenshtein/Levenshtein-c/_levenshtein.hpp

@@ -6,6 +6,7 @@
 #include <numeric>
 #include <memory>
 #include <vector>
+#include <string>
 #include <unordered_set>
 #include <rapidfuzz/distance/Indel.hpp>
 #include <rapidfuzz/distance/Levenshtein.hpp>
@@ -129,24 +130,24 @@ static inline RF_String convert_string(PyObject* py_str)
 /* Edit operation type
  * DON'T CHANGE! used as array indices and the bits are occasionally used
  * as flags */
-typedef enum {
+enum LevEditType {
   LEV_EDIT_KEEP = 0,
   LEV_EDIT_REPLACE = 1,
   LEV_EDIT_INSERT = 2,
   LEV_EDIT_DELETE = 3,
   LEV_EDIT_LAST  /* sometimes returned when an error occurs */
-} LevEditType;
+};
 
 /* Error codes returned by editop check functions */
-typedef enum {
+enum LevEditOpError {
   LEV_EDIT_ERR_OK = 0,
   LEV_EDIT_ERR_TYPE,  /* nonexistent edit type */
   LEV_EDIT_ERR_OUT,  /* edit out of string bounds */
   LEV_EDIT_ERR_ORDER,  /* ops are not ordered */
   LEV_EDIT_ERR_BLOCK,  /* incosistent block boundaries (block ops) */
   LEV_EDIT_ERR_SPAN,  /* sequence is not a full transformation (block ops) */
   LEV_EDIT_ERR_LAST
-} LevEditOpError;
+};
 
 /* Edit operation (atomic).
  * This is the `native' atomic edit operation.  It differs from the difflib
@@ -481,26 +482,23 @@ double finish_distance_computations(size_t len1, CharT* string1,
  * @strings: An array of strings, that may contain NUL characters.
  * @weights: The string weights (they behave exactly as multiplicities, though
  *           any positive value is allowed, not just integers).
- * @medlength: Where the new length of the median should be stored.
  *
  * Tries to make @s a better generalized median string of @strings with
  * small perturbations.
  *
  * It never returns a string with larger SOD than @s; in the worst case, a
  * string identical to @s is returned.
  *
- * Returns: The improved generalized median, as a newly allocated string; its
- *          length is stored in @medlength.
+ * Returns: The improved generalized median
  **/
 template <typename CharT>
-CharT* lev_median_improve(size_t len, const CharT* s, size_t n, const size_t* lengths,
-                             const CharT** strings, const double *weights, size_t *medlength)
+std::basic_string<CharT> lev_median_improve(size_t len, const CharT* s, size_t n, const size_t* lengths,
+                             const CharT** strings, const double *weights)
 {
   /* find all symbols */
   std::vector<CharT> symlist = make_symlist(n, lengths, strings);
   if (symlist.empty()) {
-    *medlength = 0;
-    return (CharT*)calloc(1, sizeof(CharT));
+    return std::basic_string<CharT>();
   }
 
   /* allocate and initialize per-string matrix rows and a common work buffer */
@@ -552,7 +550,7 @@ CharT* lev_median_improve(size_t len, const CharT* s, size_t n, const size_t* le
       median[pos] = orig_symbol;
     }
     /* FOREACH symbol: try to add it at pos, if some lower the total
-     * distance, chooste the best (increase medlength)
+     * distance, chooste the best (increase medlen)
      * We simulate insertion by replacing the character at pos-1 */
     orig_symbol = *(median + pos - 1);
     for (size_t j = 0; j < symlist.size(); j++) {
@@ -567,8 +565,8 @@ CharT* lev_median_improve(size_t len, const CharT* s, size_t n, const size_t* le
       }
     }
     *(median + pos - 1) = orig_symbol;
-    /* IF pos < medlength: try to delete the symbol at pos, if it lowers
-     * the total distance remember it (decrease medlength) */
+    /* IF pos < medlen: try to delete the symbol at pos, if it lowers
+     * the total distance remember it (decrease medlen) */
     if (pos < medlen) {
       sum = finish_distance_computations(medlen - pos - 1, median + pos + 1,
                                          n, lengths, strings,
@@ -624,29 +622,20 @@ CharT* lev_median_improve(size_t len, const CharT* s, size_t n, const size_t* le
     }
   }
 
-  /* return result */
-  CharT *result = (CharT*)safe_malloc(medlen, sizeof(CharT));
-  if (!result) {
-    return NULL;
-  }
-  *medlength = medlen;
-  memcpy(result, median, medlen*sizeof(CharT));
-  return result;
+  return std::basic_string<CharT>(median, medlen);
 }
 
-lev_byte*
+std::basic_string<lev_byte>
 lev_quick_median(size_t n,
                  const size_t *lengths,
                  const lev_byte *strings[],
-                 const double *weights,
-                 size_t *medlength);
+                 const double *weights);
 
-lev_wchar*
+std::basic_string<lev_wchar>
 lev_u_quick_median(size_t n,
                    const size_t *lengths,
                    const lev_wchar *strings[],
-                   const double *weights,
-                   size_t *medlength);
+                   const double *weights);
 
 /**
  * lev_set_median:
@@ -655,12 +644,10 @@ lev_u_quick_median(size_t n,
  * @strings: An array of strings, that may contain NUL characters.
  * @weights: The string weights (they behave exactly as multiplicities, though
  *           any positive value is allowed, not just integers).
- * @medlength: Where the length of the median string should be stored.
  *
  * Finds the median string of a string set @strings.
  *
- * Returns: The set median as a newly allocate string, its length is stored
- *          in @medlength.  %NULL in the case of failure.
+ * Returns: The set median
  **/
 static inline std::basic_string<uint32_t> lev_set_median(const std::vector<RF_String>& strings,
                          const std::vector<double>& weights)