Rename WebKitTools to Tools
[WebKit-https.git] / Tools / Scripts / webkitpy / thirdparty / simplejson / _speedups.c
1 #include "Python.h"
2 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
3 typedef int Py_ssize_t;
4 #define PY_SSIZE_T_MAX INT_MAX
5 #define PY_SSIZE_T_MIN INT_MIN
6 #endif
7
8 static Py_ssize_t
9 ascii_escape_char(Py_UNICODE c, char *output, Py_ssize_t chars);
10 static PyObject *
11 ascii_escape_unicode(PyObject *pystr);
12 static PyObject *
13 ascii_escape_str(PyObject *pystr);
14 static PyObject *
15 py_encode_basestring_ascii(PyObject* self __attribute__((__unused__)), PyObject *pystr);
16 void init_speedups(void);
17
18 #define S_CHAR(c) (c >= ' ' && c <= '~' && c != '\\' && c != '/' && c != '"')
19
20 #define MIN_EXPANSION 6
21 #ifdef Py_UNICODE_WIDE
22 #define MAX_EXPANSION (2 * MIN_EXPANSION)
23 #else
24 #define MAX_EXPANSION MIN_EXPANSION
25 #endif
26
27 static Py_ssize_t
28 ascii_escape_char(Py_UNICODE c, char *output, Py_ssize_t chars) {
29     Py_UNICODE x;
30     output[chars++] = '\\';
31     switch (c) {
32         case '/': output[chars++] = (char)c; break;
33         case '\\': output[chars++] = (char)c; break;
34         case '"': output[chars++] = (char)c; break;
35         case '\b': output[chars++] = 'b'; break;
36         case '\f': output[chars++] = 'f'; break;
37         case '\n': output[chars++] = 'n'; break;
38         case '\r': output[chars++] = 'r'; break;
39         case '\t': output[chars++] = 't'; break;
40         default:
41 #ifdef Py_UNICODE_WIDE
42             if (c >= 0x10000) {
43                 /* UTF-16 surrogate pair */
44                 Py_UNICODE v = c - 0x10000;
45                 c = 0xd800 | ((v >> 10) & 0x3ff);
46                 output[chars++] = 'u';
47                 x = (c & 0xf000) >> 12;
48                 output[chars++] = (x < 10) ? '0' + x : 'a' + (x - 10);
49                 x = (c & 0x0f00) >> 8;
50                 output[chars++] = (x < 10) ? '0' + x : 'a' + (x - 10);
51                 x = (c & 0x00f0) >> 4;
52                 output[chars++] = (x < 10) ? '0' + x : 'a' + (x - 10);
53                 x = (c & 0x000f);
54                 output[chars++] = (x < 10) ? '0' + x : 'a' + (x - 10);
55                 c = 0xdc00 | (v & 0x3ff);
56                 output[chars++] = '\\';
57             }
58 #endif
59             output[chars++] = 'u';
60             x = (c & 0xf000) >> 12;
61             output[chars++] = (x < 10) ? '0' + x : 'a' + (x - 10);
62             x = (c & 0x0f00) >> 8;
63             output[chars++] = (x < 10) ? '0' + x : 'a' + (x - 10);
64             x = (c & 0x00f0) >> 4;
65             output[chars++] = (x < 10) ? '0' + x : 'a' + (x - 10);
66             x = (c & 0x000f);
67             output[chars++] = (x < 10) ? '0' + x : 'a' + (x - 10);
68     }
69     return chars;
70 }
71
72 static PyObject *
73 ascii_escape_unicode(PyObject *pystr) {
74     Py_ssize_t i;
75     Py_ssize_t input_chars;
76     Py_ssize_t output_size;
77     Py_ssize_t chars;
78     PyObject *rval;
79     char *output;
80     Py_UNICODE *input_unicode;
81
82     input_chars = PyUnicode_GET_SIZE(pystr);
83     input_unicode = PyUnicode_AS_UNICODE(pystr);
84     /* One char input can be up to 6 chars output, estimate 4 of these */
85     output_size = 2 + (MIN_EXPANSION * 4) + input_chars;
86     rval = PyString_FromStringAndSize(NULL, output_size);
87     if (rval == NULL) {
88         return NULL;
89     }
90     output = PyString_AS_STRING(rval);
91     chars = 0;
92     output[chars++] = '"';
93     for (i = 0; i < input_chars; i++) {
94         Py_UNICODE c = input_unicode[i];
95         if (S_CHAR(c)) {
96             output[chars++] = (char)c;
97         } else {
98             chars = ascii_escape_char(c, output, chars);
99         }
100         if (output_size - chars < (1 + MAX_EXPANSION)) {
101             /* There's more than four, so let's resize by a lot */
102             output_size *= 2;
103             /* This is an upper bound */
104             if (output_size > 2 + (input_chars * MAX_EXPANSION)) {
105                 output_size = 2 + (input_chars * MAX_EXPANSION);
106             }
107             if (_PyString_Resize(&rval, output_size) == -1) {
108                 return NULL;
109             }
110             output = PyString_AS_STRING(rval);
111         }
112     }
113     output[chars++] = '"';
114     if (_PyString_Resize(&rval, chars) == -1) {
115         return NULL;
116     }
117     return rval;
118 }
119
120 static PyObject *
121 ascii_escape_str(PyObject *pystr) {
122     Py_ssize_t i;
123     Py_ssize_t input_chars;
124     Py_ssize_t output_size;
125     Py_ssize_t chars;
126     PyObject *rval;
127     char *output;
128     char *input_str;
129
130     input_chars = PyString_GET_SIZE(pystr);
131     input_str = PyString_AS_STRING(pystr);
132     /* One char input can be up to 6 chars output, estimate 4 of these */
133     output_size = 2 + (MIN_EXPANSION * 4) + input_chars;
134     rval = PyString_FromStringAndSize(NULL, output_size);
135     if (rval == NULL) {
136         return NULL;
137     }
138     output = PyString_AS_STRING(rval);
139     chars = 0;
140     output[chars++] = '"';
141     for (i = 0; i < input_chars; i++) {
142         Py_UNICODE c = (Py_UNICODE)input_str[i];
143         if (S_CHAR(c)) {
144             output[chars++] = (char)c;
145         } else if (c > 0x7F) {
146             /* We hit a non-ASCII character, bail to unicode mode */
147             PyObject *uni;
148             Py_DECREF(rval);
149             uni = PyUnicode_DecodeUTF8(input_str, input_chars, "strict");
150             if (uni == NULL) {
151                 return NULL;
152             }
153             rval = ascii_escape_unicode(uni);
154             Py_DECREF(uni);
155             return rval;
156         } else {
157             chars = ascii_escape_char(c, output, chars);
158         }
159         /* An ASCII char can't possibly expand to a surrogate! */
160         if (output_size - chars < (1 + MIN_EXPANSION)) {
161             /* There's more than four, so let's resize by a lot */
162             output_size *= 2;
163             if (output_size > 2 + (input_chars * MIN_EXPANSION)) {
164                 output_size = 2 + (input_chars * MIN_EXPANSION);
165             }
166             if (_PyString_Resize(&rval, output_size) == -1) {
167                 return NULL;
168             }
169             output = PyString_AS_STRING(rval);
170         }
171     }
172     output[chars++] = '"';
173     if (_PyString_Resize(&rval, chars) == -1) {
174         return NULL;
175     }
176     return rval;
177 }
178
179 PyDoc_STRVAR(pydoc_encode_basestring_ascii,
180     "encode_basestring_ascii(basestring) -> str\n"
181     "\n"
182     "..."
183 );
184
185 static PyObject *
186 py_encode_basestring_ascii(PyObject* self __attribute__((__unused__)), PyObject *pystr) {
187     /* METH_O */
188     if (PyString_Check(pystr)) {
189         return ascii_escape_str(pystr);
190     } else if (PyUnicode_Check(pystr)) {
191         return ascii_escape_unicode(pystr);
192     }
193     PyErr_SetString(PyExc_TypeError, "first argument must be a string");
194     return NULL;
195 }
196
197 #define DEFN(n, k) \
198     {  \
199         #n, \
200         (PyCFunction)py_ ##n, \
201         k, \
202         pydoc_ ##n \
203     }
204 static PyMethodDef speedups_methods[] = {
205     DEFN(encode_basestring_ascii, METH_O),
206     {}
207 };
208 #undef DEFN
209
210 void
211 init_speedups(void)
212 {
213     PyObject *m;
214     m = Py_InitModule4("_speedups", speedups_methods, NULL, NULL, PYTHON_API_VERSION);
215 }