« back to all changes in this revision
Viewing changes to Python/getargs.c
- browse files at revision 15
- compare with another revision
- download diff
- download tarball
- view history from revision 15
- Committer: Bazaar Package Importer
- Author(s): Matthias Klose
- Date: 2010-07-06 16:52:42 UTC
- mfrom: (1.2.1 upstream) (2.1.11 sid)
- Revision ID: james.westby@ubuntu.com-20100706165242-2xv4i019r3et6c0j
Tags: 3.1.2+20100706-1ubuntu1
* Merge with Debian; remaining changes:
- Regenerate the control file.
- Add debian/patches/overwrite-semaphore-check for Lucid buildds.
- Regenerate the control file.
- Add debian/patches/overwrite-semaphore-check for Lucid buildds.
- files added:
- Lib/distutils/tests/test_log.py
- debian/source
- files removed:
- debian/PVER-dbg.symbols.i386.in
- files modified:
- Demo/embed/demo.c
added
removed
Python/getargs.c
14
14
int PyArg_VaParse(PyObject *, const char *, va_list);
15
15
16
16
int PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
17
const char *, char **, ...);
17
const char *, char **, ...);
18
18
int PyArg_VaParseTupleAndKeywords(PyObject *, PyObject *,
19
const char *, char **, va_list);
19
const char *, char **, va_list);
20
20
21
21
#ifdef HAVE_DECLSPEC_DLL
22
22
/* Export functions */
40
40
static char *convertitem(PyObject *, const char **, va_list *, int, int *,
41
41
char *, size_t, PyObject **);
42
42
static char *converttuple(PyObject *, const char **, va_list *, int,
43
int *, char *, size_t, int, PyObject **);
43
int *, char *, size_t, int, PyObject **);
44
44
static char *convertsimple(PyObject *, const char **, va_list *, int, char *,
45
size_t, PyObject **);
45
size_t, PyObject **);
46
46
static Py_ssize_t convertbuffer(PyObject *, void **p, char **);
47
47
static int getbuffer(PyObject *, Py_buffer *, char**);
48
48
49
49
static int vgetargskeywords(PyObject *, PyObject *,
50
const char *, char **, va_list *, int);
50
const char *, char **, va_list *, int);
51
51
static char *skipitem(const char **, va_list *, int);
52
52
53
53
int
54
54
PyArg_Parse(PyObject *args, const char *format, ...)
55
55
{
56
int retval;
57
va_list va;
56
int retval;
57
va_list va;
58
58
59
va_start(va, format);
60
retval = vgetargs1(args, format, &va, FLAG_COMPAT);
61
va_end(va);
62
return retval;
59
va_start(va, format);
60
retval = vgetargs1(args, format, &va, FLAG_COMPAT);
61
va_end(va);
62
return retval;
63
63
}
64
64
65
65
int
66
66
_PyArg_Parse_SizeT(PyObject *args, char *format, ...)
67
67
{
68
int retval;
69
va_list va;
68
int retval;
69
va_list va;
70
70
71
va_start(va, format);
72
retval = vgetargs1(args, format, &va, FLAG_COMPAT|FLAG_SIZE_T);
73
va_end(va);
74
return retval;
71
va_start(va, format);
72
retval = vgetargs1(args, format, &va, FLAG_COMPAT|FLAG_SIZE_T);
73
va_end(va);
74
return retval;
75
75
}
76
76
77
77
78
78
int
79
79
PyArg_ParseTuple(PyObject *args, const char *format, ...)
80
80
{
81
int retval;
82
va_list va;
81
int retval;
82
va_list va;
83
83
84
va_start(va, format);
85
retval = vgetargs1(args, format, &va, 0);
86
va_end(va);
87
return retval;
84
va_start(va, format);
85
retval = vgetargs1(args, format, &va, 0);
86
va_end(va);
87
return retval;
88
88
}
89
89
90
90
int
91
91
_PyArg_ParseTuple_SizeT(PyObject *args, char *format, ...)
92
92
{
93
int retval;
94
va_list va;
93
int retval;
94
va_list va;
95
95
96
va_start(va, format);
97
retval = vgetargs1(args, format, &va, FLAG_SIZE_T);
98
va_end(va);
99
return retval;
96
va_start(va, format);
97
retval = vgetargs1(args, format, &va, FLAG_SIZE_T);
98
va_end(va);
99
return retval;
100
100
}
101
101
102
102
103
103
int
104
104
PyArg_VaParse(PyObject *args, const char *format, va_list va)
105
105
{
106
va_list lva;
106
va_list lva;
107
107
108
108
#ifdef VA_LIST_IS_ARRAY
109
memcpy(lva, va, sizeof(va_list));
109
memcpy(lva, va, sizeof(va_list));
110
110
#else
111
111
#ifdef __va_copy
112
__va_copy(lva, va);
112
__va_copy(lva, va);
113
113
#else
114
lva = va;
114
lva = va;
115
115
#endif
116
116
#endif
117
117
118
return vgetargs1(args, format, &lva, 0);
118
return vgetargs1(args, format, &lva, 0);
119
119
}
120
120
121
121
int
122
122
_PyArg_VaParse_SizeT(PyObject *args, char *format, va_list va)
123
123
{
124
va_list lva;
124
va_list lva;
125
125
126
126
#ifdef VA_LIST_IS_ARRAY
127
memcpy(lva, va, sizeof(va_list));
127
memcpy(lva, va, sizeof(va_list));
128
128
#else
129
129
#ifdef __va_copy
130
__va_copy(lva, va);
130
__va_copy(lva, va);
131
131
#else
132
lva = va;
132
lva = va;
133
133
#endif
134
134
#endif
135
135
136
return vgetargs1(args, format, &lva, FLAG_SIZE_T);
136
return vgetargs1(args, format, &lva, FLAG_SIZE_T);
137
137
}
138
138
139
139
146
146
static void
147
147
cleanup_ptr(PyObject *self)
148
148
{
149
void *ptr = PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_PTR);
150
if (ptr) {
151
PyMem_FREE(ptr);
152
}
149
void *ptr = PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_PTR);
150
if (ptr) {
151
PyMem_FREE(ptr);
152
}
153
153
}
154
154
155
155
static void
156
156
cleanup_buffer(PyObject *self)
157
157
{
158
Py_buffer *ptr = (Py_buffer *)PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_BUFFER);
159
if (ptr) {
160
PyBuffer_Release(ptr);
161
}
158
Py_buffer *ptr = (Py_buffer *)PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_BUFFER);
159
if (ptr) {
160
PyBuffer_Release(ptr);
161
}
162
162
}
163
163
164
164
static int
165
165
addcleanup(void *ptr, PyObject **freelist, PyCapsule_Destructor destr)
166
166
{
167
PyObject *cobj;
168
const char *name;
169
170
if (!*freelist) {
171
*freelist = PyList_New(0);
172
if (!*freelist) {
173
destr(ptr);
174
return -1;
175
}
176
}
177
178
if (destr == cleanup_ptr) {
179
name = GETARGS_CAPSULE_NAME_CLEANUP_PTR;
180
} else if (destr == cleanup_buffer) {
181
name = GETARGS_CAPSULE_NAME_CLEANUP_BUFFER;
182
} else {
183
return -1;
184
}
185
cobj = PyCapsule_New(ptr, name, destr);
186
if (!cobj) {
187
destr(ptr);
188
return -1;
189
}
190
if (PyList_Append(*freelist, cobj)) {
191
Py_DECREF(cobj);
192
return -1;
193
}
167
PyObject *cobj;
168
const char *name;
169
170
if (!*freelist) {
171
*freelist = PyList_New(0);
172
if (!*freelist) {
173
destr(ptr);
174
return -1;
175
}
176
}
177
178
if (destr == cleanup_ptr) {
179
name = GETARGS_CAPSULE_NAME_CLEANUP_PTR;
180
} else if (destr == cleanup_buffer) {
181
name = GETARGS_CAPSULE_NAME_CLEANUP_BUFFER;
182
} else {
183
return -1;
184
}
185
cobj = PyCapsule_New(ptr, name, destr);
186
if (!cobj) {
187
destr(ptr);
188
return -1;
189
}
190
if (PyList_Append(*freelist, cobj)) {
194
191
Py_DECREF(cobj);
195
return 0;
192
return -1;
193
}
194
Py_DECREF(cobj);
195
return 0;
196
196
}
197
197
198
198
static void
199
199
cleanup_convert(PyObject *self)
200
200
{
201
typedef int (*destr_t)(PyObject *, void *);
202
destr_t destr = (destr_t)PyCapsule_GetContext(self);
203
void *ptr = PyCapsule_GetPointer(self,
204
GETARGS_CAPSULE_NAME_CLEANUP_CONVERT);
205
if (ptr && destr)
206
destr(NULL, ptr);
201
typedef int (*destr_t)(PyObject *, void *);
202
destr_t destr = (destr_t)PyCapsule_GetContext(self);
203
void *ptr = PyCapsule_GetPointer(self,
204
GETARGS_CAPSULE_NAME_CLEANUP_CONVERT);
205
if (ptr && destr)
206
destr(NULL, ptr);
207
207
}
208
208
209
209
static int
210
210
addcleanup_convert(void *ptr, PyObject **freelist, int (*destr)(PyObject*,void*))
211
211
{
212
PyObject *cobj;
213
if (!*freelist) {
214
*freelist = PyList_New(0);
215
if (!*freelist) {
216
destr(NULL, ptr);
217
return -1;
218
}
219
}
220
cobj = PyCapsule_New(ptr, GETARGS_CAPSULE_NAME_CLEANUP_CONVERT,
221
cleanup_convert);
222
if (!cobj) {
223
destr(NULL, ptr);
224
return -1;
225
}
226
if (PyCapsule_SetContext(cobj, destr) == -1) {
227
/* This really should not happen. */
228
Py_FatalError("capsule refused setting of context.");
229
}
230
if (PyList_Append(*freelist, cobj)) {
231
Py_DECREF(cobj); /* This will also call destr. */
232
return -1;
233
}
234
Py_DECREF(cobj);
235
return 0;
212
PyObject *cobj;
213
if (!*freelist) {
214
*freelist = PyList_New(0);
215
if (!*freelist) {
216
destr(NULL, ptr);
217
return -1;
218
}
219
}
220
cobj = PyCapsule_New(ptr, GETARGS_CAPSULE_NAME_CLEANUP_CONVERT,
221
cleanup_convert);
222
if (!cobj) {
223
destr(NULL, ptr);
224
return -1;
225
}
226
if (PyCapsule_SetContext(cobj, destr) == -1) {
227
/* This really should not happen. */
228
Py_FatalError("capsule refused setting of context.");
229
}
230
if (PyList_Append(*freelist, cobj)) {
231
Py_DECREF(cobj); /* This will also call destr. */
232
return -1;
233
}
234
Py_DECREF(cobj);
235
return 0;
236
236
}
237
237
238
238
static int
239
239
cleanreturn(int retval, PyObject *freelist)
240
240
{
241
if (freelist && retval != 0) {
242
/* We were successful, reset the destructors so that they
243
don't get called. */
244
Py_ssize_t len = PyList_GET_SIZE(freelist), i;
245
for (i = 0; i < len; i++)
246
PyCapsule_SetDestructor(PyList_GET_ITEM(freelist, i), NULL);
247
}
248
Py_XDECREF(freelist);
249
return retval;
241
if (freelist && retval != 0) {
242
/* We were successful, reset the destructors so that they
243
don't get called. */
244
Py_ssize_t len = PyList_GET_SIZE(freelist), i;
245
for (i = 0; i < len; i++)
246
PyCapsule_SetDestructor(PyList_GET_ITEM(freelist, i), NULL);
247
}
248
Py_XDECREF(freelist);
249
return retval;
250
250
}
251
251
252
252
253
253
static int
254
254
vgetargs1(PyObject *args, const char *format, va_list *p_va, int flags)
255
255
{
256
char msgbuf[256];
257
int levels[32];
258
const char *fname = NULL;
259
const char *message = NULL;
260
int min = -1;
261
int max = 0;
262
int level = 0;
263
int endfmt = 0;
264
const char *formatsave = format;
265
Py_ssize_t i, len;
266
char *msg;
267
PyObject *freelist = NULL;
268
int compat = flags & FLAG_COMPAT;
269
270
assert(compat || (args != (PyObject*)NULL));
271
flags = flags & ~FLAG_COMPAT;
272
273
while (endfmt == 0) {
274
int c = *format++;
275
switch (c) {
276
case '(':
277
if (level == 0)
278
max++;
279
level++;
280
if (level >= 30)
281
Py_FatalError("too many tuple nesting levels "
282
"in argument format string");
283
break;
284
case ')':
285
if (level == 0)
286
Py_FatalError("excess ')' in getargs format");
287
else
288
level--;
289
break;
290
case '\0':
291
endfmt = 1;
292
break;
293
case ':':
294
fname = format;
295
endfmt = 1;
296
break;
297
case ';':
298
message = format;
299
endfmt = 1;
300
break;
301
default:
302
if (level == 0) {
303
if (c == 'O')
304
max++;
305
else if (isalpha(Py_CHARMASK(c))) {
306
if (c != 'e') /* skip encoded */
307
max++;
308
} else if (c == '|')
309
min = max;
310
}
311
break;
312
}
313
}
314
315
if (level != 0)
316
Py_FatalError(/* '(' */ "missing ')' in getargs format");
317
318
if (min < 0)
319
min = max;
320
321
format = formatsave;
322
323
if (compat) {
324
if (max == 0) {
325
if (args == NULL)
326
return 1;
327
PyOS_snprintf(msgbuf, sizeof(msgbuf),
328
"%.200s%s takes no arguments",
329
fname==NULL ? "function" : fname,
330
fname==NULL ? "" : "()");
331
PyErr_SetString(PyExc_TypeError, msgbuf);
332
return 0;
333
}
334
else if (min == 1 && max == 1) {
335
if (args == NULL) {
336
PyOS_snprintf(msgbuf, sizeof(msgbuf),
337
"%.200s%s takes at least one argument",
338
fname==NULL ? "function" : fname,
339
fname==NULL ? "" : "()");
340
PyErr_SetString(PyExc_TypeError, msgbuf);
341
return 0;
342
}
343
msg = convertitem(args, &format, p_va, flags, levels,
344
msgbuf, sizeof(msgbuf), &freelist);
345
if (msg == NULL)
346
return cleanreturn(1, freelist);
347
seterror(levels[0], msg, levels+1, fname, message);
348
return cleanreturn(0, freelist);
349
}
350
else {
351
PyErr_SetString(PyExc_SystemError,
352
"old style getargs format uses new features");
353
return 0;
354
}
355
}
356
357
if (!PyTuple_Check(args)) {
358
PyErr_SetString(PyExc_SystemError,
359
"new style getargs format but argument is not a tuple");
360
return 0;
361
}
362
363
len = PyTuple_GET_SIZE(args);
364
365
if (len < min || max < len) {
366
if (message == NULL) {
367
PyOS_snprintf(msgbuf, sizeof(msgbuf),
368
"%.150s%s takes %s %d argument%s "
369
"(%ld given)",
370
fname==NULL ? "function" : fname,
371
fname==NULL ? "" : "()",
372
min==max ? "exactly"
373
: len < min ? "at least" : "at most",
374
len < min ? min : max,
375
(len < min ? min : max) == 1 ? "" : "s",
376
Py_SAFE_DOWNCAST(len, Py_ssize_t, long));
377
message = msgbuf;
378
}
379
PyErr_SetString(PyExc_TypeError, message);
380
return 0;
381
}
382
383
for (i = 0; i < len; i++) {
384
if (*format == '|')
385
format++;
386
msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,
387
flags, levels, msgbuf,
388
sizeof(msgbuf), &freelist);
389
if (msg) {
390
seterror(i+1, msg, levels, fname, msg);
391
return cleanreturn(0, freelist);
392
}
393
}
394
395
if (*format != '\0' && !isalpha(Py_CHARMASK(*format)) &&
396
*format != '(' &&
397
*format != '|' && *format != ':' && *format != ';') {
398
PyErr_Format(PyExc_SystemError,
399
"bad format string: %.200s", formatsave);
400
return cleanreturn(0, freelist);
401
}
402
403
return cleanreturn(1, freelist);
256
char msgbuf[256];
257
int levels[32];
258
const char *fname = NULL;
259
const char *message = NULL;
260
int min = -1;
261
int max = 0;
262
int level = 0;
263
int endfmt = 0;
264
const char *formatsave = format;
265
Py_ssize_t i, len;
266
char *msg;
267
PyObject *freelist = NULL;
268
int compat = flags & FLAG_COMPAT;
269
270
assert(compat || (args != (PyObject*)NULL));
271
flags = flags & ~FLAG_COMPAT;
272
273
while (endfmt == 0) {
274
int c = *format++;
275
switch (c) {
276
case '(':
277
if (level == 0)
278
max++;
279
level++;
280
if (level >= 30)
281
Py_FatalError("too many tuple nesting levels "
282
"in argument format string");
283
break;
284
case ')':
285
if (level == 0)
286
Py_FatalError("excess ')' in getargs format");
287
else
288
level--;
289
break;
290
case '\0':
291
endfmt = 1;
292
break;
293
case ':':
294
fname = format;
295
endfmt = 1;
296
break;
297
case ';':
298
message = format;
299
endfmt = 1;
300
break;
301
default:
302
if (level == 0) {
303
if (c == 'O')
304
max++;
305
else if (isalpha(Py_CHARMASK(c))) {
306
if (c != 'e') /* skip encoded */
307
max++;
308
} else if (c == '|')
309
min = max;
310
}
311
break;
312
}
313
}
314
315
if (level != 0)
316
Py_FatalError(/* '(' */ "missing ')' in getargs format");
317
318
if (min < 0)
319
min = max;
320
321
format = formatsave;
322
323
if (compat) {
324
if (max == 0) {
325
if (args == NULL)
326
return 1;
327
PyOS_snprintf(msgbuf, sizeof(msgbuf),
328
"%.200s%s takes no arguments",
329
fname==NULL ? "function" : fname,
330
fname==NULL ? "" : "()");
331
PyErr_SetString(PyExc_TypeError, msgbuf);
332
return 0;
333
}
334
else if (min == 1 && max == 1) {
335
if (args == NULL) {
336
PyOS_snprintf(msgbuf, sizeof(msgbuf),
337
"%.200s%s takes at least one argument",
338
fname==NULL ? "function" : fname,
339
fname==NULL ? "" : "()");
340
PyErr_SetString(PyExc_TypeError, msgbuf);
341
return 0;
342
}
343
msg = convertitem(args, &format, p_va, flags, levels,
344
msgbuf, sizeof(msgbuf), &freelist);
345
if (msg == NULL)
346
return cleanreturn(1, freelist);
347
seterror(levels[0], msg, levels+1, fname, message);
348
return cleanreturn(0, freelist);
349
}
350
else {
351
PyErr_SetString(PyExc_SystemError,
352
"old style getargs format uses new features");
353
return 0;
354
}
355
}
356
357
if (!PyTuple_Check(args)) {
358
PyErr_SetString(PyExc_SystemError,
359
"new style getargs format but argument is not a tuple");
360
return 0;
361
}
362
363
len = PyTuple_GET_SIZE(args);
364
365
if (len < min || max < len) {
366
if (message == NULL) {
367
PyOS_snprintf(msgbuf, sizeof(msgbuf),
368
"%.150s%s takes %s %d argument%s "
369
"(%ld given)",
370
fname==NULL ? "function" : fname,
371
fname==NULL ? "" : "()",
372
min==max ? "exactly"
373
: len < min ? "at least" : "at most",
374
len < min ? min : max,
375
(len < min ? min : max) == 1 ? "" : "s",
376
Py_SAFE_DOWNCAST(len, Py_ssize_t, long));
377
message = msgbuf;
378
}
379
PyErr_SetString(PyExc_TypeError, message);
380
return 0;
381
}
382
383
for (i = 0; i < len; i++) {
384
if (*format == '|')
385
format++;
386
msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,
387
flags, levels, msgbuf,
388
sizeof(msgbuf), &freelist);
389
if (msg) {
390
seterror(i+1, msg, levels, fname, msg);
391
return cleanreturn(0, freelist);
392
}
393
}
394
395
if (*format != '\0' && !isalpha(Py_CHARMASK(*format)) &&
396
*format != '(' &&
397
*format != '|' && *format != ':' && *format != ';') {
398
PyErr_Format(PyExc_SystemError,
399
"bad format string: %.200s", formatsave);
400
return cleanreturn(0, freelist);
401
}
402
403
return cleanreturn(1, freelist);
404
404
}
405
405
406
406
409
409
seterror(int iarg, const char *msg, int *levels, const char *fname,
410
410
const char *message)
411
411
{
412
char buf[512];
413
int i;
414
char *p = buf;
412
char buf[512];
413
int i;
414
char *p = buf;
415
415
416
if (PyErr_Occurred())
417
return;
418
else if (message == NULL) {
419
if (fname != NULL) {
420
PyOS_snprintf(p, sizeof(buf), "%.200s() ", fname);
421
p += strlen(p);
422
}
423
if (iarg != 0) {
424
PyOS_snprintf(p, sizeof(buf) - (p - buf),
425
"argument %d", iarg);
426
i = 0;
427
p += strlen(p);
428
while (levels[i] > 0 && i < 32 && (int)(p-buf) < 220) {
429
PyOS_snprintf(p, sizeof(buf) - (p - buf),
430
", item %d", levels[i]-1);
431
p += strlen(p);
432
i++;
433
}
434
}
435
else {
436
PyOS_snprintf(p, sizeof(buf) - (p - buf), "argument");
437
p += strlen(p);
438
}
439
PyOS_snprintf(p, sizeof(buf) - (p - buf), " %.256s", msg);
440
message = buf;
441
}
442
PyErr_SetString(PyExc_TypeError, message);
416
if (PyErr_Occurred())
417
return;
418
else if (message == NULL) {
419
if (fname != NULL) {
420
PyOS_snprintf(p, sizeof(buf), "%.200s() ", fname);
421
p += strlen(p);
422
}
423
if (iarg != 0) {
424
PyOS_snprintf(p, sizeof(buf) - (p - buf),
425
"argument %d", iarg);
426
i = 0;
427
p += strlen(p);
428
while (levels[i] > 0 && i < 32 && (int)(p-buf) < 220) {
429
PyOS_snprintf(p, sizeof(buf) - (p - buf),
430
", item %d", levels[i]-1);
431
p += strlen(p);
432
i++;
433
}
434
}
435
else {
436
PyOS_snprintf(p, sizeof(buf) - (p - buf), "argument");
437
p += strlen(p);
438
}
439
PyOS_snprintf(p, sizeof(buf) - (p - buf), " %.256s", msg);
440
message = buf;
441
}
442
PyErr_SetString(PyExc_TypeError, message);
443
443
}
444
444
445
445
455
455
*p_va is undefined,
456
456
*levels is a 0-terminated list of item numbers,
457
457
*msgbuf contains an error message, whose format is:
458
"must be <typename1>, not <typename2>", where:
459
<typename1> is the name of the expected type, and
460
<typename2> is the name of the actual type,
458
"must be <typename1>, not <typename2>", where:
459
<typename1> is the name of the expected type, and
460
<typename2> is the name of the actual type,
461
461
and msgbuf is returned.
462
462
*/
463
463
466
466
int *levels, char *msgbuf, size_t bufsize, int toplevel,
467
467
PyObject **freelist)
468
468
{
469
int level = 0;
470
int n = 0;
471
const char *format = *p_format;
472
int i;
473
474
for (;;) {
475
int c = *format++;
476
if (c == '(') {
477
if (level == 0)
478
n++;
479
level++;
480
}
481
else if (c == ')') {
482
if (level == 0)
483
break;
484
level--;
485
}
486
else if (c == ':' || c == ';' || c == '\0')
487
break;
488
else if (level == 0 && isalpha(Py_CHARMASK(c)))
489
n++;
490
}
491
492
if (!PySequence_Check(arg) || PyBytes_Check(arg)) {
493
levels[0] = 0;
494
PyOS_snprintf(msgbuf, bufsize,
495
toplevel ? "expected %d arguments, not %.50s" :
496
"must be %d-item sequence, not %.50s",
497
n,
498
arg == Py_None ? "None" : arg->ob_type->tp_name);
499
return msgbuf;
500
}
501
502
if ((i = PySequence_Size(arg)) != n) {
503
levels[0] = 0;
504
PyOS_snprintf(msgbuf, bufsize,
505
toplevel ? "expected %d arguments, not %d" :
506
"must be sequence of length %d, not %d",
507
n, i);
508
return msgbuf;
509
}
510
511
format = *p_format;
512
for (i = 0; i < n; i++) {
513
char *msg;
514
PyObject *item;
515
item = PySequence_GetItem(arg, i);
516
if (item == NULL) {
517
PyErr_Clear();
518
levels[0] = i+1;
519
levels[1] = 0;
520
strncpy(msgbuf, "is not retrievable", bufsize);
521
return msgbuf;
522
}
523
msg = convertitem(item, &format, p_va, flags, levels+1,
524
msgbuf, bufsize, freelist);
525
/* PySequence_GetItem calls tp->sq_item, which INCREFs */
526
Py_XDECREF(item);
527
if (msg != NULL) {
528
levels[0] = i+1;
529
return msg;
530
}
531
}
532
533
*p_format = format;
534
return NULL;
469
int level = 0;
470
int n = 0;
471
const char *format = *p_format;
472
int i;
473
474
for (;;) {
475
int c = *format++;
476
if (c == '(') {
477
if (level == 0)
478
n++;
479
level++;
480
}
481
else if (c == ')') {
482
if (level == 0)
483
break;
484
level--;
485
}
486
else if (c == ':' || c == ';' || c == '\0')
487
break;
488
else if (level == 0 && isalpha(Py_CHARMASK(c)))
489
n++;
490
}
491
492
if (!PySequence_Check(arg) || PyBytes_Check(arg)) {
493
levels[0] = 0;
494
PyOS_snprintf(msgbuf, bufsize,
495
toplevel ? "expected %d arguments, not %.50s" :
496
"must be %d-item sequence, not %.50s",
497
n,
498
arg == Py_None ? "None" : arg->ob_type->tp_name);
499
return msgbuf;
500
}
501
502
if ((i = PySequence_Size(arg)) != n) {
503
levels[0] = 0;
504
PyOS_snprintf(msgbuf, bufsize,
505
toplevel ? "expected %d arguments, not %d" :
506
"must be sequence of length %d, not %d",
507
n, i);
508
return msgbuf;
509
}
510
511
format = *p_format;
512
for (i = 0; i < n; i++) {
513
char *msg;
514
PyObject *item;
515
item = PySequence_GetItem(arg, i);
516
if (item == NULL) {
517
PyErr_Clear();
518
levels[0] = i+1;
519
levels[1] = 0;
520
strncpy(msgbuf, "is not retrievable", bufsize);
521
return msgbuf;
522
}
523
msg = convertitem(item, &format, p_va, flags, levels+1,
524
msgbuf, bufsize, freelist);
525
/* PySequence_GetItem calls tp->sq_item, which INCREFs */
526
Py_XDECREF(item);
527
if (msg != NULL) {
528
levels[0] = i+1;
529
return msg;
530
}
531
}
532
533
*p_format = format;
534
return NULL;
535
535
}
536
536
537
537
541
541
convertitem(PyObject *arg, const char **p_format, va_list *p_va, int flags,
542
542
int *levels, char *msgbuf, size_t bufsize, PyObject **freelist)
543
543
{
544
char *msg;
545
const char *format = *p_format;
544
char *msg;
545
const char *format = *p_format;
546
546
547
if (*format == '(' /* ')' */) {
548
format++;
549
msg = converttuple(arg, &format, p_va, flags, levels, msgbuf,
550
bufsize, 0, freelist);
551
if (msg == NULL)
552
format++;
553
}
554
else {
555
msg = convertsimple(arg, &format, p_va, flags,
556
msgbuf, bufsize, freelist);
557
if (msg != NULL)
558
levels[0] = 0;
559
}
560
if (msg == NULL)
561
*p_format = format;
562
return msg;
547
if (*format == '(' /* ')' */) {
548
format++;
549
msg = converttuple(arg, &format, p_va, flags, levels, msgbuf,
550
bufsize, 0, freelist);
551
if (msg == NULL)
552
format++;
553
}
554
else {
555
msg = convertsimple(arg, &format, p_va, flags,
556
msgbuf, bufsize, freelist);
557
if (msg != NULL)
558
levels[0] = 0;
559
}
560
if (msg == NULL)
561
*p_format = format;
562
return msg;
563
563
}
564
564
565
565
566
566
567
567
#define UNICODE_DEFAULT_ENCODING(arg) \
568
_PyUnicode_AsDefaultEncodedString(arg, NULL)
568
_PyUnicode_AsDefaultEncodedString(arg, NULL)
569
569
570
570
/* Format an error message generated by convertsimple(). */
571
571
572
572
static char *
573
573
converterr(const char *expected, PyObject *arg, char *msgbuf, size_t bufsize)
574
574
{
575
assert(expected != NULL);
576
assert(arg != NULL);
577
PyOS_snprintf(msgbuf, bufsize,
578
"must be %.50s, not %.50s", expected,
579
arg == Py_None ? "None" : arg->ob_type->tp_name);
580
return msgbuf;
575
assert(expected != NULL);
576
assert(arg != NULL);
577
PyOS_snprintf(msgbuf, bufsize,
578
"must be %.50s, not %.50s", expected,
579
arg == Py_None ? "None" : arg->ob_type->tp_name);
580
return msgbuf;
581
581
}
582
582
583
583
#define CONV_UNICODE "(unicode conversion error)"
587
587
static int
588
588
float_argument_error(PyObject *arg)
589
589
{
590
if (PyFloat_Check(arg)) {
591
PyErr_SetString(PyExc_TypeError,
592
"integer argument expected, got float" );
593
return 1;
594
}
595
else
596
return 0;
590
if (PyFloat_Check(arg)) {
591
PyErr_SetString(PyExc_TypeError,
592
"integer argument expected, got float" );
593
return 1;
594
}
595
else
596
return 0;
597
597
}
598
598
599
599
/* Convert a non-tuple argument. Return NULL if conversion went OK,
609
609
convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags,
610
610
char *msgbuf, size_t bufsize, PyObject **freelist)
611
611
{
612
/* For # codes */
613
#define FETCH_SIZE int *q=NULL;Py_ssize_t *q2=NULL;\
614
if (flags & FLAG_SIZE_T) q2=va_arg(*p_va, Py_ssize_t*); \
615
else q=va_arg(*p_va, int*);
612
/* For # codes */
613
#define FETCH_SIZE int *q=NULL;Py_ssize_t *q2=NULL;\
614
if (flags & FLAG_SIZE_T) q2=va_arg(*p_va, Py_ssize_t*); \
615
else q=va_arg(*p_va, int*);
616
616
#define STORE_SIZE(s) if (flags & FLAG_SIZE_T) *q2=s; else *q=s;
617
617
#define BUFFER_LEN ((flags & FLAG_SIZE_T) ? *q2:*q)
618
618
619
const char *format = *p_format;
620
char c = *format++;
621
PyObject *uarg;
622
623
switch (c) {
624
625
case 'b': { /* unsigned byte -- very short int */
626
char *p = va_arg(*p_va, char *);
627
long ival;
628
if (float_argument_error(arg))
629
return converterr("integer<b>", arg, msgbuf, bufsize);
630
ival = PyLong_AsLong(arg);
631
if (ival == -1 && PyErr_Occurred())
632
return converterr("integer<b>", arg, msgbuf, bufsize);
633
else if (ival < 0) {
634
PyErr_SetString(PyExc_OverflowError,
635
"unsigned byte integer is less than minimum");
636
return converterr("integer<b>", arg, msgbuf, bufsize);
637
}
638
else if (ival > UCHAR_MAX) {
639
PyErr_SetString(PyExc_OverflowError,
640
"unsigned byte integer is greater than maximum");
641
return converterr("integer<b>", arg, msgbuf, bufsize);
642
}
643
else
644
*p = (unsigned char) ival;
645
break;
646
}
647
648
case 'B': {/* byte sized bitfield - both signed and unsigned
649
values allowed */
650
char *p = va_arg(*p_va, char *);
651
long ival;
652
if (float_argument_error(arg))
653
return converterr("integer<B>", arg, msgbuf, bufsize);
654
ival = PyLong_AsUnsignedLongMask(arg);
655
if (ival == -1 && PyErr_Occurred())
656
return converterr("integer<B>", arg, msgbuf, bufsize);
657
else
658
*p = (unsigned char) ival;
659
break;
660
}
661
662
case 'h': {/* signed short int */
663
short *p = va_arg(*p_va, short *);
664
long ival;
665
if (float_argument_error(arg))
666
return converterr("integer<h>", arg, msgbuf, bufsize);
667
ival = PyLong_AsLong(arg);
668
if (ival == -1 && PyErr_Occurred())
669
return converterr("integer<h>", arg, msgbuf, bufsize);
670
else if (ival < SHRT_MIN) {
671
PyErr_SetString(PyExc_OverflowError,
672
"signed short integer is less than minimum");
673
return converterr("integer<h>", arg, msgbuf, bufsize);
674
}
675
else if (ival > SHRT_MAX) {
676
PyErr_SetString(PyExc_OverflowError,
677
"signed short integer is greater than maximum");
678
return converterr("integer<h>", arg, msgbuf, bufsize);
679
}
680
else
681
*p = (short) ival;
682
break;
683
}
684
685
case 'H': { /* short int sized bitfield, both signed and
686
unsigned allowed */
687
unsigned short *p = va_arg(*p_va, unsigned short *);
688
long ival;
689
if (float_argument_error(arg))
690
return converterr("integer<H>", arg, msgbuf, bufsize);
691
ival = PyLong_AsUnsignedLongMask(arg);
692
if (ival == -1 && PyErr_Occurred())
693
return converterr("integer<H>", arg, msgbuf, bufsize);
694
else
695
*p = (unsigned short) ival;
696
break;
697
}
698
699
case 'i': {/* signed int */
700
int *p = va_arg(*p_va, int *);
701
long ival;
702
if (float_argument_error(arg))
703
return converterr("integer<i>", arg, msgbuf, bufsize);
704
ival = PyLong_AsLong(arg);
705
if (ival == -1 && PyErr_Occurred())
706
return converterr("integer<i>", arg, msgbuf, bufsize);
707
else if (ival > INT_MAX) {
708
PyErr_SetString(PyExc_OverflowError,
709
"signed integer is greater than maximum");
710
return converterr("integer<i>", arg, msgbuf, bufsize);
711
}
712
else if (ival < INT_MIN) {
713
PyErr_SetString(PyExc_OverflowError,
714
"signed integer is less than minimum");
715
return converterr("integer<i>", arg, msgbuf, bufsize);
716
}
717
else
718
*p = ival;
719
break;
720
}
721
722
case 'I': { /* int sized bitfield, both signed and
723
unsigned allowed */
724
unsigned int *p = va_arg(*p_va, unsigned int *);
725
unsigned int ival;
726
if (float_argument_error(arg))
727
return converterr("integer<I>", arg, msgbuf, bufsize);
728
ival = (unsigned int)PyLong_AsUnsignedLongMask(arg);
729
if (ival == (unsigned int)-1 && PyErr_Occurred())
730
return converterr("integer<I>", arg, msgbuf, bufsize);
731
else
732
*p = ival;
733
break;
734
}
735
736
case 'n': /* Py_ssize_t */
737
{
738
PyObject *iobj;
739
Py_ssize_t *p = va_arg(*p_va, Py_ssize_t *);
740
Py_ssize_t ival = -1;
741
if (float_argument_error(arg))
742
return converterr("integer<n>", arg, msgbuf, bufsize);
743
iobj = PyNumber_Index(arg);
744
if (iobj != NULL) {
745
ival = PyLong_AsSsize_t(iobj);
746
Py_DECREF(iobj);
747
}
748
if (ival == -1 && PyErr_Occurred())
749
return converterr("integer<n>", arg, msgbuf, bufsize);
750
*p = ival;
751
break;
752
}
753
case 'l': {/* long int */
754
long *p = va_arg(*p_va, long *);
755
long ival;
756
if (float_argument_error(arg))
757
return converterr("integer<l>", arg, msgbuf, bufsize);
758
ival = PyLong_AsLong(arg);
759
if (ival == -1 && PyErr_Occurred())
760
return converterr("integer<l>", arg, msgbuf, bufsize);
761
else
762
*p = ival;
763
break;
764
}
765
766
case 'k': { /* long sized bitfield */
767
unsigned long *p = va_arg(*p_va, unsigned long *);
768
unsigned long ival;
769
if (PyLong_Check(arg))
770
ival = PyLong_AsUnsignedLongMask(arg);
771
else
772
return converterr("integer<k>", arg, msgbuf, bufsize);
773
*p = ival;
774
break;
775
}
619
const char *format = *p_format;
620
char c = *format++;
621
PyObject *uarg;
622
623
switch (c) {
624
625
case 'b': { /* unsigned byte -- very short int */
626
char *p = va_arg(*p_va, char *);
627
long ival;
628
if (float_argument_error(arg))
629
return converterr("integer<b>", arg, msgbuf, bufsize);
630
ival = PyLong_AsLong(arg);
631
if (ival == -1 && PyErr_Occurred())
632
return converterr("integer<b>", arg, msgbuf, bufsize);
633
else if (ival < 0) {
634
PyErr_SetString(PyExc_OverflowError,
635
"unsigned byte integer is less than minimum");
636
return converterr("integer<b>", arg, msgbuf, bufsize);
637
}
638
else if (ival > UCHAR_MAX) {
639
PyErr_SetString(PyExc_OverflowError,
640
"unsigned byte integer is greater than maximum");
641
return converterr("integer<b>", arg, msgbuf, bufsize);
642
}
643
else
644
*p = (unsigned char) ival;
645
break;
646
}
647
648
case 'B': {/* byte sized bitfield - both signed and unsigned
649
values allowed */
650
char *p = va_arg(*p_va, char *);
651
long ival;
652
if (float_argument_error(arg))
653
return converterr("integer<B>", arg, msgbuf, bufsize);
654
ival = PyLong_AsUnsignedLongMask(arg);
655
if (ival == -1 && PyErr_Occurred())
656
return converterr("integer<B>", arg, msgbuf, bufsize);
657
else
658
*p = (unsigned char) ival;
659
break;
660
}
661
662
case 'h': {/* signed short int */
663
short *p = va_arg(*p_va, short *);
664
long ival;
665
if (float_argument_error(arg))
666
return converterr("integer<h>", arg, msgbuf, bufsize);
667
ival = PyLong_AsLong(arg);
668
if (ival == -1 && PyErr_Occurred())
669
return converterr("integer<h>", arg, msgbuf, bufsize);
670
else if (ival < SHRT_MIN) {
671
PyErr_SetString(PyExc_OverflowError,
672
"signed short integer is less than minimum");
673
return converterr("integer<h>", arg, msgbuf, bufsize);
674
}
675
else if (ival > SHRT_MAX) {
676
PyErr_SetString(PyExc_OverflowError,
677
"signed short integer is greater than maximum");
678
return converterr("integer<h>", arg, msgbuf, bufsize);
679
}
680
else
681
*p = (short) ival;
682
break;
683
}
684
685
case 'H': { /* short int sized bitfield, both signed and
686
unsigned allowed */
687
unsigned short *p = va_arg(*p_va, unsigned short *);
688
long ival;
689
if (float_argument_error(arg))
690
return converterr("integer<H>", arg, msgbuf, bufsize);
691
ival = PyLong_AsUnsignedLongMask(arg);
692
if (ival == -1 && PyErr_Occurred())
693
return converterr("integer<H>", arg, msgbuf, bufsize);
694
else
695
*p = (unsigned short) ival;
696
break;
697
}
698
699
case 'i': {/* signed int */
700
int *p = va_arg(*p_va, int *);
701
long ival;
702
if (float_argument_error(arg))
703
return converterr("integer<i>", arg, msgbuf, bufsize);
704
ival = PyLong_AsLong(arg);
705
if (ival == -1 && PyErr_Occurred())
706
return converterr("integer<i>", arg, msgbuf, bufsize);
707
else if (ival > INT_MAX) {
708
PyErr_SetString(PyExc_OverflowError,
709
"signed integer is greater than maximum");
710
return converterr("integer<i>", arg, msgbuf, bufsize);
711
}
712
else if (ival < INT_MIN) {
713
PyErr_SetString(PyExc_OverflowError,
714
"signed integer is less than minimum");
715
return converterr("integer<i>", arg, msgbuf, bufsize);
716
}
717
else
718
*p = ival;
719
break;
720
}
721
722
case 'I': { /* int sized bitfield, both signed and
723
unsigned allowed */
724
unsigned int *p = va_arg(*p_va, unsigned int *);
725
unsigned int ival;
726
if (float_argument_error(arg))
727
return converterr("integer<I>", arg, msgbuf, bufsize);
728
ival = (unsigned int)PyLong_AsUnsignedLongMask(arg);
729
if (ival == (unsigned int)-1 && PyErr_Occurred())
730
return converterr("integer<I>", arg, msgbuf, bufsize);
731
else
732
*p = ival;
733
break;
734
}
735
736
case 'n': /* Py_ssize_t */
737
{
738
PyObject *iobj;
739
Py_ssize_t *p = va_arg(*p_va, Py_ssize_t *);
740
Py_ssize_t ival = -1;
741
if (float_argument_error(arg))
742
return converterr("integer<n>", arg, msgbuf, bufsize);
743
iobj = PyNumber_Index(arg);
744
if (iobj != NULL) {
745
ival = PyLong_AsSsize_t(iobj);
746
Py_DECREF(iobj);
747
}
748
if (ival == -1 && PyErr_Occurred())
749
return converterr("integer<n>", arg, msgbuf, bufsize);
750
*p = ival;
751
break;
752
}
753
case 'l': {/* long int */
754
long *p = va_arg(*p_va, long *);
755
long ival;
756
if (float_argument_error(arg))
757
return converterr("integer<l>", arg, msgbuf, bufsize);
758
ival = PyLong_AsLong(arg);
759
if (ival == -1 && PyErr_Occurred())
760
return converterr("integer<l>", arg, msgbuf, bufsize);
761
else
762
*p = ival;
763
break;
764
}
765
766
case 'k': { /* long sized bitfield */
767
unsigned long *p = va_arg(*p_va, unsigned long *);
768
unsigned long ival;
769
if (PyLong_Check(arg))
770
ival = PyLong_AsUnsignedLongMask(arg);
771
else
772
return converterr("integer<k>", arg, msgbuf, bufsize);
773
*p = ival;
774
break;
775
}
776
776
777
777
#ifdef HAVE_LONG_LONG
778
case 'L': {/* PY_LONG_LONG */
779
PY_LONG_LONG *p = va_arg( *p_va, PY_LONG_LONG * );
780
PY_LONG_LONG ival = PyLong_AsLongLong( arg );
781
if (ival == (PY_LONG_LONG)-1 && PyErr_Occurred() ) {
782
return converterr("long<L>", arg, msgbuf, bufsize);
783
} else {
784
*p = ival;
785
}
786
break;
787
}
778
case 'L': {/* PY_LONG_LONG */
779
PY_LONG_LONG *p = va_arg( *p_va, PY_LONG_LONG * );
780
PY_LONG_LONG ival = PyLong_AsLongLong( arg );
781
if (ival == (PY_LONG_LONG)-1 && PyErr_Occurred() ) {
782
return converterr("long<L>", arg, msgbuf, bufsize);
783
} else {
784
*p = ival;
785
}
786
break;
787
}
788
788
789
case 'K': { /* long long sized bitfield */
790
unsigned PY_LONG_LONG *p = va_arg(*p_va, unsigned PY_LONG_LONG *);
791
unsigned PY_LONG_LONG ival;
792
if (PyLong_Check(arg))
793
ival = PyLong_AsUnsignedLongLongMask(arg);
794
else
795
return converterr("integer<K>", arg, msgbuf, bufsize);
796
*p = ival;
797
break;
798
}
789
case 'K': { /* long long sized bitfield */
790
unsigned PY_LONG_LONG *p = va_arg(*p_va, unsigned PY_LONG_LONG *);
791
unsigned PY_LONG_LONG ival;
792
if (PyLong_Check(arg))
793
ival = PyLong_AsUnsignedLongLongMask(arg);
794
else
795
return converterr("integer<K>", arg, msgbuf, bufsize);
796
*p = ival;
797
break;
798
}
799
799
#endif
800
800
801
case 'f': {/* float */
802
float *p = va_arg(*p_va, float *);
803
double dval = PyFloat_AsDouble(arg);
804
if (PyErr_Occurred())
805
return converterr("float<f>", arg, msgbuf, bufsize);
806
else
807
*p = (float) dval;
808
break;
809
}
801
case 'f': {/* float */
802
float *p = va_arg(*p_va, float *);
803
double dval = PyFloat_AsDouble(arg);
804
if (PyErr_Occurred())
805
return converterr("float<f>", arg, msgbuf, bufsize);
806
else
807
*p = (float) dval;
808
break;
809
}
810
810
811
case 'd': {/* double */
812
double *p = va_arg(*p_va, double *);
813
double dval = PyFloat_AsDouble(arg);
814
if (PyErr_Occurred())
815
return converterr("float<d>", arg, msgbuf, bufsize);
816
else
817
*p = dval;
818
break;
819
}
811
case 'd': {/* double */
812
double *p = va_arg(*p_va, double *);
813
double dval = PyFloat_AsDouble(arg);
814
if (PyErr_Occurred())
815
return converterr("float<d>", arg, msgbuf, bufsize);
816
else
817
*p = dval;
818
break;
819
}
820
820
821
821
#ifndef WITHOUT_COMPLEX
822
case 'D': {/* complex double */
823
Py_complex *p = va_arg(*p_va, Py_complex *);
824
Py_complex cval;
825
cval = PyComplex_AsCComplex(arg);
826
if (PyErr_Occurred())
827
return converterr("complex<D>", arg, msgbuf, bufsize);
828
else
829
*p = cval;
830
break;
831
}
822
case 'D': {/* complex double */
823
Py_complex *p = va_arg(*p_va, Py_complex *);
824
Py_complex cval;
825
cval = PyComplex_AsCComplex(arg);
826
if (PyErr_Occurred())
827
return converterr("complex<D>", arg, msgbuf, bufsize);
828
else
829
*p = cval;
830
break;
831
}
832
832
#endif /* WITHOUT_COMPLEX */
833
833
834
case 'c': {/* char */
835
char *p = va_arg(*p_va, char *);
836
if (PyBytes_Check(arg) && PyBytes_Size(arg) == 1)
837
*p = PyBytes_AS_STRING(arg)[0];
838
else
839
return converterr("a byte string of length 1", arg, msgbuf, bufsize);
840
break;
841
}
842
843
case 'C': {/* unicode char */
844
int *p = va_arg(*p_va, int *);
845
if (PyUnicode_Check(arg) &&
846
PyUnicode_GET_SIZE(arg) == 1)
847
*p = PyUnicode_AS_UNICODE(arg)[0];
848
else
849
return converterr("a unicode character", arg, msgbuf, bufsize);
850
break;
851
}
852
853
/* XXX WAAAAH! 's', 'y', 'z', 'u', 'Z', 'e', 'w', 't' codes all
854
need to be cleaned up! */
855
856
case 's': {/* text string */
857
if (*format == '*') {
858
Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);
859
860
if (PyUnicode_Check(arg)) {
861
uarg = UNICODE_DEFAULT_ENCODING(arg);
862
if (uarg == NULL)
863
return converterr(CONV_UNICODE,
864
arg, msgbuf, bufsize);
865
PyBuffer_FillInfo(p, arg,
866
PyBytes_AS_STRING(uarg), PyBytes_GET_SIZE(uarg),
867
1, 0);
868
}
869
else { /* any buffer-like object */
870
char *buf;
871
if (getbuffer(arg, p, &buf) < 0)
872
return converterr(buf, arg, msgbuf, bufsize);
873
}
874
if (addcleanup(p, freelist, cleanup_buffer)) {
875
return converterr(
876
"(cleanup problem)",
877
arg, msgbuf, bufsize);
878
}
879
format++;
880
} else if (*format == '#') {
881
void **p = (void **)va_arg(*p_va, char **);
882
FETCH_SIZE;
883
884
if (PyUnicode_Check(arg)) {
885
uarg = UNICODE_DEFAULT_ENCODING(arg);
886
if (uarg == NULL)
887
return converterr(CONV_UNICODE,
888
arg, msgbuf, bufsize);
889
*p = PyBytes_AS_STRING(uarg);
890
STORE_SIZE(PyBytes_GET_SIZE(uarg));
891
}
892
else { /* any buffer-like object */
893
/* XXX Really? */
894
char *buf;
895
Py_ssize_t count = convertbuffer(arg, p, &buf);
896
if (count < 0)
897
return converterr(buf, arg, msgbuf, bufsize);
898
STORE_SIZE(count);
899
}
900
format++;
901
} else {
902
char **p = va_arg(*p_va, char **);
903
904
if (PyUnicode_Check(arg)) {
905
uarg = UNICODE_DEFAULT_ENCODING(arg);
906
if (uarg == NULL)
907
return converterr(CONV_UNICODE,
908
arg, msgbuf, bufsize);
909
*p = PyBytes_AS_STRING(uarg);
910
}
911
else
912
return converterr("string", arg, msgbuf, bufsize);
913
if ((Py_ssize_t) strlen(*p) != PyBytes_GET_SIZE(uarg))
914
return converterr("string without null bytes",
915
arg, msgbuf, bufsize);
916
}
917
break;
918
}
919
920
case 'y': {/* any buffer-like object, but not PyUnicode */
921
void **p = (void **)va_arg(*p_va, char **);
922
char *buf;
923
Py_ssize_t count;
924
if (*format == '*') {
925
if (getbuffer(arg, (Py_buffer*)p, &buf) < 0)
926
return converterr(buf, arg, msgbuf, bufsize);
927
format++;
928
if (addcleanup(p, freelist, cleanup_buffer)) {
929
return converterr(
930
"(cleanup problem)",
931
arg, msgbuf, bufsize);
932
}
933
break;
934
}
935
count = convertbuffer(arg, p, &buf);
936
if (count < 0)
937
return converterr(buf, arg, msgbuf, bufsize);
938
else if (*format == '#') {
939
FETCH_SIZE;
940
STORE_SIZE(count);
941
format++;
942
}
943
break;
944
}
945
946
case 'z': {/* like 's' or 's#', but None is okay, stored as NULL */
947
if (*format == '*') {
948
Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);
949
950
if (arg == Py_None)
951
PyBuffer_FillInfo(p, NULL, NULL, 0, 1, 0);
952
else if (PyUnicode_Check(arg)) {
953
uarg = UNICODE_DEFAULT_ENCODING(arg);
954
if (uarg == NULL)
955
return converterr(CONV_UNICODE,
956
arg, msgbuf, bufsize);
957
PyBuffer_FillInfo(p, arg,
958
PyBytes_AS_STRING(uarg), PyBytes_GET_SIZE(uarg),
959
1, 0);
960
}
961
else { /* any buffer-like object */
962
char *buf;
963
if (getbuffer(arg, p, &buf) < 0)
964
return converterr(buf, arg, msgbuf, bufsize);
965
}
966
if (addcleanup(p, freelist, cleanup_buffer)) {
967
return converterr(
968
"(cleanup problem)",
969
arg, msgbuf, bufsize);
970
}
971
format++;
972
} else if (*format == '#') { /* any buffer-like object */
973
void **p = (void **)va_arg(*p_va, char **);
974
FETCH_SIZE;
975
976
if (arg == Py_None) {
977
*p = 0;
978
STORE_SIZE(0);
979
}
980
else if (PyUnicode_Check(arg)) {
981
uarg = UNICODE_DEFAULT_ENCODING(arg);
982
if (uarg == NULL)
983
return converterr(CONV_UNICODE,
984
arg, msgbuf, bufsize);
985
*p = PyBytes_AS_STRING(uarg);
986
STORE_SIZE(PyBytes_GET_SIZE(uarg));
987
}
988
else { /* any buffer-like object */
989
/* XXX Really? */
990
char *buf;
991
Py_ssize_t count = convertbuffer(arg, p, &buf);
992
if (count < 0)
993
return converterr(buf, arg, msgbuf, bufsize);
994
STORE_SIZE(count);
995
}
996
format++;
997
} else {
998
char **p = va_arg(*p_va, char **);
999
uarg = NULL;
1000
1001
if (arg == Py_None)
1002
*p = 0;
1003
else if (PyBytes_Check(arg)) {
1004
/* Enable null byte check below */
1005
uarg = arg;
1006
*p = PyBytes_AS_STRING(arg);
1007
}
1008
else if (PyUnicode_Check(arg)) {
1009
uarg = UNICODE_DEFAULT_ENCODING(arg);
1010
if (uarg == NULL)
1011
return converterr(CONV_UNICODE,
1012
arg, msgbuf, bufsize);
1013
*p = PyBytes_AS_STRING(uarg);
1014
}
1015
else
1016
return converterr("string or None",
1017
arg, msgbuf, bufsize);
1018
if (*format == '#') {
1019
FETCH_SIZE;
1020
assert(0); /* XXX redundant with if-case */
1021
if (arg == Py_None) {
1022
STORE_SIZE(0);
1023
}
1024
else {
1025
STORE_SIZE(PyBytes_Size(arg));
1026
}
1027
format++;
1028
}
1029
else if (*p != NULL && uarg != NULL &&
1030
(Py_ssize_t) strlen(*p) != PyBytes_GET_SIZE(uarg))
1031
return converterr(
1032
"string without null bytes or None",
1033
arg, msgbuf, bufsize);
1034
}
1035
break;
1036
}
1037
1038
case 'Z': {/* unicode, may be NULL (None) */
1039
if (*format == '#') { /* any buffer-like object */
1040
Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
1041
FETCH_SIZE;
1042
1043
if (arg == Py_None) {
1044
*p = 0;
1045
STORE_SIZE(0);
1046
}
1047
else if (PyUnicode_Check(arg)) {
1048
*p = PyUnicode_AS_UNICODE(arg);
1049
STORE_SIZE(PyUnicode_GET_SIZE(arg));
1050
}
1051
format++;
1052
} else {
1053
Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
1054
1055
if (arg == Py_None)
1056
*p = 0;
1057
else if (PyUnicode_Check(arg))
1058
*p = PyUnicode_AS_UNICODE(arg);
1059
else
1060
return converterr("string or None",
1061
arg, msgbuf, bufsize);
1062
}
1063
break;
1064
}
1065
1066
case 'e': {/* encoded string */
1067
char **buffer;
1068
const char *encoding;
1069
PyObject *s;
1070
int recode_strings;
1071
Py_ssize_t size;
1072
const char *ptr;
1073
1074
/* Get 'e' parameter: the encoding name */
1075
encoding = (const char *)va_arg(*p_va, const char *);
1076
if (encoding == NULL)
1077
encoding = PyUnicode_GetDefaultEncoding();
1078
1079
/* Get output buffer parameter:
1080
's' (recode all objects via Unicode) or
1081
't' (only recode non-string objects)
1082
*/
1083
if (*format == 's')
1084
recode_strings = 1;
1085
else if (*format == 't')
1086
recode_strings = 0;
1087
else
1088
return converterr(
1089
"(unknown parser marker combination)",
1090
arg, msgbuf, bufsize);
1091
buffer = (char **)va_arg(*p_va, char **);
1092
format++;
1093
if (buffer == NULL)
1094
return converterr("(buffer is NULL)",
1095
arg, msgbuf, bufsize);
1096
1097
/* Encode object */
1098
if (!recode_strings &&
1099
(PyBytes_Check(arg) || PyByteArray_Check(arg))) {
1100
s = arg;
1101
Py_INCREF(s);
1102
if (PyObject_AsCharBuffer(s, &ptr, &size) < 0)
1103
return converterr("(AsCharBuffer failed)",
1104
arg, msgbuf, bufsize);
1105
}
1106
else {
1107
PyObject *u;
1108
1109
/* Convert object to Unicode */
1110
u = PyUnicode_FromObject(arg);
1111
if (u == NULL)
1112
return converterr(
1113
"string or unicode or text buffer",
1114
arg, msgbuf, bufsize);
1115
1116
/* Encode object; use default error handling */
1117
s = PyUnicode_AsEncodedString(u,
1118
encoding,
1119
NULL);
1120
Py_DECREF(u);
1121
if (s == NULL)
1122
return converterr("(encoding failed)",
1123
arg, msgbuf, bufsize);
1124
if (!PyBytes_Check(s)) {
1125
Py_DECREF(s);
1126
return converterr(
1127
"(encoder failed to return bytes)",
1128
arg, msgbuf, bufsize);
1129
}
1130
size = PyBytes_GET_SIZE(s);
1131
ptr = PyBytes_AS_STRING(s);
1132
if (ptr == NULL)
1133
ptr = "";
1134
}
1135
1136
/* Write output; output is guaranteed to be 0-terminated */
1137
if (*format == '#') {
1138
/* Using buffer length parameter '#':
1139
1140
- if *buffer is NULL, a new buffer of the
1141
needed size is allocated and the data
1142
copied into it; *buffer is updated to point
1143
to the new buffer; the caller is
1144
responsible for PyMem_Free()ing it after
1145
usage
1146
1147
- if *buffer is not NULL, the data is
1148
copied to *buffer; *buffer_len has to be
1149
set to the size of the buffer on input;
1150
buffer overflow is signalled with an error;
1151
buffer has to provide enough room for the
1152
encoded string plus the trailing 0-byte
1153
1154
- in both cases, *buffer_len is updated to
1155
the size of the buffer /excluding/ the
1156
trailing 0-byte
1157
1158
*/
1159
FETCH_SIZE;
1160
1161
format++;
1162
if (q == NULL && q2 == NULL) {
1163
Py_DECREF(s);
1164
return converterr(
1165
"(buffer_len is NULL)",
1166
arg, msgbuf, bufsize);
1167
}
1168
if (*buffer == NULL) {
1169
*buffer = PyMem_NEW(char, size + 1);
1170
if (*buffer == NULL) {
1171
Py_DECREF(s);
1172
return converterr(
1173
"(memory error)",
1174
arg, msgbuf, bufsize);
1175
}
1176
if (addcleanup(*buffer, freelist, cleanup_ptr)) {
1177
Py_DECREF(s);
1178
return converterr(
1179
"(cleanup problem)",
1180
arg, msgbuf, bufsize);
1181
}
1182
} else {
1183
if (size + 1 > BUFFER_LEN) {
1184
Py_DECREF(s);
1185
return converterr(
1186
"(buffer overflow)",
1187
arg, msgbuf, bufsize);
1188
}
1189
}
1190
memcpy(*buffer, ptr, size+1);
1191
STORE_SIZE(size);
1192
} else {
1193
/* Using a 0-terminated buffer:
1194
1195
- the encoded string has to be 0-terminated
1196
for this variant to work; if it is not, an
1197
error raised
1198
1199
- a new buffer of the needed size is
1200
allocated and the data copied into it;
1201
*buffer is updated to point to the new
1202
buffer; the caller is responsible for
1203
PyMem_Free()ing it after usage
1204
1205
*/
1206
if ((Py_ssize_t)strlen(ptr) != size) {
1207
Py_DECREF(s);
1208
return converterr(
1209
"encoded string without NULL bytes",
1210
arg, msgbuf, bufsize);
1211
}
1212
*buffer = PyMem_NEW(char, size + 1);
1213
if (*buffer == NULL) {
1214
Py_DECREF(s);
1215
return converterr("(memory error)",
1216
arg, msgbuf, bufsize);
1217
}
1218
if (addcleanup(*buffer, freelist, cleanup_ptr)) {
1219
Py_DECREF(s);
1220
return converterr("(cleanup problem)",
1221
arg, msgbuf, bufsize);
1222
}
1223
memcpy(*buffer, ptr, size+1);
1224
}
1225
Py_DECREF(s);
1226
break;
1227
}
1228
1229
case 'u': {/* raw unicode buffer (Py_UNICODE *) */
1230
Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
1231
if (!PyUnicode_Check(arg))
1232
return converterr("str", arg, msgbuf, bufsize);
1233
*p = PyUnicode_AS_UNICODE(arg);
1234
if (*format == '#') { /* store pointer and size */
1235
FETCH_SIZE;
1236
STORE_SIZE(PyUnicode_GET_SIZE(arg));
1237
format++;
1238
}
1239
break;
1240
}
1241
1242
case 'S': { /* PyBytes object */
1243
PyObject **p = va_arg(*p_va, PyObject **);
1244
if (PyBytes_Check(arg))
1245
*p = arg;
1246
else
1247
return converterr("bytes", arg, msgbuf, bufsize);
1248
break;
1249
}
1250
1251
case 'Y': { /* PyByteArray object */
1252
PyObject **p = va_arg(*p_va, PyObject **);
1253
if (PyByteArray_Check(arg))
1254
*p = arg;
1255
else
1256
return converterr("buffer", arg, msgbuf, bufsize);
1257
break;
1258
}
1259
1260
case 'U': { /* PyUnicode object */
1261
PyObject **p = va_arg(*p_va, PyObject **);
1262
if (PyUnicode_Check(arg))
1263
*p = arg;
1264
else
1265
return converterr("str", arg, msgbuf, bufsize);
1266
break;
1267
}
1268
1269
case 'O': { /* object */
1270
PyTypeObject *type;
1271
PyObject **p;
1272
if (*format == '!') {
1273
type = va_arg(*p_va, PyTypeObject*);
1274
p = va_arg(*p_va, PyObject **);
1275
format++;
1276
if (PyType_IsSubtype(arg->ob_type, type))
1277
*p = arg;
1278
else
1279
return converterr(type->tp_name, arg, msgbuf, bufsize);
1280
1281
}
1282
else if (*format == '?') {
1283
inquiry pred = va_arg(*p_va, inquiry);
1284
p = va_arg(*p_va, PyObject **);
1285
format++;
1286
if ((*pred)(arg))
1287
*p = arg;
1288
else
1289
return converterr("(unspecified)",
1290
arg, msgbuf, bufsize);
1291
1292
}
1293
else if (*format == '&') {
1294
typedef int (*converter)(PyObject *, void *);
1295
converter convert = va_arg(*p_va, converter);
1296
void *addr = va_arg(*p_va, void *);
1297
int res;
1298
format++;
1299
if (! (res = (*convert)(arg, addr)))
1300
return converterr("(unspecified)",
1301
arg, msgbuf, bufsize);
1302
if (res == Py_CLEANUP_SUPPORTED &&
1303
addcleanup_convert(addr, freelist, convert) == -1)
1304
return converterr("(cleanup problem)",
1305
arg, msgbuf, bufsize);
1306
}
1307
else {
1308
p = va_arg(*p_va, PyObject **);
1309
*p = arg;
1310
}
1311
break;
1312
}
1313
1314
1315
case 'w': { /* memory buffer, read-write access */
1316
void **p = va_arg(*p_va, void **);
1317
PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1318
Py_ssize_t count;
1319
int temp=-1;
1320
Py_buffer view;
1321
1322
if (pb && pb->bf_releasebuffer && *format != '*')
1323
/* Buffer must be released, yet caller does not use
1324
the Py_buffer protocol. */
1325
return converterr("pinned buffer", arg, msgbuf, bufsize);
1326
1327
1328
if (pb && pb->bf_getbuffer && *format == '*') {
1329
/* Caller is interested in Py_buffer, and the object
1330
supports it directly. */
1331
format++;
1332
if (PyObject_GetBuffer(arg, (Py_buffer*)p, PyBUF_WRITABLE) < 0) {
1333
PyErr_Clear();
1334
return converterr("read-write buffer", arg, msgbuf, bufsize);
1335
}
1336
if (addcleanup(p, freelist, cleanup_buffer)) {
1337
return converterr(
1338
"(cleanup problem)",
1339
arg, msgbuf, bufsize);
1340
}
1341
if (!PyBuffer_IsContiguous((Py_buffer*)p, 'C'))
1342
return converterr("contiguous buffer", arg, msgbuf, bufsize);
1343
break;
1344
}
1345
1346
/* Here we have processed w*, only w and w# remain. */
1347
if (pb == NULL ||
1348
pb->bf_getbuffer == NULL ||
1349
((temp = PyObject_GetBuffer(arg, &view,
1350
PyBUF_SIMPLE)) != 0) ||
1351
view.readonly == 1) {
1352
if (temp==0) {
1353
PyBuffer_Release(&view);
1354
}
1355
return converterr("single-segment read-write buffer",
1356
arg, msgbuf, bufsize);
1357
}
1358
1359
if ((count = view.len) < 0)
1360
return converterr("(unspecified)", arg, msgbuf, bufsize);
1361
*p = view.buf;
1362
if (*format == '#') {
1363
FETCH_SIZE;
1364
STORE_SIZE(count);
1365
format++;
1366
}
1367
break;
1368
}
1369
1370
/*TEO: This can be eliminated --- here only for backward
1371
compatibility */
1372
case 't': { /* 8-bit character buffer, read-only access */
1373
char **p = va_arg(*p_va, char **);
1374
PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1375
Py_ssize_t count;
1376
Py_buffer view;
1377
1378
if (*format++ != '#')
1379
return converterr(
1380
"invalid use of 't' format character",
1381
arg, msgbuf, bufsize);
1382
if (pb == NULL || pb->bf_getbuffer == NULL)
1383
return converterr(
1384
"bytes or read-only character buffer",
1385
arg, msgbuf, bufsize);
1386
1387
if (PyObject_GetBuffer(arg, &view, PyBUF_SIMPLE) != 0)
1388
return converterr("string or single-segment read-only buffer",
1389
arg, msgbuf, bufsize);
1390
1391
count = view.len;
1392
*p = view.buf;
1393
if (pb->bf_releasebuffer)
1394
return converterr(
1395
"string or pinned buffer",
1396
arg, msgbuf, bufsize);
1397
1398
PyBuffer_Release(&view);
1399
1400
if (count < 0)
1401
return converterr("(unspecified)", arg, msgbuf, bufsize);
1402
{
1403
FETCH_SIZE;
1404
STORE_SIZE(count);
1405
}
1406
break;
1407
}
1408
1409
default:
1410
return converterr("impossible<bad format char>", arg, msgbuf, bufsize);
1411
1412
}
1413
1414
*p_format = format;
1415
return NULL;
834
case 'c': {/* char */
835
char *p = va_arg(*p_va, char *);
836
if (PyBytes_Check(arg) && PyBytes_Size(arg) == 1)
837
*p = PyBytes_AS_STRING(arg)[0];
838
else
839
return converterr("a byte string of length 1", arg, msgbuf, bufsize);
840
break;
841
}
842
843
case 'C': {/* unicode char */
844
int *p = va_arg(*p_va, int *);
845
if (PyUnicode_Check(arg) &&
846
PyUnicode_GET_SIZE(arg) == 1)
847
*p = PyUnicode_AS_UNICODE(arg)[0];
848
else
849
return converterr("a unicode character", arg, msgbuf, bufsize);
850
break;
851
}
852
853
/* XXX WAAAAH! 's', 'y', 'z', 'u', 'Z', 'e', 'w', 't' codes all
854
need to be cleaned up! */
855
856
case 's': {/* text string */
857
if (*format == '*') {
858
Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);
859
860
if (PyUnicode_Check(arg)) {
861
uarg = UNICODE_DEFAULT_ENCODING(arg);
862
if (uarg == NULL)
863
return converterr(CONV_UNICODE,
864
arg, msgbuf, bufsize);
865
PyBuffer_FillInfo(p, arg,
866
PyBytes_AS_STRING(uarg), PyBytes_GET_SIZE(uarg),
867
1, 0);
868
}
869
else { /* any buffer-like object */
870
char *buf;
871
if (getbuffer(arg, p, &buf) < 0)
872
return converterr(buf, arg, msgbuf, bufsize);
873
}
874
if (addcleanup(p, freelist, cleanup_buffer)) {
875
return converterr(
876
"(cleanup problem)",
877
arg, msgbuf, bufsize);
878
}
879
format++;
880
} else if (*format == '#') {
881
void **p = (void **)va_arg(*p_va, char **);
882
FETCH_SIZE;
883
884
if (PyUnicode_Check(arg)) {
885
uarg = UNICODE_DEFAULT_ENCODING(arg);
886
if (uarg == NULL)
887
return converterr(CONV_UNICODE,
888
arg, msgbuf, bufsize);
889
*p = PyBytes_AS_STRING(uarg);
890
STORE_SIZE(PyBytes_GET_SIZE(uarg));
891
}
892
else { /* any buffer-like object */
893
/* XXX Really? */
894
char *buf;
895
Py_ssize_t count = convertbuffer(arg, p, &buf);
896
if (count < 0)
897
return converterr(buf, arg, msgbuf, bufsize);
898
STORE_SIZE(count);
899
}
900
format++;
901
} else {
902
char **p = va_arg(*p_va, char **);
903
904
if (PyUnicode_Check(arg)) {
905
uarg = UNICODE_DEFAULT_ENCODING(arg);
906
if (uarg == NULL)
907
return converterr(CONV_UNICODE,
908
arg, msgbuf, bufsize);
909
*p = PyBytes_AS_STRING(uarg);
910
}
911
else
912
return converterr("string", arg, msgbuf, bufsize);
913
if ((Py_ssize_t) strlen(*p) != PyBytes_GET_SIZE(uarg))
914
return converterr("string without null bytes",
915
arg, msgbuf, bufsize);
916
}
917
break;
918
}
919
920
case 'y': {/* any buffer-like object, but not PyUnicode */
921
void **p = (void **)va_arg(*p_va, char **);
922
char *buf;
923
Py_ssize_t count;
924
if (*format == '*') {
925
if (getbuffer(arg, (Py_buffer*)p, &buf) < 0)
926
return converterr(buf, arg, msgbuf, bufsize);
927
format++;
928
if (addcleanup(p, freelist, cleanup_buffer)) {
929
return converterr(
930
"(cleanup problem)",
931
arg, msgbuf, bufsize);
932
}
933
break;
934
}
935
count = convertbuffer(arg, p, &buf);
936
if (count < 0)
937
return converterr(buf, arg, msgbuf, bufsize);
938
else if (*format == '#') {
939
FETCH_SIZE;
940
STORE_SIZE(count);
941
format++;
942
}
943
break;
944
}
945
946
case 'z': {/* like 's' or 's#', but None is okay, stored as NULL */
947
if (*format == '*') {
948
Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);
949
950
if (arg == Py_None)
951
PyBuffer_FillInfo(p, NULL, NULL, 0, 1, 0);
952
else if (PyUnicode_Check(arg)) {
953
uarg = UNICODE_DEFAULT_ENCODING(arg);
954
if (uarg == NULL)
955
return converterr(CONV_UNICODE,
956
arg, msgbuf, bufsize);
957
PyBuffer_FillInfo(p, arg,
958
PyBytes_AS_STRING(uarg), PyBytes_GET_SIZE(uarg),
959
1, 0);
960
}
961
else { /* any buffer-like object */
962
char *buf;
963
if (getbuffer(arg, p, &buf) < 0)
964
return converterr(buf, arg, msgbuf, bufsize);
965
}
966
if (addcleanup(p, freelist, cleanup_buffer)) {
967
return converterr(
968
"(cleanup problem)",
969
arg, msgbuf, bufsize);
970
}
971
format++;
972
} else if (*format == '#') { /* any buffer-like object */
973
void **p = (void **)va_arg(*p_va, char **);
974
FETCH_SIZE;
975
976
if (arg == Py_None) {
977
*p = 0;
978
STORE_SIZE(0);
979
}
980
else if (PyUnicode_Check(arg)) {
981
uarg = UNICODE_DEFAULT_ENCODING(arg);
982
if (uarg == NULL)
983
return converterr(CONV_UNICODE,
984
arg, msgbuf, bufsize);
985
*p = PyBytes_AS_STRING(uarg);
986
STORE_SIZE(PyBytes_GET_SIZE(uarg));
987
}
988
else { /* any buffer-like object */
989
/* XXX Really? */
990
char *buf;
991
Py_ssize_t count = convertbuffer(arg, p, &buf);
992
if (count < 0)
993
return converterr(buf, arg, msgbuf, bufsize);
994
STORE_SIZE(count);
995
}
996
format++;
997
} else {
998
char **p = va_arg(*p_va, char **);
999
uarg = NULL;
1000
1001
if (arg == Py_None)
1002
*p = 0;
1003
else if (PyBytes_Check(arg)) {
1004
/* Enable null byte check below */
1005
uarg = arg;
1006
*p = PyBytes_AS_STRING(arg);
1007
}
1008
else if (PyUnicode_Check(arg)) {
1009
uarg = UNICODE_DEFAULT_ENCODING(arg);
1010
if (uarg == NULL)
1011
return converterr(CONV_UNICODE,
1012
arg, msgbuf, bufsize);
1013
*p = PyBytes_AS_STRING(uarg);
1014
}
1015
else
1016
return converterr("string or None",
1017
arg, msgbuf, bufsize);
1018
if (*format == '#') {
1019
FETCH_SIZE;
1020
assert(0); /* XXX redundant with if-case */
1021
if (arg == Py_None) {
1022
STORE_SIZE(0);
1023
}
1024
else {
1025
STORE_SIZE(PyBytes_Size(arg));
1026
}
1027
format++;
1028
}
1029
else if (*p != NULL && uarg != NULL &&
1030
(Py_ssize_t) strlen(*p) != PyBytes_GET_SIZE(uarg))
1031
return converterr(
1032
"string without null bytes or None",
1033
arg, msgbuf, bufsize);
1034
}
1035
break;
1036
}
1037
1038
case 'Z': {/* unicode, may be NULL (None) */
1039
if (*format == '#') { /* any buffer-like object */
1040
Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
1041
FETCH_SIZE;
1042
1043
if (arg == Py_None) {
1044
*p = 0;
1045
STORE_SIZE(0);
1046
}
1047
else if (PyUnicode_Check(arg)) {
1048
*p = PyUnicode_AS_UNICODE(arg);
1049
STORE_SIZE(PyUnicode_GET_SIZE(arg));
1050
}
1051
else
1052
return converterr("str or None", arg, msgbuf, bufsize);
1053
format++;
1054
} else {
1055
Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
1056
1057
if (arg == Py_None)
1058
*p = 0;
1059
else if (PyUnicode_Check(arg))
1060
*p = PyUnicode_AS_UNICODE(arg);
1061
else
1062
return converterr("str or None", arg, msgbuf, bufsize);
1063
}
1064
break;
1065
}
1066
1067
case 'e': {/* encoded string */
1068
char **buffer;
1069
const char *encoding;
1070
PyObject *s;
1071
int recode_strings;
1072
Py_ssize_t size;
1073
const char *ptr;
1074
1075
/* Get 'e' parameter: the encoding name */
1076
encoding = (const char *)va_arg(*p_va, const char *);
1077
if (encoding == NULL)
1078
encoding = PyUnicode_GetDefaultEncoding();
1079
1080
/* Get output buffer parameter:
1081
's' (recode all objects via Unicode) or
1082
't' (only recode non-string objects)
1083
*/
1084
if (*format == 's')
1085
recode_strings = 1;
1086
else if (*format == 't')
1087
recode_strings = 0;
1088
else
1089
return converterr(
1090
"(unknown parser marker combination)",
1091
arg, msgbuf, bufsize);
1092
buffer = (char **)va_arg(*p_va, char **);
1093
format++;
1094
if (buffer == NULL)
1095
return converterr("(buffer is NULL)",
1096
arg, msgbuf, bufsize);
1097
1098
/* Encode object */
1099
if (!recode_strings &&
1100
(PyBytes_Check(arg) || PyByteArray_Check(arg))) {
1101
s = arg;
1102
Py_INCREF(s);
1103
if (PyObject_AsCharBuffer(s, &ptr, &size) < 0)
1104
return converterr("(AsCharBuffer failed)",
1105
arg, msgbuf, bufsize);
1106
}
1107
else {
1108
PyObject *u;
1109
1110
/* Convert object to Unicode */
1111
u = PyUnicode_FromObject(arg);
1112
if (u == NULL)
1113
return converterr(
1114
"string or unicode or text buffer",
1115
arg, msgbuf, bufsize);
1116
1117
/* Encode object; use default error handling */
1118
s = PyUnicode_AsEncodedString(u,
1119
encoding,
1120
NULL);
1121
Py_DECREF(u);
1122
if (s == NULL)
1123
return converterr("(encoding failed)",
1124
arg, msgbuf, bufsize);
1125
if (!PyBytes_Check(s)) {
1126
Py_DECREF(s);
1127
return converterr(
1128
"(encoder failed to return bytes)",
1129
arg, msgbuf, bufsize);
1130
}
1131
size = PyBytes_GET_SIZE(s);
1132
ptr = PyBytes_AS_STRING(s);
1133
if (ptr == NULL)
1134
ptr = "";
1135
}
1136
1137
/* Write output; output is guaranteed to be 0-terminated */
1138
if (*format == '#') {
1139
/* Using buffer length parameter '#':
1140
1141
- if *buffer is NULL, a new buffer of the
1142
needed size is allocated and the data
1143
copied into it; *buffer is updated to point
1144
to the new buffer; the caller is
1145
responsible for PyMem_Free()ing it after
1146
usage
1147
1148
- if *buffer is not NULL, the data is
1149
copied to *buffer; *buffer_len has to be
1150
set to the size of the buffer on input;
1151
buffer overflow is signalled with an error;
1152
buffer has to provide enough room for the
1153
encoded string plus the trailing 0-byte
1154
1155
- in both cases, *buffer_len is updated to
1156
the size of the buffer /excluding/ the
1157
trailing 0-byte
1158
1159
*/
1160
FETCH_SIZE;
1161
1162
format++;
1163
if (q == NULL && q2 == NULL) {
1164
Py_DECREF(s);
1165
return converterr(
1166
"(buffer_len is NULL)",
1167
arg, msgbuf, bufsize);
1168
}
1169
if (*buffer == NULL) {
1170
*buffer = PyMem_NEW(char, size + 1);
1171
if (*buffer == NULL) {
1172
Py_DECREF(s);
1173
return converterr(
1174
"(memory error)",
1175
arg, msgbuf, bufsize);
1176
}
1177
if (addcleanup(*buffer, freelist, cleanup_ptr)) {
1178
Py_DECREF(s);
1179
return converterr(
1180
"(cleanup problem)",
1181
arg, msgbuf, bufsize);
1182
}
1183
} else {
1184
if (size + 1 > BUFFER_LEN) {
1185
Py_DECREF(s);
1186
return converterr(
1187
"(buffer overflow)",
1188
arg, msgbuf, bufsize);
1189
}
1190
}
1191
memcpy(*buffer, ptr, size+1);
1192
STORE_SIZE(size);
1193
} else {
1194
/* Using a 0-terminated buffer:
1195
1196
- the encoded string has to be 0-terminated
1197
for this variant to work; if it is not, an
1198
error raised
1199
1200
- a new buffer of the needed size is
1201
allocated and the data copied into it;
1202
*buffer is updated to point to the new
1203
buffer; the caller is responsible for
1204
PyMem_Free()ing it after usage
1205
1206
*/
1207
if ((Py_ssize_t)strlen(ptr) != size) {
1208
Py_DECREF(s);
1209
return converterr(
1210
"encoded string without NULL bytes",
1211
arg, msgbuf, bufsize);
1212
}
1213
*buffer = PyMem_NEW(char, size + 1);
1214
if (*buffer == NULL) {
1215
Py_DECREF(s);
1216
return converterr("(memory error)",
1217
arg, msgbuf, bufsize);
1218
}
1219
if (addcleanup(*buffer, freelist, cleanup_ptr)) {
1220
Py_DECREF(s);
1221
return converterr("(cleanup problem)",
1222
arg, msgbuf, bufsize);
1223
}
1224
memcpy(*buffer, ptr, size+1);
1225
}
1226
Py_DECREF(s);
1227
break;
1228
}
1229
1230
case 'u': {/* raw unicode buffer (Py_UNICODE *) */
1231
Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
1232
if (!PyUnicode_Check(arg))
1233
return converterr("str", arg, msgbuf, bufsize);
1234
*p = PyUnicode_AS_UNICODE(arg);
1235
if (*format == '#') { /* store pointer and size */
1236
FETCH_SIZE;
1237
STORE_SIZE(PyUnicode_GET_SIZE(arg));
1238
format++;
1239
}
1240
break;
1241
}
1242
1243
case 'S': { /* PyBytes object */
1244
PyObject **p = va_arg(*p_va, PyObject **);
1245
if (PyBytes_Check(arg))
1246
*p = arg;
1247
else
1248
return converterr("bytes", arg, msgbuf, bufsize);
1249
break;
1250
}
1251
1252
case 'Y': { /* PyByteArray object */
1253
PyObject **p = va_arg(*p_va, PyObject **);
1254
if (PyByteArray_Check(arg))
1255
*p = arg;
1256
else
1257
return converterr("bytearray", arg, msgbuf, bufsize);
1258
break;
1259
}
1260
1261
case 'U': { /* PyUnicode object */
1262
PyObject **p = va_arg(*p_va, PyObject **);
1263
if (PyUnicode_Check(arg))
1264
*p = arg;
1265
else
1266
return converterr("str", arg, msgbuf, bufsize);
1267
break;
1268
}
1269
1270
case 'O': { /* object */
1271
PyTypeObject *type;
1272
PyObject **p;
1273
if (*format == '!') {
1274
type = va_arg(*p_va, PyTypeObject*);
1275
p = va_arg(*p_va, PyObject **);
1276
format++;
1277
if (PyType_IsSubtype(arg->ob_type, type))
1278
*p = arg;
1279
else
1280
return converterr(type->tp_name, arg, msgbuf, bufsize);
1281
1282
}
1283
else if (*format == '?') {
1284
inquiry pred = va_arg(*p_va, inquiry);
1285
p = va_arg(*p_va, PyObject **);
1286
format++;
1287
if ((*pred)(arg))
1288
*p = arg;
1289
else
1290
return converterr("(unspecified)",
1291
arg, msgbuf, bufsize);
1292
1293
}
1294
else if (*format == '&') {
1295
typedef int (*converter)(PyObject *, void *);
1296
converter convert = va_arg(*p_va, converter);
1297
void *addr = va_arg(*p_va, void *);
1298
int res;
1299
format++;
1300
if (! (res = (*convert)(arg, addr)))
1301
return converterr("(unspecified)",
1302
arg, msgbuf, bufsize);
1303
if (res == Py_CLEANUP_SUPPORTED &&
1304
addcleanup_convert(addr, freelist, convert) == -1)
1305
return converterr("(cleanup problem)",
1306
arg, msgbuf, bufsize);
1307
}
1308
else {
1309
p = va_arg(*p_va, PyObject **);
1310
*p = arg;
1311
}
1312
break;
1313
}
1314
1315
1316
case 'w': { /* memory buffer, read-write access */
1317
void **p = va_arg(*p_va, void **);
1318
PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1319
Py_ssize_t count;
1320
int temp=-1;
1321
Py_buffer view;
1322
1323
if (pb && pb->bf_releasebuffer && *format != '*')
1324
/* Buffer must be released, yet caller does not use
1325
the Py_buffer protocol. */
1326
return converterr("pinned buffer", arg, msgbuf, bufsize);
1327
1328
1329
if (pb && pb->bf_getbuffer && *format == '*') {
1330
/* Caller is interested in Py_buffer, and the object
1331
supports it directly. */
1332
format++;
1333
if (PyObject_GetBuffer(arg, (Py_buffer*)p, PyBUF_WRITABLE) < 0) {
1334
PyErr_Clear();
1335
return converterr("read-write buffer", arg, msgbuf, bufsize);
1336
}
1337
if (addcleanup(p, freelist, cleanup_buffer)) {
1338
return converterr(
1339
"(cleanup problem)",
1340
arg, msgbuf, bufsize);
1341
}
1342
if (!PyBuffer_IsContiguous((Py_buffer*)p, 'C'))
1343
return converterr("contiguous buffer", arg, msgbuf, bufsize);
1344
break;
1345
}
1346
1347
/* Here we have processed w*, only w and w# remain. */
1348
if (pb == NULL ||
1349
pb->bf_getbuffer == NULL ||
1350
((temp = PyObject_GetBuffer(arg, &view,
1351
PyBUF_SIMPLE)) != 0) ||
1352
view.readonly == 1) {
1353
if (temp==0) {
1354
PyBuffer_Release(&view);
1355
}
1356
return converterr("single-segment read-write buffer",
1357
arg, msgbuf, bufsize);
1358
}
1359
1360
if ((count = view.len) < 0)
1361
return converterr("(unspecified)", arg, msgbuf, bufsize);
1362
*p = view.buf;
1363
if (*format == '#') {
1364
FETCH_SIZE;
1365
STORE_SIZE(count);
1366
format++;
1367
}
1368
break;
1369
}
1370
1371
/*TEO: This can be eliminated --- here only for backward
1372
compatibility */
1373
case 't': { /* 8-bit character buffer, read-only access */
1374
char **p = va_arg(*p_va, char **);
1375
PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1376
Py_ssize_t count;
1377
Py_buffer view;
1378
1379
if (*format++ != '#')
1380
return converterr(
1381
"invalid use of 't' format character",
1382
arg, msgbuf, bufsize);
1383
if (pb == NULL || pb->bf_getbuffer == NULL)
1384
return converterr(
1385
"bytes or read-only character buffer",
1386
arg, msgbuf, bufsize);
1387
if (pb->bf_releasebuffer)
1388
return converterr(
1389
"string or pinned buffer",
1390
arg, msgbuf, bufsize);
1391
1392
if (PyObject_GetBuffer(arg, &view, PyBUF_SIMPLE) != 0)
1393
return converterr("string or single-segment read-only buffer",
1394
arg, msgbuf, bufsize);
1395
1396
count = view.len;
1397
*p = view.buf;
1398
1399
PyBuffer_Release(&view);
1400
1401
if (count < 0)
1402
return converterr("(unspecified)", arg, msgbuf, bufsize);
1403
{
1404
FETCH_SIZE;
1405
STORE_SIZE(count);
1406
}
1407
break;
1408
}
1409
1410
default:
1411
return converterr("impossible<bad format char>", arg, msgbuf, bufsize);
1412
1413
}
1414
1415
*p_format = format;
1416
return NULL;
1416
1417
}
1417
1418
1418
1419
static Py_ssize_t
1419
1420
convertbuffer(PyObject *arg, void **p, char **errmsg)
1420
1421
{
1421
PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1422
Py_ssize_t count;
1423
Py_buffer view;
1424
1425
*errmsg = NULL;
1426
*p = NULL;
1427
if (pb == NULL ||
1428
pb->bf_getbuffer == NULL ||
1429
pb->bf_releasebuffer != NULL) {
1430
*errmsg = "bytes or read-only buffer";
1431
return -1;
1432
}
1433
1434
if (PyObject_GetBuffer(arg, &view, PyBUF_SIMPLE) != 0) {
1435
*errmsg = "bytes or single-segment read-only buffer";
1436
return -1;
1437
}
1438
count = view.len;
1439
*p = view.buf;
1440
PyBuffer_Release(&view);
1441
return count;
1422
PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1423
Py_ssize_t count;
1424
Py_buffer view;
1425
1426
*errmsg = NULL;
1427
*p = NULL;
1428
if (pb == NULL ||
1429
pb->bf_getbuffer == NULL ||
1430
pb->bf_releasebuffer != NULL) {
1431
*errmsg = "bytes or read-only buffer";
1432
return -1;
1433
}
1434
1435
if (PyObject_GetBuffer(arg, &view, PyBUF_SIMPLE) != 0) {
1436
*errmsg = "bytes or single-segment read-only buffer";
1437
return -1;
1438
}
1439
count = view.len;
1440
*p = view.buf;
1441
PyBuffer_Release(&view);
1442
return count;
1442
1443
}
1443
1444
1444
1445
/* XXX for 3.x, getbuffer and convertbuffer can probably
1446
1447
static int
1447
1448
getbuffer(PyObject *arg, Py_buffer *view, char **errmsg)
1448
1449
{
1449
void *buf;
1450
Py_ssize_t count;
1451
PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1452
if (pb == NULL) {
1453
*errmsg = "bytes or buffer";
1454
return -1;
1455
}
1456
if (pb->bf_getbuffer) {
1457
if (PyObject_GetBuffer(arg, view, 0) < 0) {
1458
*errmsg = "convertible to a buffer";
1459
return -1;
1460
}
1461
if (!PyBuffer_IsContiguous(view, 'C')) {
1462
*errmsg = "contiguous buffer";
1463
return -1;
1464
}
1465
return 0;
1466
}
1450
void *buf;
1451
Py_ssize_t count;
1452
PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1453
if (pb == NULL) {
1454
*errmsg = "bytes or buffer";
1455
return -1;
1456
}
1457
if (pb->bf_getbuffer) {
1458
if (PyObject_GetBuffer(arg, view, 0) < 0) {
1459
*errmsg = "convertible to a buffer";
1460
return -1;
1461
}
1462
if (!PyBuffer_IsContiguous(view, 'C')) {
1463
PyBuffer_Release(view);
1464
*errmsg = "contiguous buffer";
1465
return -1;
1466
}
1467
return 0;
1468
}
1467
1469
1468
count = convertbuffer(arg, &buf, errmsg);
1469
if (count < 0) {
1470
*errmsg = "convertible to a buffer";
1471
return count;
1472
}
1473
PyBuffer_FillInfo(view, NULL, buf, count, 1, 0);
1474
return 0;
1470
count = convertbuffer(arg, &buf, errmsg);
1471
if (count < 0) {
1472
*errmsg = "convertible to a buffer";
1473
return count;
1474
}
1475
PyBuffer_FillInfo(view, NULL, buf, count, 1, 0);
1476
return 0;
1475
1477
}
1476
1478
1477
1479
/* Support for keyword arguments donated by
1480
1482
/* Return false (0) for error, else true. */
1481
1483
int
1482
1484
PyArg_ParseTupleAndKeywords(PyObject *args,
1483
PyObject *keywords,
1484
const char *format,
1485
char **kwlist, ...)
1485
PyObject *keywords,
1486
const char *format,
1487
char **kwlist, ...)
1486
1488
{
1487
int retval;
1488
va_list va;
1489
1490
if ((args == NULL || !PyTuple_Check(args)) ||
1491
(keywords != NULL && !PyDict_Check(keywords)) ||
1492
format == NULL ||
1493
kwlist == NULL)
1494
{
1495
PyErr_BadInternalCall();
1496
return 0;
1497
}
1498
1499
va_start(va, kwlist);
1500
retval = vgetargskeywords(args, keywords, format, kwlist, &va, 0);
1501
va_end(va);
1502
return retval;
1489
int retval;
1490
va_list va;
1491
1492
if ((args == NULL || !PyTuple_Check(args)) ||
1493
(keywords != NULL && !PyDict_Check(keywords)) ||
1494
format == NULL ||
1495
kwlist == NULL)
1496
{
1497
PyErr_BadInternalCall();
1498
return 0;
1499
}
1500
1501
va_start(va, kwlist);
1502
retval = vgetargskeywords(args, keywords, format, kwlist, &va, 0);
1503
va_end(va);
1504
return retval;
1503
1505
}
1504
1506
1505
1507
int
1506
1508
_PyArg_ParseTupleAndKeywords_SizeT(PyObject *args,
1507
PyObject *keywords,
1508
const char *format,
1509
char **kwlist, ...)
1509
PyObject *keywords,
1510
const char *format,
1511
char **kwlist, ...)
1510
1512
{
1511
int retval;
1512
va_list va;
1513
1514
if ((args == NULL || !PyTuple_Check(args)) ||
1515
(keywords != NULL && !PyDict_Check(keywords)) ||
1516
format == NULL ||
1517
kwlist == NULL)
1518
{
1519
PyErr_BadInternalCall();
1520
return 0;
1521
}
1522
1523
va_start(va, kwlist);
1524
retval = vgetargskeywords(args, keywords, format,
1525
kwlist, &va, FLAG_SIZE_T);
1526
va_end(va);
1527
return retval;
1513
int retval;
1514
va_list va;
1515
1516
if ((args == NULL || !PyTuple_Check(args)) ||
1517
(keywords != NULL && !PyDict_Check(keywords)) ||
1518
format == NULL ||
1519
kwlist == NULL)
1520
{
1521
PyErr_BadInternalCall();
1522
return 0;
1523
}
1524
1525
va_start(va, kwlist);
1526
retval = vgetargskeywords(args, keywords, format,
1527
kwlist, &va, FLAG_SIZE_T);
1528
va_end(va);
1529
return retval;
1528
1530
}
1529
1531
1530
1532
1534
1536
const char *format,
1535
1537
char **kwlist, va_list va)
1536
1538
{
1537
int retval;
1538
va_list lva;
1539
int retval;
1540
va_list lva;
1539
1541
1540
if ((args == NULL || !PyTuple_Check(args)) ||
1541
(keywords != NULL && !PyDict_Check(keywords)) ||
1542
format == NULL ||
1543
kwlist == NULL)
1544
{
1545
PyErr_BadInternalCall();
1546
return 0;
1547
}
1542
if ((args == NULL || !PyTuple_Check(args)) ||
1543
(keywords != NULL && !PyDict_Check(keywords)) ||
1544
format == NULL ||
1545
kwlist == NULL)
1546
{
1547
PyErr_BadInternalCall();
1548
return 0;
1549
}
1548
1550
1549
1551
#ifdef VA_LIST_IS_ARRAY
1550
memcpy(lva, va, sizeof(va_list));
1552
memcpy(lva, va, sizeof(va_list));
1551
1553
#else
1552
1554
#ifdef __va_copy
1553
__va_copy(lva, va);
1555
__va_copy(lva, va);
1554
1556
#else
1555
lva = va;
1557
lva = va;
1556
1558
#endif
1557
1559
#endif
1558
1560
1559
retval = vgetargskeywords(args, keywords, format, kwlist, &lva, 0);
1560
return retval;
1561
retval = vgetargskeywords(args, keywords, format, kwlist, &lva, 0);
1562
return retval;
1561
1563
}
1562
1564
1563
1565
int
1564
1566
_PyArg_VaParseTupleAndKeywords_SizeT(PyObject *args,
1565
PyObject *keywords,
1566
const char *format,
1567
char **kwlist, va_list va)
1567
PyObject *keywords,
1568
const char *format,
1569
char **kwlist, va_list va)
1568
1570
{
1569
int retval;
1570
va_list lva;
1571
int retval;
1572
va_list lva;
1571
1573
1572
if ((args == NULL || !PyTuple_Check(args)) ||
1573
(keywords != NULL && !PyDict_Check(keywords)) ||
1574
format == NULL ||
1575
kwlist == NULL)
1576
{
1577
PyErr_BadInternalCall();
1578
return 0;
1579
}
1574
if ((args == NULL || !PyTuple_Check(args)) ||
1575
(keywords != NULL && !PyDict_Check(keywords)) ||
1576
format == NULL ||
1577
kwlist == NULL)
1578
{
1579
PyErr_BadInternalCall();
1580
return 0;
1581
}
1580
1582
1581
1583
#ifdef VA_LIST_IS_ARRAY
1582
memcpy(lva, va, sizeof(va_list));
1584
memcpy(lva, va, sizeof(va_list));
1583
1585
#else
1584
1586
#ifdef __va_copy
1585
__va_copy(lva, va);
1587
__va_copy(lva, va);
1586
1588
#else
1587
lva = va;
1589
lva = va;
1588
1590
#endif
1589
1591
#endif
1590
1592
1591
retval = vgetargskeywords(args, keywords, format,
1592
kwlist, &lva, FLAG_SIZE_T);
1593
return retval;
1593
retval = vgetargskeywords(args, keywords, format,
1594
kwlist, &lva, FLAG_SIZE_T);
1595
return retval;
1594
1596
}
1595
1597
1596
1598
#define IS_END_OF_FORMAT(c) (c == '\0' || c == ';' || c == ':')
1597
1599
1598
1600
static int
1599
1601
vgetargskeywords(PyObject *args, PyObject *keywords, const char *format,
1600
char **kwlist, va_list *p_va, int flags)
1602
char **kwlist, va_list *p_va, int flags)
1601
1603
{
1602
char msgbuf[512];
1603
int levels[32];
1604
const char *fname, *msg, *custom_msg, *keyword;
1605
int min = INT_MAX;
1606
int i, len, nargs, nkeywords;
1607
PyObject *freelist = NULL, *current_arg;
1608
1609
assert(args != NULL && PyTuple_Check(args));
1610
assert(keywords == NULL || PyDict_Check(keywords));
1611
assert(format != NULL);
1612
assert(kwlist != NULL);
1613
assert(p_va != NULL);
1614
1615
/* grab the function name or custom error msg first (mutually exclusive) */
1616
fname = strchr(format, ':');
1617
if (fname) {
1618
fname++;
1619
custom_msg = NULL;
1620
}
1621
else {
1622
custom_msg = strchr(format,';');
1623
if (custom_msg)
1624
custom_msg++;
1625
}
1626
1627
/* scan kwlist and get greatest possible nbr of args */
1628
for (len=0; kwlist[len]; len++)
1629
continue;
1630
1631
nargs = PyTuple_GET_SIZE(args);
1632
nkeywords = (keywords == NULL) ? 0 : PyDict_Size(keywords);
1633
if (nargs + nkeywords > len) {
1634
PyErr_Format(PyExc_TypeError, "%s%s takes at most %d "
1635
"argument%s (%d given)",
1636
(fname == NULL) ? "function" : fname,
1637
(fname == NULL) ? "" : "()",
1638
len,
1639
(len == 1) ? "" : "s",
1640
nargs + nkeywords);
1641
return 0;
1642
}
1643
1644
/* convert tuple args and keyword args in same loop, using kwlist to drive process */
1645
for (i = 0; i < len; i++) {
1646
keyword = kwlist[i];
1647
if (*format == '|') {
1648
min = i;
1649
format++;
1650
}
1651
if (IS_END_OF_FORMAT(*format)) {
1652
PyErr_Format(PyExc_RuntimeError,
1653
"More keyword list entries (%d) than "
1654
"format specifiers (%d)", len, i);
1655
return cleanreturn(0, freelist);
1656
}
1657
current_arg = NULL;
1658
if (nkeywords) {
1659
current_arg = PyDict_GetItemString(keywords, keyword);
1660
}
1661
if (current_arg) {
1662
--nkeywords;
1663
if (i < nargs) {
1664
/* arg present in tuple and in dict */
1665
PyErr_Format(PyExc_TypeError,
1666
"Argument given by name ('%s') "
1667
"and position (%d)",
1668
keyword, i+1);
1669
return cleanreturn(0, freelist);
1670
}
1671
}
1672
else if (nkeywords && PyErr_Occurred())
1673
return cleanreturn(0, freelist);
1674
else if (i < nargs)
1675
current_arg = PyTuple_GET_ITEM(args, i);
1676
1677
if (current_arg) {
1678
msg = convertitem(current_arg, &format, p_va, flags,
1679
levels, msgbuf, sizeof(msgbuf), &freelist);
1680
if (msg) {
1681
seterror(i+1, msg, levels, fname, custom_msg);
1682
return cleanreturn(0, freelist);
1683
}
1684
continue;
1685
}
1686
1687
if (i < min) {
1688
PyErr_Format(PyExc_TypeError, "Required argument "
1689
"'%s' (pos %d) not found",
1690
keyword, i+1);
1691
return cleanreturn(0, freelist);
1692
}
1693
/* current code reports success when all required args
1694
* fulfilled and no keyword args left, with no further
1695
* validation. XXX Maybe skip this in debug build ?
1696
*/
1697
if (!nkeywords)
1698
return cleanreturn(1, freelist);
1699
1700
/* We are into optional args, skip thru to any remaining
1701
* keyword args */
1702
msg = skipitem(&format, p_va, flags);
1703
if (msg) {
1704
PyErr_Format(PyExc_RuntimeError, "%s: '%s'", msg,
1705
format);
1706
return cleanreturn(0, freelist);
1707
}
1708
}
1709
1710
if (!IS_END_OF_FORMAT(*format) && *format != '|') {
1711
PyErr_Format(PyExc_RuntimeError,
1712
"more argument specifiers than keyword list entries "
1713
"(remaining format:'%s')", format);
1714
return cleanreturn(0, freelist);
1715
}
1716
1717
/* make sure there are no extraneous keyword arguments */
1718
if (nkeywords > 0) {
1719
PyObject *key, *value;
1720
Py_ssize_t pos = 0;
1721
while (PyDict_Next(keywords, &pos, &key, &value)) {
1722
int match = 0;
1723
char *ks;
1724
if (!PyUnicode_Check(key)) {
1725
PyErr_SetString(PyExc_TypeError,
1726
"keywords must be strings");
1727
return cleanreturn(0, freelist);
1728
}
1729
ks = _PyUnicode_AsString(key);
1730
for (i = 0; i < len; i++) {
1731
if (!strcmp(ks, kwlist[i])) {
1732
match = 1;
1733
break;
1734
}
1735
}
1736
if (!match) {
1737
PyErr_Format(PyExc_TypeError,
1738
"'%s' is an invalid keyword "
1739
"argument for this function",
1740
ks);
1741
return cleanreturn(0, freelist);
1742
}
1743
}
1744
}
1745
1746
return cleanreturn(1, freelist);
1604
char msgbuf[512];
1605
int levels[32];
1606
const char *fname, *msg, *custom_msg, *keyword;
1607
int min = INT_MAX;
1608
int i, len, nargs, nkeywords;
1609
PyObject *freelist = NULL, *current_arg;
1610
1611
assert(args != NULL && PyTuple_Check(args));
1612
assert(keywords == NULL || PyDict_Check(keywords));
1613
assert(format != NULL);
1614
assert(kwlist != NULL);
1615
assert(p_va != NULL);
1616
1617
/* grab the function name or custom error msg first (mutually exclusive) */
1618
fname = strchr(format, ':');
1619
if (fname) {
1620
fname++;
1621
custom_msg = NULL;
1622
}
1623
else {
1624
custom_msg = strchr(format,';');
1625
if (custom_msg)
1626
custom_msg++;
1627
}
1628
1629
/* scan kwlist and get greatest possible nbr of args */
1630
for (len=0; kwlist[len]; len++)
1631
continue;
1632
1633
nargs = PyTuple_GET_SIZE(args);
1634
nkeywords = (keywords == NULL) ? 0 : PyDict_Size(keywords);
1635
if (nargs + nkeywords > len) {
1636
PyErr_Format(PyExc_TypeError, "%s%s takes at most %d "
1637
"argument%s (%d given)",
1638
(fname == NULL) ? "function" : fname,
1639
(fname == NULL) ? "" : "()",
1640
len,
1641
(len == 1) ? "" : "s",
1642
nargs + nkeywords);
1643
return 0;
1644
}
1645
1646
/* convert tuple args and keyword args in same loop, using kwlist to drive process */
1647
for (i = 0; i < len; i++) {
1648
keyword = kwlist[i];
1649
if (*format == '|') {
1650
min = i;
1651
format++;
1652
}
1653
if (IS_END_OF_FORMAT(*format)) {
1654
PyErr_Format(PyExc_RuntimeError,
1655
"More keyword list entries (%d) than "
1656
"format specifiers (%d)", len, i);
1657
return cleanreturn(0, freelist);
1658
}
1659
current_arg = NULL;
1660
if (nkeywords) {
1661
current_arg = PyDict_GetItemString(keywords, keyword);
1662
}
1663
if (current_arg) {
1664
--nkeywords;
1665
if (i < nargs) {
1666
/* arg present in tuple and in dict */
1667
PyErr_Format(PyExc_TypeError,
1668
"Argument given by name ('%s') "
1669
"and position (%d)",
1670
keyword, i+1);
1671
return cleanreturn(0, freelist);
1672
}
1673
}
1674
else if (nkeywords && PyErr_Occurred())
1675
return cleanreturn(0, freelist);
1676
else if (i < nargs)
1677
current_arg = PyTuple_GET_ITEM(args, i);
1678
1679
if (current_arg) {
1680
msg = convertitem(current_arg, &format, p_va, flags,
1681
levels, msgbuf, sizeof(msgbuf), &freelist);
1682
if (msg) {
1683
seterror(i+1, msg, levels, fname, custom_msg);
1684
return cleanreturn(0, freelist);
1685
}
1686
continue;
1687
}
1688
1689
if (i < min) {
1690
PyErr_Format(PyExc_TypeError, "Required argument "
1691
"'%s' (pos %d) not found",
1692
keyword, i+1);
1693
return cleanreturn(0, freelist);
1694
}
1695
/* current code reports success when all required args
1696
* fulfilled and no keyword args left, with no further
1697
* validation. XXX Maybe skip this in debug build ?
1698
*/
1699
if (!nkeywords)
1700
return cleanreturn(1, freelist);
1701
1702
/* We are into optional args, skip thru to any remaining
1703
* keyword args */
1704
msg = skipitem(&format, p_va, flags);
1705
if (msg) {
1706
PyErr_Format(PyExc_RuntimeError, "%s: '%s'", msg,
1707
format);
1708
return cleanreturn(0, freelist);
1709
}
1710
}
1711
1712
if (!IS_END_OF_FORMAT(*format) && *format != '|') {
1713
PyErr_Format(PyExc_RuntimeError,
1714
"more argument specifiers than keyword list entries "
1715
"(remaining format:'%s')", format);
1716
return cleanreturn(0, freelist);
1717
}
1718
1719
/* make sure there are no extraneous keyword arguments */
1720
if (nkeywords > 0) {
1721
PyObject *key, *value;
1722
Py_ssize_t pos = 0;
1723
while (PyDict_Next(keywords, &pos, &key, &value)) {
1724
int match = 0;
1725
char *ks;
1726
if (!PyUnicode_Check(key)) {
1727
PyErr_SetString(PyExc_TypeError,
1728
"keywords must be strings");
1729
return cleanreturn(0, freelist);
1730
}
1731
ks = _PyUnicode_AsString(key);
1732
for (i = 0; i < len; i++) {
1733
if (!strcmp(ks, kwlist[i])) {
1734
match = 1;
1735
break;
1736
}
1737
}
1738
if (!match) {
1739
PyErr_Format(PyExc_TypeError,
1740
"'%s' is an invalid keyword "
1741
"argument for this function",
1742
ks);
1743
return cleanreturn(0, freelist);
1744
}
1745
}
1746
}
1747
1748
return cleanreturn(1, freelist);
1747
1749
}
1748
1750
1749
1751
1750
1752
static char *
1751
1753
skipitem(const char **p_format, va_list *p_va, int flags)
1752
1754
{
1753
const char *format = *p_format;
1754
char c = *format++;
1755
1756
switch (c) {
1757
1758
/* simple codes
1759
* The individual types (second arg of va_arg) are irrelevant */
1760
1761
case 'b': /* byte -- very short int */
1762
case 'B': /* byte as bitfield */
1763
case 'h': /* short int */
1764
case 'H': /* short int as bitfield */
1765
case 'i': /* int */
1766
case 'I': /* int sized bitfield */
1767
case 'l': /* long int */
1768
case 'k': /* long int sized bitfield */
1755
const char *format = *p_format;
1756
char c = *format++;
1757
1758
switch (c) {
1759
1760
/* simple codes
1761
* The individual types (second arg of va_arg) are irrelevant */
1762
1763
case 'b': /* byte -- very short int */
1764
case 'B': /* byte as bitfield */
1765
case 'h': /* short int */
1766
case 'H': /* short int as bitfield */
1767
case 'i': /* int */
1768
case 'I': /* int sized bitfield */
1769
case 'l': /* long int */
1770
case 'k': /* long int sized bitfield */
1769
1771
#ifdef HAVE_LONG_LONG
1770
case 'L': /* PY_LONG_LONG */
1771
case 'K': /* PY_LONG_LONG sized bitfield */
1772
case 'L': /* PY_LONG_LONG */
1773
case 'K': /* PY_LONG_LONG sized bitfield */
1772
1774
#endif
1773
case 'f': /* float */
1774
case 'd': /* double */
1775
case 'f': /* float */
1776
case 'd': /* double */
1775
1777
#ifndef WITHOUT_COMPLEX
1776
case 'D': /* complex double */
1778
case 'D': /* complex double */
1777
1779
#endif
1778
case 'c': /* char */
1779
case 'C': /* unicode char */
1780
{
1781
(void) va_arg(*p_va, void *);
1782
break;
1783
}
1784
1785
case 'n': /* Py_ssize_t */
1786
{
1787
(void) va_arg(*p_va, Py_ssize_t *);
1788
break;
1789
}
1790
1791
/* string codes */
1792
1793
case 'e': /* string with encoding */
1794
{
1795
(void) va_arg(*p_va, const char *);
1796
if (!(*format == 's' || *format == 't'))
1797
/* after 'e', only 's' and 't' is allowed */
1798
goto err;
1799
format++;
1800
/* explicit fallthrough to string cases */
1801
}
1802
1803
case 's': /* string */
1804
case 'z': /* string or None */
1805
case 'y': /* bytes */
1806
case 'u': /* unicode string */
1807
case 't': /* buffer, read-only */
1808
case 'w': /* buffer, read-write */
1809
{
1810
(void) va_arg(*p_va, char **);
1811
if (*format == '#') {
1812
if (flags & FLAG_SIZE_T)
1813
(void) va_arg(*p_va, Py_ssize_t *);
1814
else
1815
(void) va_arg(*p_va, int *);
1816
format++;
1817
} else if ((c == 's' || c == 'z' || c == 'y') && *format == '*') {
1818
format++;
1819
}
1820
break;
1821
}
1822
1823
/* object codes */
1824
1825
case 'S': /* string object */
1826
case 'Y': /* string object */
1827
case 'U': /* unicode string object */
1828
{
1829
(void) va_arg(*p_va, PyObject **);
1830
break;
1831
}
1832
1833
case 'O': /* object */
1834
{
1835
if (*format == '!') {
1836
format++;
1837
(void) va_arg(*p_va, PyTypeObject*);
1838
(void) va_arg(*p_va, PyObject **);
1839
}
1780
case 'c': /* char */
1781
case 'C': /* unicode char */
1782
{
1783
(void) va_arg(*p_va, void *);
1784
break;
1785
}
1786
1787
case 'n': /* Py_ssize_t */
1788
{
1789
(void) va_arg(*p_va, Py_ssize_t *);
1790
break;
1791
}
1792
1793
/* string codes */
1794
1795
case 'e': /* string with encoding */
1796
{
1797
(void) va_arg(*p_va, const char *);
1798
if (!(*format == 's' || *format == 't'))
1799
/* after 'e', only 's' and 't' is allowed */
1800
goto err;
1801
format++;
1802
/* explicit fallthrough to string cases */
1803
}
1804
1805
case 's': /* string */
1806
case 'z': /* string or None */
1807
case 'y': /* bytes */
1808
case 'u': /* unicode string */
1809
case 't': /* buffer, read-only */
1810
case 'w': /* buffer, read-write */
1811
{
1812
(void) va_arg(*p_va, char **);
1813
if (*format == '#') {
1814
if (flags & FLAG_SIZE_T)
1815
(void) va_arg(*p_va, Py_ssize_t *);
1816
else
1817
(void) va_arg(*p_va, int *);
1818
format++;
1819
} else if ((c == 's' || c == 'z' || c == 'y') && *format == '*') {
1820
format++;
1821
}
1822
break;
1823
}
1824
1825
/* object codes */
1826
1827
case 'S': /* string object */
1828
case 'Y': /* string object */
1829
case 'U': /* unicode string object */
1830
{
1831
(void) va_arg(*p_va, PyObject **);
1832
break;
1833
}
1834
1835
case 'O': /* object */
1836
{
1837
if (*format == '!') {
1838
format++;
1839
(void) va_arg(*p_va, PyTypeObject*);
1840
(void) va_arg(*p_va, PyObject **);
1841
}
1840
1842
#if 0
1841
1843
/* I don't know what this is for */
1842
else if (*format == '?') {
1843
inquiry pred = va_arg(*p_va, inquiry);
1844
format++;
1845
if ((*pred)(arg)) {
1846
(void) va_arg(*p_va, PyObject **);
1847
}
1848
}
1844
else if (*format == '?') {
1845
inquiry pred = va_arg(*p_va, inquiry);
1846
format++;
1847
if ((*pred)(arg)) {
1848
(void) va_arg(*p_va, PyObject **);
1849
}
1850
}
1849
1851
#endif
1850
else if (*format == '&') {
1851
typedef int (*converter)(PyObject *, void *);
1852
(void) va_arg(*p_va, converter);
1853
(void) va_arg(*p_va, void *);
1854
format++;
1855
}
1856
else {
1857
(void) va_arg(*p_va, PyObject **);
1858
}
1859
break;
1860
}
1861
1862
case '(': /* bypass tuple, not handled at all previously */
1863
{
1864
char *msg;
1865
for (;;) {
1866
if (*format==')')
1867
break;
1868
if (IS_END_OF_FORMAT(*format))
1869
return "Unmatched left paren in format "
1870
"string";
1871
msg = skipitem(&format, p_va, flags);
1872
if (msg)
1873
return msg;
1874
}
1875
format++;
1876
break;
1877
}
1878
1879
case ')':
1880
return "Unmatched right paren in format string";
1881
1882
default:
1852
else if (*format == '&') {
1853
typedef int (*converter)(PyObject *, void *);
1854
(void) va_arg(*p_va, converter);
1855
(void) va_arg(*p_va, void *);
1856
format++;
1857
}
1858
else {
1859
(void) va_arg(*p_va, PyObject **);
1860
}
1861
break;
1862
}
1863
1864
case '(': /* bypass tuple, not handled at all previously */
1865
{
1866
char *msg;
1867
for (;;) {
1868
if (*format==')')
1869
break;
1870
if (IS_END_OF_FORMAT(*format))
1871
return "Unmatched left paren in format "
1872
"string";
1873
msg = skipitem(&format, p_va, flags);
1874
if (msg)
1875
return msg;
1876
}
1877
format++;
1878
break;
1879
}
1880
1881
case ')':
1882
return "Unmatched right paren in format string";
1883
1884
default:
1883
1885
err:
1884
return "impossible<bad format char>";
1885
1886
}
1887
1888
*p_format = format;
1889
return NULL;
1886
return "impossible<bad format char>";
1887
1888
}
1889
1890
*p_format = format;
1891
return NULL;
1890
1892
}
1891
1893
1892
1894
1893
1895
int
1894
1896
PyArg_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, ...)
1895
1897
{
1896
Py_ssize_t i, l;
1897
PyObject **o;
1898
va_list vargs;
1898
Py_ssize_t i, l;
1899
PyObject **o;
1900
va_list vargs;
1899
1901
1900
1902
#ifdef HAVE_STDARG_PROTOTYPES
1901
va_start(vargs, max);
1903
va_start(vargs, max);
1902
1904
#else
1903
va_start(vargs);
1905
va_start(vargs);
1904
1906
#endif
1905
1907
1906
assert(min >= 0);
1907
assert(min <= max);
1908
if (!PyTuple_Check(args)) {
1909
PyErr_SetString(PyExc_SystemError,
1910
"PyArg_UnpackTuple() argument list is not a tuple");
1911
return 0;
1912
}
1913
l = PyTuple_GET_SIZE(args);
1914
if (l < min) {
1915
if (name != NULL)
1916
PyErr_Format(
1917
PyExc_TypeError,
1918
"%s expected %s%zd arguments, got %zd",
1919
name, (min == max ? "" : "at least "), min, l);
1920
else
1921
PyErr_Format(
1922
PyExc_TypeError,
1923
"unpacked tuple should have %s%zd elements,"
1924
" but has %zd",
1925
(min == max ? "" : "at least "), min, l);
1926
va_end(vargs);
1927
return 0;
1928
}
1929
if (l > max) {
1930
if (name != NULL)
1931
PyErr_Format(
1932
PyExc_TypeError,
1933
"%s expected %s%zd arguments, got %zd",
1934
name, (min == max ? "" : "at most "), max, l);
1935
else
1936
PyErr_Format(
1937
PyExc_TypeError,
1938
"unpacked tuple should have %s%zd elements,"
1939
" but has %zd",
1940
(min == max ? "" : "at most "), max, l);
1941
va_end(vargs);
1942
return 0;
1943
}
1944
for (i = 0; i < l; i++) {
1945
o = va_arg(vargs, PyObject **);
1946
*o = PyTuple_GET_ITEM(args, i);
1947
}
1948
va_end(vargs);
1949
return 1;
1908
assert(min >= 0);
1909
assert(min <= max);
1910
if (!PyTuple_Check(args)) {
1911
PyErr_SetString(PyExc_SystemError,
1912
"PyArg_UnpackTuple() argument list is not a tuple");
1913
return 0;
1914
}
1915
l = PyTuple_GET_SIZE(args);
1916
if (l < min) {
1917
if (name != NULL)
1918
PyErr_Format(
1919
PyExc_TypeError,
1920
"%s expected %s%zd arguments, got %zd",
1921
name, (min == max ? "" : "at least "), min, l);
1922
else
1923
PyErr_Format(
1924
PyExc_TypeError,
1925
"unpacked tuple should have %s%zd elements,"
1926
" but has %zd",
1927
(min == max ? "" : "at least "), min, l);
1928
va_end(vargs);
1929
return 0;
1930
}
1931
if (l > max) {
1932
if (name != NULL)
1933
PyErr_Format(
1934
PyExc_TypeError,
1935
"%s expected %s%zd arguments, got %zd",
1936
name, (min == max ? "" : "at most "), max, l);
1937
else
1938
PyErr_Format(
1939
PyExc_TypeError,
1940
"unpacked tuple should have %s%zd elements,"
1941
" but has %zd",
1942
(min == max ? "" : "at most "), max, l);
1943
va_end(vargs);
1944
return 0;
1945
}
1946
for (i = 0; i < l; i++) {
1947
o = va_arg(vargs, PyObject **);
1948
*o = PyTuple_GET_ITEM(args, i);
1949
}
1950
va_end(vargs);
1951
return 1;
1950
1952
}
1951
1953
1952
1954
1958
1960
int
1959
1961
_PyArg_NoKeywords(const char *funcname, PyObject *kw)
1960
1962
{
1961
if (kw == NULL)
1962
return 1;
1963
if (!PyDict_CheckExact(kw)) {
1964
PyErr_BadInternalCall();
1965
return 0;
1966
}
1967
if (PyDict_Size(kw) == 0)
1968
return 1;
1963
if (kw == NULL)
1964
return 1;
1965
if (!PyDict_CheckExact(kw)) {
1966
PyErr_BadInternalCall();
1967
return 0;
1968
}
1969
if (PyDict_Size(kw) == 0)
1970
return 1;
1969
1971
1970
PyErr_Format(PyExc_TypeError, "%s does not take keyword arguments",
1971
funcname);
1972
return 0;
1972
PyErr_Format(PyExc_TypeError, "%s does not take keyword arguments",
1973
funcname);
1974
return 0;
1973
1975
}
1974
1976
#ifdef __cplusplus
1975
1977
};
Loggerhead is a web-based interface for Breezy
Version: 2.0.1