1 #include <stddef.h> // ptrdiff_t
2
3 #define PY_SSIZE_T_CLEAN
4 #include "parts.h"
5 #include "util.h"
6
7
8 static PyObject *
9 object_getattr(PyObject *self, PyObject *args)
10 {
11 PyObject *obj, *attr_name;
12 if (!PyArg_ParseTuple(args, "OO", &obj, &attr_name)) {
13 return NULL;
14 }
15 NULLABLE(obj);
16 NULLABLE(attr_name);
17 return PyObject_GetAttr(obj, attr_name);
18 }
19
20 static PyObject *
21 object_getattrstring(PyObject *self, PyObject *args)
22 {
23 PyObject *obj;
24 const char *attr_name;
25 Py_ssize_t size;
26 if (!PyArg_ParseTuple(args, "Oz#", &obj, &attr_name, &size)) {
27 return NULL;
28 }
29 NULLABLE(obj);
30 return PyObject_GetAttrString(obj, attr_name);
31 }
32
33 static PyObject *
34 object_hasattr(PyObject *self, PyObject *args)
35 {
36 PyObject *obj, *attr_name;
37 if (!PyArg_ParseTuple(args, "OO", &obj, &attr_name)) {
38 return NULL;
39 }
40 NULLABLE(obj);
41 NULLABLE(attr_name);
42 return PyLong_FromLong(PyObject_HasAttr(obj, attr_name));
43 }
44
45 static PyObject *
46 object_hasattrstring(PyObject *self, PyObject *args)
47 {
48 PyObject *obj;
49 const char *attr_name;
50 Py_ssize_t size;
51 if (!PyArg_ParseTuple(args, "Oz#", &obj, &attr_name, &size)) {
52 return NULL;
53 }
54 NULLABLE(obj);
55 return PyLong_FromLong(PyObject_HasAttrString(obj, attr_name));
56 }
57
58 static PyObject *
59 object_setattr(PyObject *self, PyObject *args)
60 {
61 PyObject *obj, *attr_name, *value;
62 if (!PyArg_ParseTuple(args, "OOO", &obj, &attr_name, &value)) {
63 return NULL;
64 }
65 NULLABLE(obj);
66 NULLABLE(attr_name);
67 NULLABLE(value);
68 RETURN_INT(PyObject_SetAttr(obj, attr_name, value));
69 }
70
71 static PyObject *
72 object_setattrstring(PyObject *self, PyObject *args)
73 {
74 PyObject *obj, *value;
75 const char *attr_name;
76 Py_ssize_t size;
77 if (!PyArg_ParseTuple(args, "Oz#O", &obj, &attr_name, &size, &value)) {
78 return NULL;
79 }
80 NULLABLE(obj);
81 NULLABLE(value);
82 RETURN_INT(PyObject_SetAttrString(obj, attr_name, value));
83 }
84
85 static PyObject *
86 object_delattr(PyObject *self, PyObject *args)
87 {
88 PyObject *obj, *attr_name;
89 if (!PyArg_ParseTuple(args, "OO", &obj, &attr_name)) {
90 return NULL;
91 }
92 NULLABLE(obj);
93 NULLABLE(attr_name);
94 RETURN_INT(PyObject_DelAttr(obj, attr_name));
95 }
96
97 static PyObject *
98 object_delattrstring(PyObject *self, PyObject *args)
99 {
100 PyObject *obj;
101 const char *attr_name;
102 Py_ssize_t size;
103 if (!PyArg_ParseTuple(args, "Oz#", &obj, &attr_name, &size)) {
104 return NULL;
105 }
106 NULLABLE(obj);
107 RETURN_INT(PyObject_DelAttrString(obj, attr_name));
108 }
109
110
111 static PyObject *
112 mapping_check(PyObject *self, PyObject *obj)
113 {
114 NULLABLE(obj);
115 return PyLong_FromLong(PyMapping_Check(obj));
116 }
117
118 static PyObject *
119 mapping_size(PyObject *self, PyObject *obj)
120 {
121 NULLABLE(obj);
122 RETURN_SIZE(PyMapping_Size(obj));
123 }
124
125 static PyObject *
126 mapping_length(PyObject *self, PyObject *obj)
127 {
128 NULLABLE(obj);
129 RETURN_SIZE(PyMapping_Length(obj));
130 }
131
132 static PyObject *
133 object_getitem(PyObject *self, PyObject *args)
134 {
135 PyObject *mapping, *key;
136 if (!PyArg_ParseTuple(args, "OO", &mapping, &key)) {
137 return NULL;
138 }
139 NULLABLE(mapping);
140 NULLABLE(key);
141 return PyObject_GetItem(mapping, key);
142 }
143
144 static PyObject *
145 mapping_getitemstring(PyObject *self, PyObject *args)
146 {
147 PyObject *mapping;
148 const char *key;
149 Py_ssize_t size;
150 if (!PyArg_ParseTuple(args, "Oz#", &mapping, &key, &size)) {
151 return NULL;
152 }
153 NULLABLE(mapping);
154 return PyMapping_GetItemString(mapping, key);
155 }
156
157 static PyObject *
158 mapping_haskey(PyObject *self, PyObject *args)
159 {
160 PyObject *mapping, *key;
161 if (!PyArg_ParseTuple(args, "OO", &mapping, &key)) {
162 return NULL;
163 }
164 NULLABLE(mapping);
165 NULLABLE(key);
166 return PyLong_FromLong(PyMapping_HasKey(mapping, key));
167 }
168
169 static PyObject *
170 mapping_haskeystring(PyObject *self, PyObject *args)
171 {
172 PyObject *mapping;
173 const char *key;
174 Py_ssize_t size;
175 if (!PyArg_ParseTuple(args, "Oz#", &mapping, &key, &size)) {
176 return NULL;
177 }
178 NULLABLE(mapping);
179 return PyLong_FromLong(PyMapping_HasKeyString(mapping, key));
180 }
181
182 static PyObject *
183 object_setitem(PyObject *self, PyObject *args)
184 {
185 PyObject *mapping, *key, *value;
186 if (!PyArg_ParseTuple(args, "OOO", &mapping, &key, &value)) {
187 return NULL;
188 }
189 NULLABLE(mapping);
190 NULLABLE(key);
191 NULLABLE(value);
192 RETURN_INT(PyObject_SetItem(mapping, key, value));
193 }
194
195 static PyObject *
196 mapping_setitemstring(PyObject *self, PyObject *args)
197 {
198 PyObject *mapping, *value;
199 const char *key;
200 Py_ssize_t size;
201 if (!PyArg_ParseTuple(args, "Oz#O", &mapping, &key, &size, &value)) {
202 return NULL;
203 }
204 NULLABLE(mapping);
205 NULLABLE(value);
206 RETURN_INT(PyMapping_SetItemString(mapping, key, value));
207 }
208
209 static PyObject *
210 object_delitem(PyObject *self, PyObject *args)
211 {
212 PyObject *mapping, *key;
213 if (!PyArg_ParseTuple(args, "OO", &mapping, &key)) {
214 return NULL;
215 }
216 NULLABLE(mapping);
217 NULLABLE(key);
218 RETURN_INT(PyObject_DelItem(mapping, key));
219 }
220
221 static PyObject *
222 mapping_delitem(PyObject *self, PyObject *args)
223 {
224 PyObject *mapping, *key;
225 if (!PyArg_ParseTuple(args, "OO", &mapping, &key)) {
226 return NULL;
227 }
228 NULLABLE(mapping);
229 NULLABLE(key);
230 RETURN_INT(PyMapping_DelItem(mapping, key));
231 }
232
233 static PyObject *
234 mapping_delitemstring(PyObject *self, PyObject *args)
235 {
236 PyObject *mapping;
237 const char *key;
238 Py_ssize_t size;
239 if (!PyArg_ParseTuple(args, "Oz#", &mapping, &key, &size)) {
240 return NULL;
241 }
242 NULLABLE(mapping);
243 RETURN_INT(PyMapping_DelItemString(mapping, key));
244 }
245
246 static PyObject *
247 mapping_keys(PyObject *self, PyObject *obj)
248 {
249 NULLABLE(obj);
250 return PyMapping_Keys(obj);
251 }
252
253 static PyObject *
254 mapping_values(PyObject *self, PyObject *obj)
255 {
256 NULLABLE(obj);
257 return PyMapping_Values(obj);
258 }
259
260 static PyObject *
261 mapping_items(PyObject *self, PyObject *obj)
262 {
263 NULLABLE(obj);
264 return PyMapping_Items(obj);
265 }
266
267
268 static PyObject *
269 sequence_check(PyObject* self, PyObject *obj)
270 {
271 NULLABLE(obj);
272 return PyLong_FromLong(PySequence_Check(obj));
273 }
274
275 static PyObject *
276 sequence_size(PyObject* self, PyObject *obj)
277 {
278 NULLABLE(obj);
279 RETURN_SIZE(PySequence_Size(obj));
280 }
281
282 static PyObject *
283 sequence_length(PyObject* self, PyObject *obj)
284 {
285 NULLABLE(obj);
286 RETURN_SIZE(PySequence_Length(obj));
287 }
288
289 static PyObject *
290 sequence_concat(PyObject *self, PyObject *args)
291 {
292 PyObject *seq1, *seq2;
293 if (!PyArg_ParseTuple(args, "OO", &seq1, &seq2)) {
294 return NULL;
295 }
296 NULLABLE(seq1);
297 NULLABLE(seq2);
298
299 return PySequence_Concat(seq1, seq2);
300 }
301
302 static PyObject *
303 sequence_repeat(PyObject *self, PyObject *args)
304 {
305 PyObject *seq;
306 Py_ssize_t count;
307 if (!PyArg_ParseTuple(args, "On", &seq, &count)) {
308 return NULL;
309 }
310 NULLABLE(seq);
311
312 return PySequence_Repeat(seq, count);
313 }
314
315 static PyObject *
316 sequence_inplaceconcat(PyObject *self, PyObject *args)
317 {
318 PyObject *seq1, *seq2;
319 if (!PyArg_ParseTuple(args, "OO", &seq1, &seq2)) {
320 return NULL;
321 }
322 NULLABLE(seq1);
323 NULLABLE(seq2);
324
325 return PySequence_InPlaceConcat(seq1, seq2);
326 }
327
328 static PyObject *
329 sequence_inplacerepeat(PyObject *self, PyObject *args)
330 {
331 PyObject *seq;
332 Py_ssize_t count;
333 if (!PyArg_ParseTuple(args, "On", &seq, &count)) {
334 return NULL;
335 }
336 NULLABLE(seq);
337
338 return PySequence_InPlaceRepeat(seq, count);
339 }
340
341 static PyObject *
342 sequence_getitem(PyObject *self, PyObject *args)
343 {
344 PyObject *seq;
345 Py_ssize_t i;
346 if (!PyArg_ParseTuple(args, "On", &seq, &i)) {
347 return NULL;
348 }
349 NULLABLE(seq);
350
351 return PySequence_GetItem(seq, i);
352 }
353
354 static PyObject *
355 sequence_setitem(PyObject *self, PyObject *args)
356 {
357 Py_ssize_t i;
358 PyObject *seq, *val;
359 if (!PyArg_ParseTuple(args, "OnO", &seq, &i, &val)) {
360 return NULL;
361 }
362 NULLABLE(seq);
363 NULLABLE(val);
364
365 RETURN_INT(PySequence_SetItem(seq, i, val));
366 }
367
368
369 static PyObject *
370 sequence_delitem(PyObject *self, PyObject *args)
371 {
372 Py_ssize_t i;
373 PyObject *seq;
374 if (!PyArg_ParseTuple(args, "On", &seq, &i)) {
375 return NULL;
376 }
377 NULLABLE(seq);
378
379 RETURN_INT(PySequence_DelItem(seq, i));
380 }
381
382 static PyObject *
383 sequence_setslice(PyObject* self, PyObject *args)
384 {
385 PyObject *sequence, *obj;
386 Py_ssize_t i1, i2;
387 if (!PyArg_ParseTuple(args, "OnnO", &sequence, &i1, &i2, &obj)) {
388 return NULL;
389 }
390 NULLABLE(sequence);
391 NULLABLE(obj);
392
393 RETURN_INT(PySequence_SetSlice(sequence, i1, i2, obj));
394 }
395
396 static PyObject *
397 sequence_delslice(PyObject *self, PyObject *args)
398 {
399 PyObject *sequence;
400 Py_ssize_t i1, i2;
401 if (!PyArg_ParseTuple(args, "Onn", &sequence, &i1, &i2)) {
402 return NULL;
403 }
404 NULLABLE(sequence);
405
406 RETURN_INT(PySequence_DelSlice(sequence, i1, i2));
407 }
408
409 static PyObject *
410 sequence_count(PyObject *self, PyObject *args)
411 {
412 PyObject *seq, *value;
413 if (!PyArg_ParseTuple(args, "OO", &seq, &value)) {
414 return NULL;
415 }
416 NULLABLE(seq);
417 NULLABLE(value);
418
419 RETURN_SIZE(PySequence_Count(seq, value));
420 }
421
422 static PyObject *
423 sequence_contains(PyObject *self, PyObject *args)
424 {
425 PyObject *seq, *value;
426 if (!PyArg_ParseTuple(args, "OO", &seq, &value)) {
427 return NULL;
428 }
429 NULLABLE(seq);
430 NULLABLE(value);
431
432 RETURN_INT(PySequence_Contains(seq, value));
433 }
434
435 static PyObject *
436 sequence_index(PyObject *self, PyObject *args)
437 {
438 PyObject *seq, *value;
439 if (!PyArg_ParseTuple(args, "OO", &seq, &value)) {
440 return NULL;
441 }
442 NULLABLE(seq);
443 NULLABLE(value);
444
445 RETURN_SIZE(PySequence_Index(seq, value));
446 }
447
448 static PyObject *
449 sequence_list(PyObject *self, PyObject *obj)
450 {
451 NULLABLE(obj);
452 return PySequence_List(obj);
453 }
454
455 static PyObject *
456 sequence_tuple(PyObject *self, PyObject *obj)
457 {
458 NULLABLE(obj);
459 return PySequence_Tuple(obj);
460 }
461
462
463 static PyMethodDef test_methods[] = {
464 {"object_getattr", object_getattr, METH_VARARGS},
465 {"object_getattrstring", object_getattrstring, METH_VARARGS},
466 {"object_hasattr", object_hasattr, METH_VARARGS},
467 {"object_hasattrstring", object_hasattrstring, METH_VARARGS},
468 {"object_setattr", object_setattr, METH_VARARGS},
469 {"object_setattrstring", object_setattrstring, METH_VARARGS},
470 {"object_delattr", object_delattr, METH_VARARGS},
471 {"object_delattrstring", object_delattrstring, METH_VARARGS},
472
473 {"mapping_check", mapping_check, METH_O},
474 {"mapping_size", mapping_size, METH_O},
475 {"mapping_length", mapping_length, METH_O},
476 {"object_getitem", object_getitem, METH_VARARGS},
477 {"mapping_getitemstring", mapping_getitemstring, METH_VARARGS},
478 {"mapping_haskey", mapping_haskey, METH_VARARGS},
479 {"mapping_haskeystring", mapping_haskeystring, METH_VARARGS},
480 {"object_setitem", object_setitem, METH_VARARGS},
481 {"mapping_setitemstring", mapping_setitemstring, METH_VARARGS},
482 {"object_delitem", object_delitem, METH_VARARGS},
483 {"mapping_delitem", mapping_delitem, METH_VARARGS},
484 {"mapping_delitemstring", mapping_delitemstring, METH_VARARGS},
485 {"mapping_keys", mapping_keys, METH_O},
486 {"mapping_values", mapping_values, METH_O},
487 {"mapping_items", mapping_items, METH_O},
488
489 {"sequence_check", sequence_check, METH_O},
490 {"sequence_size", sequence_size, METH_O},
491 {"sequence_length", sequence_length, METH_O},
492 {"sequence_concat", sequence_concat, METH_VARARGS},
493 {"sequence_repeat", sequence_repeat, METH_VARARGS},
494 {"sequence_inplaceconcat", sequence_inplaceconcat, METH_VARARGS},
495 {"sequence_inplacerepeat", sequence_inplacerepeat, METH_VARARGS},
496 {"sequence_getitem", sequence_getitem, METH_VARARGS},
497 {"sequence_setitem", sequence_setitem, METH_VARARGS},
498 {"sequence_delitem", sequence_delitem, METH_VARARGS},
499 {"sequence_setslice", sequence_setslice, METH_VARARGS},
500 {"sequence_delslice", sequence_delslice, METH_VARARGS},
501 {"sequence_count", sequence_count, METH_VARARGS},
502 {"sequence_contains", sequence_contains, METH_VARARGS},
503 {"sequence_index", sequence_index, METH_VARARGS},
504 {"sequence_list", sequence_list, METH_O},
505 {"sequence_tuple", sequence_tuple, METH_O},
506
507 {NULL},
508 };
509
510 int
511 _PyTestCapi_Init_Abstract(PyObject *m)
512 {
513 if (PyModule_AddFunctions(m, test_methods) < 0) {
514 return -1;
515 }
516
517 return 0;
518 }