interface.cpp

#include <Python.h>
#include <locale>

#include "diff-match-patch-cpp-stl/diff_match_patch.h"

#if PY_MAJOR_VERSION == 3
 // Upgrade these types.
 #define PyString_FromString PyUnicode_FromString
 #define PyString_FromStringAndSize PyUnicode_FromStringAndSize
 #define PyInt_FromLong PyLong_FromLong
#endif

// template traits class
template <char FMTSPEC>
struct call_traits {
};

// Python 2 string
template <>
struct call_traits<'s'> {
 // PyArg_ParseTuple for 's' gives a 'char*', and we'll
 // convert that to a std::string using a cast operator.
 typedef char* PY_STRING_STORAGE;
 typedef std::string STL_STRING_TYPE;

 // Use the operator cast to convert char*s to std::strings.
 static std::string to_string(char* value) { return (std::string)value; }

 // Create PyString from underlying char array
 static PyObject* from_string(std::string& value) {
 return PyString_FromStringAndSize(value.data(), value.size());
 }

 // Convert std::strings to char*s
 static const char* to_bytes(std::string& value) {
 return value.c_str();
 }
};

// Python 3 bytes
template <>
struct call_traits<'y'> {
 // PyArg_ParseTuple for 'y' gives a 'char*', and we'll
 // convert that to a std::string using a cast operator.
 typedef char* PY_STRING_STORAGE;
 typedef std::string STL_STRING_TYPE;

 // Use the operator cast to convert char*s to std::strings.
 static std::string to_string(char* value) { return (std::string)value; }

 // Create PyString from underlying char array
 static PyObject* from_string(std::string& value) {
 return PyString_FromStringAndSize(value.data(), value.size());
 }

 // Convert std::strings to char*s
 static const char* to_bytes(std::string& value) {
 return value.c_str();
 }
};

// Python 2/3 unicode
template <>
struct call_traits<'u'> {
 // PyArg_ParseTuple for 'u' gives a 'Py_UNICODE*'. That's a
 // typedef for wchar_t, unsigned short (UCS2) or unsigned long (UCS4).
 // On Ubuntu, it seems to be a typedef for wchar_t.
 // On Macs, the default build has it as a typedef for UCS2 (a "narrow" build).
 // With Python 3.3 and forward, it is always a typedef for wchar_t.
 typedef Py_UNICODE* PY_STRING_STORAGE;
 typedef std::wstring STL_STRING_TYPE;

 // Convert Py_UNICODE* to std::wstring....
 static std::wstring to_string(Py_UNICODE* value) {
 // If Py_UNICODE is the same width as wchar_t, then just do a few casts.
 // Hopefully wchar_t is unsigned, but it may not matter anyway. When
 // Py_UNICODE actually *is* wchar_t, the casts are unnecessary, but we
 // want this to compile in other environments as well.
 if (sizeof(Py_UNICODE) == sizeof(wchar_t))
 return (std::wstring)(wchar_t*)value;

 // In other cases, cast each character to wchar_t. Technically this
 // means that when a surrogate pair appears in the UTF-16 source, we
 // will treat it as two "unpaired surrogate" codepoints, which are
 // illegal in UTF-32. But the library doesn't care, and we will just be
 // converting back to UTF-16 later.
 //
 // There is a risk that the unpaired surrogates will end up in
 // different diff blocks, but this is par for the course for narrow
 // builds of Python. (difflib has the same problem.)
 size_t len = 0;
 while (value[len] != 0)
 len++;
 wchar_t* buf = (wchar_t*)malloc(sizeof(wchar_t) * (len + 1));
 assert(buf);
 buf[len] = '\0';
 for (size_t i = 0; i < len; i++)
 buf[i] = (wchar_t)value[i];
 std::wstring ret = (std::wstring)buf;
 free(buf);
 return ret;
 }

 static PyObject* from_string(std::wstring value) {
 // Wide build--just cast underlying char_t array.
 if (sizeof(Py_UNICODE) == sizeof(wchar_t))
 return PyUnicode_FromUnicode((Py_UNICODE*)value.data(), value.size());

 // Narrow build--cast to 16-bit. This is not the normal way to convert
 // UTF-32 to UTF-16, but since we got the wstring by casting UTF-16
 // chars it is fine in this case (modulo the unpaired surrogate issues
 // which we are intentionally not addressing here--see comments in
 // to_string).
 size_t len = value.size();
 Py_UNICODE* buf = (Py_UNICODE*)malloc(sizeof(Py_UNICODE) * (len + 1));
 assert(buf);
 buf[len] = '\0';
 for (size_t i = 0; i < len; i++)
 buf[i] = (Py_UNICODE)value[i];
 PyObject* ret = PyUnicode_FromUnicode(buf, len);
 free(buf);
 return ret;
 }

/* Python 3.5 introduced Py_EncodeLocale for converting wchar_t* to char*.
 If we're on Python 2.7 or 3.4, just return a dummy error, because
 doing the locale conversion manually is complicated. */
#if PY_MAJOR_VERSION == 2 || (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION <= 4)
 static const char* to_bytes(std::wstring& value) {
 return "Unspecified error";
 }
#else
 static const char* to_bytes(std::wstring& value) {
 return Py_EncodeLocale(value.c_str(), NULL);
 }
#endif
};

// actual function
template <char FMTSPEC>
static PyObject *
diff_match_patch_diff(PyObject *self, PyObject *args, PyObject *kwargs)
{
 typedef call_traits<FMTSPEC> traits;
 typename traits::PY_STRING_STORAGE a, b;
 float timelimit = 0.0;
 int checklines = 1;
 int cleanupSemantic = 1;
 int cleanupEfficient = 0;
 int counts_only = 1;
 int as_patch = 0;
 char format_spec[64];

 static char *kwlist[] = {
 strdup("left_document"),
 strdup("right_document"),
 strdup("timelimit"),
 strdup("checklines"),
 strdup("cleanup_semantic"),
 strdup("cleanup_efficient"),
 strdup("counts_only"),
 strdup("as_patch"),
 NULL };

 sprintf(format_spec, "%c%c|fbbbbb", FMTSPEC, FMTSPEC);
 if (!PyArg_ParseTupleAndKeywords(args, kwargs, format_spec, kwlist,
 &a, &b,
 &timelimit, &checklines, &cleanupSemantic, &cleanupEfficient,
 &counts_only, &as_patch))
 return NULL;

 PyObject *ret = PyList_New(0);

 typedef diff_match_patch<typename traits::STL_STRING_TYPE> DMP;
 DMP dmp;

 PyObject *opcodes[3];
 opcodes[dmp.DELETE] = PyString_FromString("-1");
 opcodes[dmp.INSERT] = PyString_FromString("1");
 opcodes[dmp.EQUAL] = PyString_FromString("0");

 dmp.Diff_Timeout = timelimit;
 typename DMP::Diffs diff = dmp.diff_main(traits::to_string(a), traits::to_string(b), checklines);

 if (cleanupSemantic)
 dmp.diff_cleanupSemantic(diff);
 else if (cleanupEfficient)
 dmp.diff_cleanupEfficiency(diff);

 if (as_patch) {
 typename DMP::Patches patch = dmp.patch_make(traits::to_string(a), diff);
 typename traits::STL_STRING_TYPE patch_str = dmp.patch_toText(patch);

 return traits::from_string(patch_str);
 }

 typename std::list<typename DMP::Diff>::const_iterator entryiter;
 for (entryiter = diff.begin(); entryiter != diff.end(); entryiter++) {
 typename DMP::Diff entry = *entryiter;

 PyObject* tuple = PyTuple_New(2);

 Py_INCREF(opcodes[entry.operation]); // we're going to reuse the object, so don't let SetItem steal the reference
 PyTuple_SetItem(tuple, 0, opcodes[entry.operation]);

 if (counts_only)
 PyTuple_SetItem(tuple, 1, PyInt_FromLong(entry.text.length()));
 else
 PyTuple_SetItem(tuple, 1, traits::from_string(entry.text));

 PyList_Append(ret, tuple);
 Py_DECREF(tuple); // the list owns a reference now
 }

 // We're left with one extra reference.
 Py_DECREF(opcodes[dmp.DELETE]);
 Py_DECREF(opcodes[dmp.INSERT]);
 Py_DECREF(opcodes[dmp.EQUAL]);

 return ret;
}

static PyObject *
diff_match_patch_diff_unicode(PyObject *self, PyObject *args, PyObject *kwargs)
{
 return diff_match_patch_diff<'u'>(self, args, kwargs);
}


template <char FMTSPEC>
static PyObject *
diff_match_patch_match_main(PyObject *self, PyObject *args, PyObject *kwargs)
{
 typedef call_traits<FMTSPEC> traits;
 typename traits::PY_STRING_STORAGE pattern, text;
 int loc;
 int match_distance = 1000;
 int match_maxbits = 32;
 float match_threshold = 0.5;
 char format_spec[64];

 static char *kwlist[] = {
 strdup("pattern"),
 strdup("text"),
 strdup("loc"),
 strdup("match_distance"),
 strdup("match_maxbits"),
 strdup("match_threshold"),
 NULL };

 sprintf(format_spec, "%c%ci|iif", FMTSPEC, FMTSPEC);
 if (!PyArg_ParseTupleAndKeywords(args, kwargs, format_spec, kwlist,
 &pattern, &text, &loc,
 &match_distance, &match_maxbits, &match_threshold)) {
 return NULL;
 }

 typedef diff_match_patch<typename traits::STL_STRING_TYPE> DMP;
 DMP dmp;

 dmp.Match_Distance = match_distance;
 dmp.Match_MaxBits = match_maxbits;
 dmp.Match_Threshold = match_threshold;

 try {
 int index = dmp.match_main(traits::to_string(pattern), traits::to_string(text), loc);
 return Py_BuildValue("i", index);
 } catch (std::exception& e) {
 PyErr_SetString(PyExc_RuntimeError, e.what());
 return NULL;
 } catch (typename traits::STL_STRING_TYPE& s) {
 PyErr_SetString(PyExc_RuntimeError, traits::to_bytes(s));
 return NULL;
 }
}

static PyObject *
diff_match_patch_match_main_unicode(PyObject *self, PyObject *args, PyObject *kwargs)
{
 return diff_match_patch_match_main<'u'>(self, args, kwargs);
}

#if PY_MAJOR_VERSION == 2
static PyObject *
diff_match_patch_diff_str(PyObject *self, PyObject *args, PyObject *kwargs)
{
 return diff_match_patch_diff<'s'>(self, args, kwargs);
}

static PyObject *
diff_match_patch_match_main_str(PyObject *self, PyObject *args, PyObject *kwargs)
{
 return diff_match_patch_match_main<'s'>(self, args, kwargs);
}

static PyMethodDef MyMethods[] = {
 {"diff_unicode", (PyCFunction)diff_match_patch_diff_unicode, METH_VARARGS|METH_KEYWORDS,
 "Compute the difference between two Unicode strings. Returns a list of tuples (OP, LEN)."},
 {"diff_str", (PyCFunction)diff_match_patch_diff_str, METH_VARARGS|METH_KEYWORDS,
 "Compute the difference between two (regular) strings. Returns a list of tuples (OP, LEN)."},
 {"match_main_unicode", (PyCFunction)diff_match_patch_match_main_unicode, METH_VARARGS|METH_KEYWORDS,
 "Locate the best instance of 'pattern' in 'text' near 'loc'. Returns -1 if no match found."},
 {"match_main_str", (PyCFunction)diff_match_patch_match_main_str, METH_VARARGS|METH_KEYWORDS,
 "Locate the best instance of 'pattern' in 'text' near 'loc'. Returns -1 if no match found."},
 {NULL, NULL, 0, NULL} /* Sentinel */
};

PyMODINIT_FUNC
initdiff_match_patch(void)
{
 (void) Py_InitModule("diff_match_patch", MyMethods);
}
#endif

#if PY_MAJOR_VERSION == 3
static PyObject *
diff_match_patch_diff_bytes(PyObject *self, PyObject *args, PyObject *kwargs)
{
 return diff_match_patch_diff<'y'>(self, args, kwargs);
}

static PyObject *
diff_match_patch_match_main_bytes(PyObject *self, PyObject *args, PyObject *kwargs)
{
 return diff_match_patch_match_main<'y'>(self, args, kwargs);
}

static PyMethodDef MyMethods[] = {
 {"diff", (PyCFunction)diff_match_patch_diff_unicode, METH_VARARGS|METH_KEYWORDS,
 "Compute the difference between two strings. Returns a list of tuples (OP, LEN)."},
 {"diff_bytes", (PyCFunction)diff_match_patch_diff_bytes, METH_VARARGS|METH_KEYWORDS,
 "Compute the difference between two byte strings. Returns a list of tuples (OP, LEN)."},
 {"match_main", (PyCFunction)diff_match_patch_match_main_unicode, METH_VARARGS|METH_KEYWORDS,
 "Locate the best instance of 'pattern' in 'text' near 'loc'. Returns -1 if no match found."},
 {"match_main_bytes", (PyCFunction)diff_match_patch_match_main_bytes, METH_VARARGS|METH_KEYWORDS,
 "Locate the best instance of 'pattern' in 'text' near 'loc'. Returns -1 if no match found."},
 {NULL, NULL, 0, NULL} /* Sentinel */
};

static struct PyModuleDef mymodule = {
 PyModuleDef_HEAD_INIT,
 "diff_match_patch", /* name of module */
 NULL, /* module documentation, may be NULL */
 -1, /* size of per-interpreter state of the module,
 or -1 if the module keeps state in global variables. */
 MyMethods
};

PyMODINIT_FUNC
PyInit_diff_match_patch(void)
{
 return PyModule_Create(&mymodule);
}
#endif