mirror of
https://github.com/janeczku/calibre-web
synced 2024-08-31 13:32:49 +00:00
240 lines
5.8 KiB
C
240 lines
5.8 KiB
C
/**
|
|
* markupsafe._speedups
|
|
* ~~~~~~~~~~~~~~~~~~~~
|
|
*
|
|
* This module implements functions for automatic escaping in C for better
|
|
* performance.
|
|
*
|
|
* :copyright: (c) 2010 by Armin Ronacher.
|
|
* :license: BSD.
|
|
*/
|
|
|
|
#include <Python.h>
|
|
|
|
#define ESCAPED_CHARS_TABLE_SIZE 63
|
|
#define UNICHR(x) (PyUnicode_AS_UNICODE((PyUnicodeObject*)PyUnicode_DecodeASCII(x, strlen(x), NULL)));
|
|
|
|
#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
|
|
typedef int Py_ssize_t;
|
|
#define PY_SSIZE_T_MAX INT_MAX
|
|
#define PY_SSIZE_T_MIN INT_MIN
|
|
#endif
|
|
|
|
|
|
static PyObject* markup;
|
|
static Py_ssize_t escaped_chars_delta_len[ESCAPED_CHARS_TABLE_SIZE];
|
|
static Py_UNICODE *escaped_chars_repl[ESCAPED_CHARS_TABLE_SIZE];
|
|
|
|
static int
|
|
init_constants(void)
|
|
{
|
|
PyObject *module;
|
|
/* happing of characters to replace */
|
|
escaped_chars_repl['"'] = UNICHR(""");
|
|
escaped_chars_repl['\''] = UNICHR("'");
|
|
escaped_chars_repl['&'] = UNICHR("&");
|
|
escaped_chars_repl['<'] = UNICHR("<");
|
|
escaped_chars_repl['>'] = UNICHR(">");
|
|
|
|
/* lengths of those characters when replaced - 1 */
|
|
memset(escaped_chars_delta_len, 0, sizeof (escaped_chars_delta_len));
|
|
escaped_chars_delta_len['"'] = escaped_chars_delta_len['\''] = \
|
|
escaped_chars_delta_len['&'] = 4;
|
|
escaped_chars_delta_len['<'] = escaped_chars_delta_len['>'] = 3;
|
|
|
|
/* import markup type so that we can mark the return value */
|
|
module = PyImport_ImportModule("markupsafe");
|
|
if (!module)
|
|
return 0;
|
|
markup = PyObject_GetAttrString(module, "Markup");
|
|
Py_DECREF(module);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static PyObject*
|
|
escape_unicode(PyUnicodeObject *in)
|
|
{
|
|
PyUnicodeObject *out;
|
|
Py_UNICODE *inp = PyUnicode_AS_UNICODE(in);
|
|
const Py_UNICODE *inp_end = PyUnicode_AS_UNICODE(in) + PyUnicode_GET_SIZE(in);
|
|
Py_UNICODE *next_escp;
|
|
Py_UNICODE *outp;
|
|
Py_ssize_t delta=0, erepl=0, delta_len=0;
|
|
|
|
/* First we need to figure out how long the escaped string will be */
|
|
while (*(inp) || inp < inp_end) {
|
|
if (*inp < ESCAPED_CHARS_TABLE_SIZE) {
|
|
delta += escaped_chars_delta_len[*inp];
|
|
erepl += !!escaped_chars_delta_len[*inp];
|
|
}
|
|
++inp;
|
|
}
|
|
|
|
/* Do we need to escape anything at all? */
|
|
if (!erepl) {
|
|
Py_INCREF(in);
|
|
return (PyObject*)in;
|
|
}
|
|
|
|
out = (PyUnicodeObject*)PyUnicode_FromUnicode(NULL, PyUnicode_GET_SIZE(in) + delta);
|
|
if (!out)
|
|
return NULL;
|
|
|
|
outp = PyUnicode_AS_UNICODE(out);
|
|
inp = PyUnicode_AS_UNICODE(in);
|
|
while (erepl-- > 0) {
|
|
/* look for the next substitution */
|
|
next_escp = inp;
|
|
while (next_escp < inp_end) {
|
|
if (*next_escp < ESCAPED_CHARS_TABLE_SIZE &&
|
|
(delta_len = escaped_chars_delta_len[*next_escp])) {
|
|
++delta_len;
|
|
break;
|
|
}
|
|
++next_escp;
|
|
}
|
|
|
|
if (next_escp > inp) {
|
|
/* copy unescaped chars between inp and next_escp */
|
|
Py_UNICODE_COPY(outp, inp, next_escp-inp);
|
|
outp += next_escp - inp;
|
|
}
|
|
|
|
/* escape 'next_escp' */
|
|
Py_UNICODE_COPY(outp, escaped_chars_repl[*next_escp], delta_len);
|
|
outp += delta_len;
|
|
|
|
inp = next_escp + 1;
|
|
}
|
|
if (inp < inp_end)
|
|
Py_UNICODE_COPY(outp, inp, PyUnicode_GET_SIZE(in) - (inp - PyUnicode_AS_UNICODE(in)));
|
|
|
|
return (PyObject*)out;
|
|
}
|
|
|
|
|
|
static PyObject*
|
|
escape(PyObject *self, PyObject *text)
|
|
{
|
|
PyObject *s = NULL, *rv = NULL, *html;
|
|
|
|
/* we don't have to escape integers, bools or floats */
|
|
if (PyLong_CheckExact(text) ||
|
|
#if PY_MAJOR_VERSION < 3
|
|
PyInt_CheckExact(text) ||
|
|
#endif
|
|
PyFloat_CheckExact(text) || PyBool_Check(text) ||
|
|
text == Py_None)
|
|
return PyObject_CallFunctionObjArgs(markup, text, NULL);
|
|
|
|
/* if the object has an __html__ method that performs the escaping */
|
|
html = PyObject_GetAttrString(text, "__html__");
|
|
if (html) {
|
|
rv = PyObject_CallObject(html, NULL);
|
|
Py_DECREF(html);
|
|
return rv;
|
|
}
|
|
|
|
/* otherwise make the object unicode if it isn't, then escape */
|
|
PyErr_Clear();
|
|
if (!PyUnicode_Check(text)) {
|
|
#if PY_MAJOR_VERSION < 3
|
|
PyObject *unicode = PyObject_Unicode(text);
|
|
#else
|
|
PyObject *unicode = PyObject_Str(text);
|
|
#endif
|
|
if (!unicode)
|
|
return NULL;
|
|
s = escape_unicode((PyUnicodeObject*)unicode);
|
|
Py_DECREF(unicode);
|
|
}
|
|
else
|
|
s = escape_unicode((PyUnicodeObject*)text);
|
|
|
|
/* convert the unicode string into a markup object. */
|
|
rv = PyObject_CallFunctionObjArgs(markup, (PyObject*)s, NULL);
|
|
Py_DECREF(s);
|
|
return rv;
|
|
}
|
|
|
|
|
|
static PyObject*
|
|
escape_silent(PyObject *self, PyObject *text)
|
|
{
|
|
if (text != Py_None)
|
|
return escape(self, text);
|
|
return PyObject_CallFunctionObjArgs(markup, NULL);
|
|
}
|
|
|
|
|
|
static PyObject*
|
|
soft_unicode(PyObject *self, PyObject *s)
|
|
{
|
|
if (!PyUnicode_Check(s))
|
|
#if PY_MAJOR_VERSION < 3
|
|
return PyObject_Unicode(s);
|
|
#else
|
|
return PyObject_Str(s);
|
|
#endif
|
|
Py_INCREF(s);
|
|
return s;
|
|
}
|
|
|
|
|
|
static PyMethodDef module_methods[] = {
|
|
{"escape", (PyCFunction)escape, METH_O,
|
|
"escape(s) -> markup\n\n"
|
|
"Convert the characters &, <, >, ', and \" in string s to HTML-safe\n"
|
|
"sequences. Use this if you need to display text that might contain\n"
|
|
"such characters in HTML. Marks return value as markup string."},
|
|
{"escape_silent", (PyCFunction)escape_silent, METH_O,
|
|
"escape_silent(s) -> markup\n\n"
|
|
"Like escape but converts None to an empty string."},
|
|
{"soft_unicode", (PyCFunction)soft_unicode, METH_O,
|
|
"soft_unicode(object) -> string\n\n"
|
|
"Make a string unicode if it isn't already. That way a markup\n"
|
|
"string is not converted back to unicode."},
|
|
{NULL, NULL, 0, NULL} /* Sentinel */
|
|
};
|
|
|
|
|
|
#if PY_MAJOR_VERSION < 3
|
|
|
|
#ifndef PyMODINIT_FUNC /* declarations for DLL import/export */
|
|
#define PyMODINIT_FUNC void
|
|
#endif
|
|
PyMODINIT_FUNC
|
|
init_speedups(void)
|
|
{
|
|
if (!init_constants())
|
|
return;
|
|
|
|
Py_InitModule3("markupsafe._speedups", module_methods, "");
|
|
}
|
|
|
|
#else /* Python 3.x module initialization */
|
|
|
|
static struct PyModuleDef module_definition = {
|
|
PyModuleDef_HEAD_INIT,
|
|
"markupsafe._speedups",
|
|
NULL,
|
|
-1,
|
|
module_methods,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
PyMODINIT_FUNC
|
|
PyInit__speedups(void)
|
|
{
|
|
if (!init_constants())
|
|
return NULL;
|
|
|
|
return PyModule_Create(&module_definition);
|
|
}
|
|
|
|
#endif
|