?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added updates with respect to recent changes to TimedRotatingFileHandler.
[python.git] / Modules / _struct.c
blobe5fe211f298f34d9b03577275aa50585ddb60a88
1 /* struct module -- pack values into and (out of) strings */
2
3 /* New version supporting byte order, alignment and size options,
4 character strings, and unsigned numbers */
5
6 #define PY_SSIZE_T_CLEAN
7
8 #include "Python.h"
9 #include "structseq.h"
10 #include "structmember.h"
11 #include <ctype.h>
12
13 static PyTypeObject PyStructType;
14
15 /* compatibility macros */
16 #if (PY_VERSION_HEX < 0x02050000)
17 typedef int Py_ssize_t;
18 #endif
19
20 /* If PY_STRUCT_OVERFLOW_MASKING is defined, the struct module will wrap all input
21 numbers for explicit endians such that they fit in the given type, much
22 like explicit casting in C. A warning will be raised if the number did
23 not originally fit within the range of the requested type. If it is
24 not defined, then all range errors and overflow will be struct.error
25 exceptions. */
26
27 #define PY_STRUCT_OVERFLOW_MASKING 1
28
29 #ifdef PY_STRUCT_OVERFLOW_MASKING
30 static PyObject *pylong_ulong_mask = NULL;
31 static PyObject *pyint_zero = NULL;
32 #endif
33
34 /* If PY_STRUCT_FLOAT_COERCE is defined, the struct module will allow float
35 arguments for integer formats with a warning for backwards
36 compatibility. */
37
38 #define PY_STRUCT_FLOAT_COERCE 1
39
40 #ifdef PY_STRUCT_FLOAT_COERCE
41 #define FLOAT_COERCE "integer argument expected, got float"
42 #endif
43
44
45 /* The translation function for each format character is table driven */
46 typedef struct _formatdef {
47 char format;
48 Py_ssize_t size;
49 Py_ssize_t alignment;
50 PyObject* (*unpack)(const char *,
51 const struct _formatdef *);
52 int (*pack)(char *, PyObject *,
53 const struct _formatdef *);
54 } formatdef;
55
56 typedef struct _formatcode {
57 const struct _formatdef *fmtdef;
58 Py_ssize_t offset;
59 Py_ssize_t size;
60 } formatcode;
61
62 /* Struct object interface */
63
64 typedef struct {
65 PyObject_HEAD
66 Py_ssize_t s_size;
67 Py_ssize_t s_len;
68 formatcode *s_codes;
69 PyObject *s_format;
70 PyObject *weakreflist; /* List of weak references */
71 } PyStructObject;
72
73
74 #define PyStruct_Check(op) PyObject_TypeCheck(op, &PyStructType)
75 #define PyStruct_CheckExact(op) (Py_TYPE(op) == &PyStructType)
76
77
78 /* Exception */
79
80 static PyObject *StructError;
81
82
83 /* Define various structs to figure out the alignments of types */
84
85
86 typedef struct { char c; short x; } st_short;
87 typedef struct { char c; int x; } st_int;
88 typedef struct { char c; long x; } st_long;
89 typedef struct { char c; float x; } st_float;
90 typedef struct { char c; double x; } st_double;
91 typedef struct { char c; void *x; } st_void_p;
92
93 #define SHORT_ALIGN (sizeof(st_short) - sizeof(short))
94 #define INT_ALIGN (sizeof(st_int) - sizeof(int))
95 #define LONG_ALIGN (sizeof(st_long) - sizeof(long))
96 #define FLOAT_ALIGN (sizeof(st_float) - sizeof(float))
97 #define DOUBLE_ALIGN (sizeof(st_double) - sizeof(double))
98 #define VOID_P_ALIGN (sizeof(st_void_p) - sizeof(void *))
99
100 /* We can't support q and Q in native mode unless the compiler does;
101 in std mode, they're 8 bytes on all platforms. */
102 #ifdef HAVE_LONG_LONG
103 typedef struct { char c; PY_LONG_LONG x; } s_long_long;
104 #define LONG_LONG_ALIGN (sizeof(s_long_long) - sizeof(PY_LONG_LONG))
105 #endif
106
107 #ifdef HAVE_C99_BOOL
108 #define BOOL_TYPE _Bool
109 typedef struct { char c; _Bool x; } s_bool;
110 #define BOOL_ALIGN (sizeof(s_bool) - sizeof(BOOL_TYPE))
111 #else
112 #define BOOL_TYPE char
113 #define BOOL_ALIGN 0
114 #endif
115
116 #define STRINGIFY(x) #x
117
118 #ifdef __powerc
119 #pragma options align=reset
120 #endif
121
122 /* Helper to get a PyLongObject by hook or by crook. Caller should decref. */
123
124 static PyObject *
125 get_pylong(PyObject *v)
126 {
127 PyNumberMethods *m;
128
129 assert(v != NULL);
130 if (PyInt_Check(v))
131 return PyLong_FromLong(PyInt_AS_LONG(v));
132 if (PyLong_Check(v)) {
133 Py_INCREF(v);
134 return v;
135 }
136 m = Py_TYPE(v)->tp_as_number;
137 if (m != NULL && m->nb_long != NULL) {
138 v = m->nb_long(v);
139 if (v == NULL)
140 return NULL;
141 if (PyLong_Check(v))
142 return v;
143 Py_DECREF(v);
144 }
145 PyErr_SetString(StructError,
146 "cannot convert argument to long");
147 return NULL;
148 }
149
150 /* Helper routine to get a Python integer and raise the appropriate error
151 if it isn't one */
152
153 static int
154 get_long(PyObject *v, long *p)
155 {
156 long x = PyInt_AsLong(v);
157 if (x == -1 && PyErr_Occurred()) {
158 #ifdef PY_STRUCT_FLOAT_COERCE
159 if (PyFloat_Check(v)) {
160 PyObject *o;
161 int res;
162 PyErr_Clear();
163 if (PyErr_WarnEx(PyExc_DeprecationWarning, FLOAT_COERCE, 2) < 0)
164 return -1;
165 o = PyNumber_Int(v);
166 if (o == NULL)
167 return -1;
168 res = get_long(o, p);
169 Py_DECREF(o);
170 return res;
171 }
172 #endif
173 if (PyErr_ExceptionMatches(PyExc_TypeError))
174 PyErr_SetString(StructError,
175 "required argument is not an integer");
176 return -1;
177 }
178 *p = x;
179 return 0;
180 }
181
182
183 /* Same, but handling unsigned long */
184
185 static int
186 get_ulong(PyObject *v, unsigned long *p)
187 {
188 if (PyLong_Check(v)) {
189 unsigned long x = PyLong_AsUnsignedLong(v);
190 if (x == (unsigned long)(-1) && PyErr_Occurred())
191 return -1;
192 *p = x;
193 return 0;
194 }
195 if (get_long(v, (long *)p) < 0)
196 return -1;
197 if (((long)*p) < 0) {
198 PyErr_SetString(StructError,
199 "unsigned argument is < 0");
200 return -1;
201 }
202 return 0;
203 }
204
205 #ifdef HAVE_LONG_LONG
206
207 /* Same, but handling native long long. */
208
209 static int
210 get_longlong(PyObject *v, PY_LONG_LONG *p)
211 {
212 PY_LONG_LONG x;
213
214 v = get_pylong(v);
215 if (v == NULL)
216 return -1;
217 assert(PyLong_Check(v));
218 x = PyLong_AsLongLong(v);
219 Py_DECREF(v);
220 if (x == (PY_LONG_LONG)-1 && PyErr_Occurred())
221 return -1;
222 *p = x;
223 return 0;
224 }
225
226 /* Same, but handling native unsigned long long. */
227
228 static int
229 get_ulonglong(PyObject *v, unsigned PY_LONG_LONG *p)
230 {
231 unsigned PY_LONG_LONG x;
232
233 v = get_pylong(v);
234 if (v == NULL)
235 return -1;
236 assert(PyLong_Check(v));
237 x = PyLong_AsUnsignedLongLong(v);
238 Py_DECREF(v);
239 if (x == (unsigned PY_LONG_LONG)-1 && PyErr_Occurred())
240 return -1;
241 *p = x;
242 return 0;
243 }
244
245 #endif
246
247 #ifdef PY_STRUCT_OVERFLOW_MASKING
248
249 /* Helper routine to get a Python integer and raise the appropriate error
250 if it isn't one */
251
252 #define INT_OVERFLOW "struct integer overflow masking is deprecated"
253
254 static int
255 get_wrapped_long(PyObject *v, long *p)
256 {
257 if (get_long(v, p) < 0) {
258 if (PyLong_Check(v) &&
259 PyErr_ExceptionMatches(PyExc_OverflowError)) {
260 PyObject *wrapped;
261 long x;
262 PyErr_Clear();
263 #ifdef PY_STRUCT_FLOAT_COERCE
264 if (PyFloat_Check(v)) {
265 PyObject *o;
266 int res;
267 PyErr_Clear();
268 if (PyErr_WarnEx(PyExc_DeprecationWarning, FLOAT_COERCE, 2) < 0)
269 return -1;
270 o = PyNumber_Int(v);
271 if (o == NULL)
272 return -1;
273 res = get_wrapped_long(o, p);
274 Py_DECREF(o);
275 return res;
276 }
277 #endif
278 if (PyErr_WarnEx(PyExc_DeprecationWarning, INT_OVERFLOW, 2) < 0)
279 return -1;
280 wrapped = PyNumber_And(v, pylong_ulong_mask);
281 if (wrapped == NULL)
282 return -1;
283 x = (long)PyLong_AsUnsignedLong(wrapped);
284 Py_DECREF(wrapped);
285 if (x == -1 && PyErr_Occurred())
286 return -1;
287 *p = x;
288 } else {
289 return -1;
290 }
291 }
292 return 0;
293 }
294
295 static int
296 get_wrapped_ulong(PyObject *v, unsigned long *p)
297 {
298 long x = (long)PyLong_AsUnsignedLong(v);
299 if (x == -1 && PyErr_Occurred()) {
300 PyObject *wrapped;
301 PyErr_Clear();
302 #ifdef PY_STRUCT_FLOAT_COERCE
303 if (PyFloat_Check(v)) {
304 PyObject *o;
305 int res;
306 PyErr_Clear();
307 if (PyErr_WarnEx(PyExc_DeprecationWarning, FLOAT_COERCE, 2) < 0)
308 return -1;
309 o = PyNumber_Int(v);
310 if (o == NULL)
311 return -1;
312 res = get_wrapped_ulong(o, p);
313 Py_DECREF(o);
314 return res;
315 }
316 #endif
317 wrapped = PyNumber_And(v, pylong_ulong_mask);
318 if (wrapped == NULL)
319 return -1;
320 if (PyErr_WarnEx(PyExc_DeprecationWarning, INT_OVERFLOW, 2) < 0) {
321 Py_DECREF(wrapped);
322 return -1;
323 }
324 x = (long)PyLong_AsUnsignedLong(wrapped);
325 Py_DECREF(wrapped);
326 if (x == -1 && PyErr_Occurred())
327 return -1;
328 }
329 *p = (unsigned long)x;
330 return 0;
331 }
332
333 #define RANGE_ERROR(x, f, flag, mask) \
334 do { \
335 if (_range_error(f, flag) < 0) \
336 return -1; \
337 else \
338 (x) &= (mask); \
339 } while (0)
340
341 #else
342
343 #define get_wrapped_long get_long
344 #define get_wrapped_ulong get_ulong
345 #define RANGE_ERROR(x, f, flag, mask) return _range_error(f, flag)
346
347 #endif
348
349 /* Floating point helpers */
350
351 static PyObject *
352 unpack_float(const char *p, /* start of 4-byte string */
353 int le) /* true for little-endian, false for big-endian */
354 {
355 double x;
356
357 x = _PyFloat_Unpack4((unsigned char *)p, le);
358 if (x == -1.0 && PyErr_Occurred())
359 return NULL;
360 return PyFloat_FromDouble(x);
361 }
362
363 static PyObject *
364 unpack_double(const char *p, /* start of 8-byte string */
365 int le) /* true for little-endian, false for big-endian */
366 {
367 double x;
368
369 x = _PyFloat_Unpack8((unsigned char *)p, le);
370 if (x == -1.0 && PyErr_Occurred())
371 return NULL;
372 return PyFloat_FromDouble(x);
373 }
374
375 /* Helper to format the range error exceptions */
376 static int
377 _range_error(const formatdef *f, int is_unsigned)
378 {
379 /* ulargest is the largest unsigned value with f->size bytes.
380 * Note that the simpler:
381 * ((size_t)1 << (f->size * 8)) - 1
382 * doesn't work when f->size == sizeof(size_t) because C doesn't
383 * define what happens when a left shift count is >= the number of
384 * bits in the integer being shifted; e.g., on some boxes it doesn't
385 * shift at all when they're equal.
386 */
387 const size_t ulargest = (size_t)-1 >> ((SIZEOF_SIZE_T - f->size)*8);
388 assert(f->size >= 1 && f->size <= SIZEOF_SIZE_T);
389 if (is_unsigned)
390 PyErr_Format(StructError,
391 "'%c' format requires 0 <= number <= %zu",
392 f->format,
393 ulargest);
394 else {
395 const Py_ssize_t largest = (Py_ssize_t)(ulargest >> 1);
396 PyErr_Format(StructError,
397 "'%c' format requires %zd <= number <= %zd",
398 f->format,
399 ~ largest,
400 largest);
401 }
402 #ifdef PY_STRUCT_OVERFLOW_MASKING
403 {
404 PyObject *ptype, *pvalue, *ptraceback;
405 PyObject *msg;
406 int rval;
407 PyErr_Fetch(&ptype, &pvalue, &ptraceback);
408 assert(pvalue != NULL);
409 msg = PyObject_Str(pvalue);
410 Py_XDECREF(ptype);
411 Py_XDECREF(pvalue);
412 Py_XDECREF(ptraceback);
413 if (msg == NULL)
414 return -1;
415 rval = PyErr_WarnEx(PyExc_DeprecationWarning,
416 PyString_AS_STRING(msg), 2);
417 Py_DECREF(msg);
418 if (rval == 0)
419 return 0;
420 }
421 #endif
422 return -1;
423 }
424
425
426
427 /* A large number of small routines follow, with names of the form
428
429 [bln][up]_TYPE
430
431 [bln] distiguishes among big-endian, little-endian and native.
432 [pu] distiguishes between pack (to struct) and unpack (from struct).
433 TYPE is one of char, byte, ubyte, etc.
434 */
435
436 /* Native mode routines. ****************************************************/
437 /* NOTE:
438 In all n[up]_<type> routines handling types larger than 1 byte, there is
439 *no* guarantee that the p pointer is properly aligned for each type,
440 therefore memcpy is called. An intermediate variable is used to
441 compensate for big-endian architectures.
442 Normally both the intermediate variable and the memcpy call will be
443 skipped by C optimisation in little-endian architectures (gcc >= 2.91
444 does this). */
445
446 static PyObject *
447 nu_char(const char *p, const formatdef *f)
448 {
449 return PyString_FromStringAndSize(p, 1);
450 }
451
452 static PyObject *
453 nu_byte(const char *p, const formatdef *f)
454 {
455 return PyInt_FromLong((long) *(signed char *)p);
456 }
457
458 static PyObject *
459 nu_ubyte(const char *p, const formatdef *f)
460 {
461 return PyInt_FromLong((long) *(unsigned char *)p);
462 }
463
464 static PyObject *
465 nu_short(const char *p, const formatdef *f)
466 {
467 short x;
468 memcpy((char *)&x, p, sizeof x);
469 return PyInt_FromLong((long)x);
470 }
471
472 static PyObject *
473 nu_ushort(const char *p, const formatdef *f)
474 {
475 unsigned short x;
476 memcpy((char *)&x, p, sizeof x);
477 return PyInt_FromLong((long)x);
478 }
479
480 static PyObject *
481 nu_int(const char *p, const formatdef *f)
482 {
483 int x;
484 memcpy((char *)&x, p, sizeof x);
485 return PyInt_FromLong((long)x);
486 }
487
488 static PyObject *
489 nu_uint(const char *p, const formatdef *f)
490 {
491 unsigned int x;
492 memcpy((char *)&x, p, sizeof x);
493 #if (SIZEOF_LONG > SIZEOF_INT)
494 return PyInt_FromLong((long)x);
495 #else
496 if (x <= ((unsigned int)LONG_MAX))
497 return PyInt_FromLong((long)x);
498 return PyLong_FromUnsignedLong((unsigned long)x);
499 #endif
500 }
501
502 static PyObject *
503 nu_long(const char *p, const formatdef *f)
504 {
505 long x;
506 memcpy((char *)&x, p, sizeof x);
507 return PyInt_FromLong(x);
508 }
509
510 static PyObject *
511 nu_ulong(const char *p, const formatdef *f)
512 {
513 unsigned long x;
514 memcpy((char *)&x, p, sizeof x);
515 if (x <= LONG_MAX)
516 return PyInt_FromLong((long)x);
517 return PyLong_FromUnsignedLong(x);
518 }
519
520 /* Native mode doesn't support q or Q unless the platform C supports
521 long long (or, on Windows, __int64). */
522
523 #ifdef HAVE_LONG_LONG
524
525 static PyObject *
526 nu_longlong(const char *p, const formatdef *f)
527 {
528 PY_LONG_LONG x;
529 memcpy((char *)&x, p, sizeof x);
530 if (x >= LONG_MIN && x <= LONG_MAX)
531 return PyInt_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));
532 return PyLong_FromLongLong(x);
533 }
534
535 static PyObject *
536 nu_ulonglong(const char *p, const formatdef *f)
537 {
538 unsigned PY_LONG_LONG x;
539 memcpy((char *)&x, p, sizeof x);
540 if (x <= LONG_MAX)
541 return PyInt_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));
542 return PyLong_FromUnsignedLongLong(x);
543 }
544
545 #endif
546
547 static PyObject *
548 nu_bool(const char *p, const formatdef *f)
549 {
550 BOOL_TYPE x;
551 memcpy((char *)&x, p, sizeof x);
552 return PyBool_FromLong(x != 0);
553 }
554
555
556 static PyObject *
557 nu_float(const char *p, const formatdef *f)
558 {
559 float x;
560 memcpy((char *)&x, p, sizeof x);
561 return PyFloat_FromDouble((double)x);
562 }
563
564 static PyObject *
565 nu_double(const char *p, const formatdef *f)
566 {
567 double x;
568 memcpy((char *)&x, p, sizeof x);
569 return PyFloat_FromDouble(x);
570 }
571
572 static PyObject *
573 nu_void_p(const char *p, const formatdef *f)
574 {
575 void *x;
576 memcpy((char *)&x, p, sizeof x);
577 return PyLong_FromVoidPtr(x);
578 }
579
580 static int
581 np_byte(char *p, PyObject *v, const formatdef *f)
582 {
583 long x;
584 if (get_long(v, &x) < 0)
585 return -1;
586 if (x < -128 || x > 127){
587 PyErr_SetString(StructError,
588 "byte format requires -128 <= number <= 127");
589 return -1;
590 }
591 *p = (char)x;
592 return 0;
593 }
594
595 static int
596 np_ubyte(char *p, PyObject *v, const formatdef *f)
597 {
598 long x;
599 if (get_long(v, &x) < 0)
600 return -1;
601 if (x < 0 || x > 255){
602 PyErr_SetString(StructError,
603 "ubyte format requires 0 <= number <= 255");
604 return -1;
605 }
606 *p = (char)x;
607 return 0;
608 }
609
610 static int
611 np_char(char *p, PyObject *v, const formatdef *f)
612 {
613 if (!PyString_Check(v) || PyString_Size(v) != 1) {
614 PyErr_SetString(StructError,
615 "char format require string of length 1");
616 return -1;
617 }
618 *p = *PyString_AsString(v);
619 return 0;
620 }
621
622 static int
623 np_short(char *p, PyObject *v, const formatdef *f)
624 {
625 long x;
626 short y;
627 if (get_long(v, &x) < 0)
628 return -1;
629 if (x < SHRT_MIN || x > SHRT_MAX){
630 PyErr_SetString(StructError,
631 "short format requires " STRINGIFY(SHRT_MIN)
632 " <= number <= " STRINGIFY(SHRT_MAX));
633 return -1;
634 }
635 y = (short)x;
636 memcpy(p, (char *)&y, sizeof y);
637 return 0;
638 }
639
640 static int
641 np_ushort(char *p, PyObject *v, const formatdef *f)
642 {
643 long x;
644 unsigned short y;
645 if (get_long(v, &x) < 0)
646 return -1;
647 if (x < 0 || x > USHRT_MAX){
648 PyErr_SetString(StructError,
649 "short format requires 0 <= number <= " STRINGIFY(USHRT_MAX));
650 return -1;
651 }
652 y = (unsigned short)x;
653 memcpy(p, (char *)&y, sizeof y);
654 return 0;
655 }
656
657 static int
658 np_int(char *p, PyObject *v, const formatdef *f)
659 {
660 long x;
661 int y;
662 if (get_long(v, &x) < 0)
663 return -1;
664 #if (SIZEOF_LONG > SIZEOF_INT)
665 if ((x < ((long)INT_MIN)) || (x > ((long)INT_MAX)))
666 return _range_error(f, 0);
667 #endif
668 y = (int)x;
669 memcpy(p, (char *)&y, sizeof y);
670 return 0;
671 }
672
673 static int
674 np_uint(char *p, PyObject *v, const formatdef *f)
675 {
676 unsigned long x;
677 unsigned int y;
678 if (get_ulong(v, &x) < 0)
679 return _range_error(f, 1);
680 y = (unsigned int)x;
681 #if (SIZEOF_LONG > SIZEOF_INT)
682 if (x > ((unsigned long)UINT_MAX))
683 return _range_error(f, 1);
684 #endif
685 memcpy(p, (char *)&y, sizeof y);
686 return 0;
687 }
688
689 static int
690 np_long(char *p, PyObject *v, const formatdef *f)
691 {
692 long x;
693 if (get_long(v, &x) < 0)
694 return -1;
695 memcpy(p, (char *)&x, sizeof x);
696 return 0;
697 }
698
699 static int
700 np_ulong(char *p, PyObject *v, const formatdef *f)
701 {
702 unsigned long x;
703 if (get_ulong(v, &x) < 0)
704 return _range_error(f, 1);
705 memcpy(p, (char *)&x, sizeof x);
706 return 0;
707 }
708
709 #ifdef HAVE_LONG_LONG
710
711 static int
712 np_longlong(char *p, PyObject *v, const formatdef *f)
713 {
714 PY_LONG_LONG x;
715 if (get_longlong(v, &x) < 0)
716 return -1;
717 memcpy(p, (char *)&x, sizeof x);
718 return 0;
719 }
720
721 static int
722 np_ulonglong(char *p, PyObject *v, const formatdef *f)
723 {
724 unsigned PY_LONG_LONG x;
725 if (get_ulonglong(v, &x) < 0)
726 return -1;
727 memcpy(p, (char *)&x, sizeof x);
728 return 0;
729 }
730 #endif
731
732
733 static int
734 np_bool(char *p, PyObject *v, const formatdef *f)
735 {
736 BOOL_TYPE y;
737 y = PyObject_IsTrue(v);
738 memcpy(p, (char *)&y, sizeof y);
739 return 0;
740 }
741
742 static int
743 np_float(char *p, PyObject *v, const formatdef *f)
744 {
745 float x = (float)PyFloat_AsDouble(v);
746 if (x == -1 && PyErr_Occurred()) {
747 PyErr_SetString(StructError,
748 "required argument is not a float");
749 return -1;
750 }
751 memcpy(p, (char *)&x, sizeof x);
752 return 0;
753 }
754
755 static int
756 np_double(char *p, PyObject *v, const formatdef *f)
757 {
758 double x = PyFloat_AsDouble(v);
759 if (x == -1 && PyErr_Occurred()) {
760 PyErr_SetString(StructError,
761 "required argument is not a float");
762 return -1;
763 }
764 memcpy(p, (char *)&x, sizeof(double));
765 return 0;
766 }
767
768 static int
769 np_void_p(char *p, PyObject *v, const formatdef *f)
770 {
771 void *x;
772
773 v = get_pylong(v);
774 if (v == NULL)
775 return -1;
776 assert(PyLong_Check(v));
777 x = PyLong_AsVoidPtr(v);
778 Py_DECREF(v);
779 if (x == NULL && PyErr_Occurred())
780 return -1;
781 memcpy(p, (char *)&x, sizeof x);
782 return 0;
783 }
784
785 static formatdef native_table[] = {
786 {'x', sizeof(char), 0, NULL},
787 {'b', sizeof(char), 0, nu_byte, np_byte},
788 {'B', sizeof(char), 0, nu_ubyte, np_ubyte},
789 {'c', sizeof(char), 0, nu_char, np_char},
790 {'s', sizeof(char), 0, NULL},
791 {'p', sizeof(char), 0, NULL},
792 {'h', sizeof(short), SHORT_ALIGN, nu_short, np_short},
793 {'H', sizeof(short), SHORT_ALIGN, nu_ushort, np_ushort},
794 {'i', sizeof(int), INT_ALIGN, nu_int, np_int},
795 {'I', sizeof(int), INT_ALIGN, nu_uint, np_uint},
796 {'l', sizeof(long), LONG_ALIGN, nu_long, np_long},
797 {'L', sizeof(long), LONG_ALIGN, nu_ulong, np_ulong},
798 #ifdef HAVE_LONG_LONG
799 {'q', sizeof(PY_LONG_LONG), LONG_LONG_ALIGN, nu_longlong, np_longlong},
800 {'Q', sizeof(PY_LONG_LONG), LONG_LONG_ALIGN, nu_ulonglong,np_ulonglong},
801 #endif
802 {'?', sizeof(BOOL_TYPE), BOOL_ALIGN, nu_bool, np_bool},
803 {'f', sizeof(float), FLOAT_ALIGN, nu_float, np_float},
804 {'d', sizeof(double), DOUBLE_ALIGN, nu_double, np_double},
805 {'P', sizeof(void *), VOID_P_ALIGN, nu_void_p, np_void_p},
806 {0}
807 };
808
809 /* Big-endian routines. *****************************************************/
810
811 static PyObject *
812 bu_int(const char *p, const formatdef *f)
813 {
814 long x = 0;
815 Py_ssize_t i = f->size;
816 const unsigned char *bytes = (const unsigned char *)p;
817 do {
818 x = (x<<8) | *bytes++;
819 } while (--i > 0);
820 /* Extend the sign bit. */
821 if (SIZEOF_LONG > f->size)
822 x |= -(x & (1L << ((8 * f->size) - 1)));
823 return PyInt_FromLong(x);
824 }
825
826 static PyObject *
827 bu_uint(const char *p, const formatdef *f)
828 {
829 unsigned long x = 0;
830 Py_ssize_t i = f->size;
831 const unsigned char *bytes = (const unsigned char *)p;
832 do {
833 x = (x<<8) | *bytes++;
834 } while (--i > 0);
835 if (x <= LONG_MAX)
836 return PyInt_FromLong((long)x);
837 return PyLong_FromUnsignedLong(x);
838 }
839
840 static PyObject *
841 bu_longlong(const char *p, const formatdef *f)
842 {
843 #ifdef HAVE_LONG_LONG
844 PY_LONG_LONG x = 0;
845 Py_ssize_t i = f->size;
846 const unsigned char *bytes = (const unsigned char *)p;
847 do {
848 x = (x<<8) | *bytes++;
849 } while (--i > 0);
850 /* Extend the sign bit. */
851 if (SIZEOF_LONG_LONG > f->size)
852 x |= -(x & ((PY_LONG_LONG)1 << ((8 * f->size) - 1)));
853 if (x >= LONG_MIN && x <= LONG_MAX)
854 return PyInt_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));
855 return PyLong_FromLongLong(x);
856 #else
857 return _PyLong_FromByteArray((const unsigned char *)p,
858 8,
859 0, /* little-endian */
860 1 /* signed */);
861 #endif
862 }
863
864 static PyObject *
865 bu_ulonglong(const char *p, const formatdef *f)
866 {
867 #ifdef HAVE_LONG_LONG
868 unsigned PY_LONG_LONG x = 0;
869 Py_ssize_t i = f->size;
870 const unsigned char *bytes = (const unsigned char *)p;
871 do {
872 x = (x<<8) | *bytes++;
873 } while (--i > 0);
874 if (x <= LONG_MAX)
875 return PyInt_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));
876 return PyLong_FromUnsignedLongLong(x);
877 #else
878 return _PyLong_FromByteArray((const unsigned char *)p,
879 8,
880 0, /* little-endian */
881 0 /* signed */);
882 #endif
883 }
884
885 static PyObject *
886 bu_float(const char *p, const formatdef *f)
887 {
888 return unpack_float(p, 0);
889 }
890
891 static PyObject *
892 bu_double(const char *p, const formatdef *f)
893 {
894 return unpack_double(p, 0);
895 }
896
897 static PyObject *
898 bu_bool(const char *p, const formatdef *f)
899 {
900 char x;
901 memcpy((char *)&x, p, sizeof x);
902 return PyBool_FromLong(x != 0);
903 }
904
905 static int
906 bp_int(char *p, PyObject *v, const formatdef *f)
907 {
908 long x;
909 Py_ssize_t i;
910 if (get_wrapped_long(v, &x) < 0)
911 return -1;
912 i = f->size;
913 if (i != SIZEOF_LONG) {
914 if ((i == 2) && (x < -32768 || x > 32767))
915 RANGE_ERROR(x, f, 0, 0xffffL);
916 #if (SIZEOF_LONG != 4)
917 else if ((i == 4) && (x < -2147483648L || x > 2147483647L))
918 RANGE_ERROR(x, f, 0, 0xffffffffL);
919 #endif
920 #ifdef PY_STRUCT_OVERFLOW_MASKING
921 else if ((i == 1) && (x < -128 || x > 127))
922 RANGE_ERROR(x, f, 0, 0xffL);
923 #endif
924 }
925 do {
926 p[--i] = (char)x;
927 x >>= 8;
928 } while (i > 0);
929 return 0;
930 }
931
932 static int
933 bp_uint(char *p, PyObject *v, const formatdef *f)
934 {
935 unsigned long x;
936 Py_ssize_t i;
937 if (get_wrapped_ulong(v, &x) < 0)
938 return -1;
939 i = f->size;
940 if (i != SIZEOF_LONG) {
941 unsigned long maxint = 1;
942 maxint <<= (unsigned long)(i * 8);
943 if (x >= maxint)
944 RANGE_ERROR(x, f, 1, maxint - 1);
945 }
946 do {
947 p[--i] = (char)x;
948 x >>= 8;
949 } while (i > 0);
950 return 0;
951 }
952
953 static int
954 bp_longlong(char *p, PyObject *v, const formatdef *f)
955 {
956 int res;
957 v = get_pylong(v);
958 if (v == NULL)
959 return -1;
960 res = _PyLong_AsByteArray((PyLongObject *)v,
961 (unsigned char *)p,
962 8,
963 0, /* little_endian */
964 1 /* signed */);
965 Py_DECREF(v);
966 return res;
967 }
968
969 static int
970 bp_ulonglong(char *p, PyObject *v, const formatdef *f)
971 {
972 int res;
973 v = get_pylong(v);
974 if (v == NULL)
975 return -1;
976 res = _PyLong_AsByteArray((PyLongObject *)v,
977 (unsigned char *)p,
978 8,
979 0, /* little_endian */
980 0 /* signed */);
981 Py_DECREF(v);
982 return res;
983 }
984
985 static int
986 bp_float(char *p, PyObject *v, const formatdef *f)
987 {
988 double x = PyFloat_AsDouble(v);
989 if (x == -1 && PyErr_Occurred()) {
990 PyErr_SetString(StructError,
991 "required argument is not a float");
992 return -1;
993 }
994 return _PyFloat_Pack4(x, (unsigned char *)p, 0);
995 }
996
997 static int
998 bp_double(char *p, PyObject *v, const formatdef *f)
999 {
1000 double x = PyFloat_AsDouble(v);
1001 if (x == -1 && PyErr_Occurred()) {
1002 PyErr_SetString(StructError,
1003 "required argument is not a float");
1004 return -1;
1005 }
1006 return _PyFloat_Pack8(x, (unsigned char *)p, 0);
1007 }
1008
1009 static int
1010 bp_bool(char *p, PyObject *v, const formatdef *f)
1011 {
1012 char y;
1013 y = PyObject_IsTrue(v);
1014 memcpy(p, (char *)&y, sizeof y);
1015 return 0;
1016 }
1017
1018 static formatdef bigendian_table[] = {
1019 {'x', 1, 0, NULL},
1020 #ifdef PY_STRUCT_OVERFLOW_MASKING
1021 /* Native packers do range checking without overflow masking. */
1022 {'b', 1, 0, nu_byte, bp_int},
1023 {'B', 1, 0, nu_ubyte, bp_uint},
1024 #else
1025 {'b', 1, 0, nu_byte, np_byte},
1026 {'B', 1, 0, nu_ubyte, np_ubyte},
1027 #endif
1028 {'c', 1, 0, nu_char, np_char},
1029 {'s', 1, 0, NULL},
1030 {'p', 1, 0, NULL},
1031 {'h', 2, 0, bu_int, bp_int},
1032 {'H', 2, 0, bu_uint, bp_uint},
1033 {'i', 4, 0, bu_int, bp_int},
1034 {'I', 4, 0, bu_uint, bp_uint},
1035 {'l', 4, 0, bu_int, bp_int},
1036 {'L', 4, 0, bu_uint, bp_uint},
1037 {'q', 8, 0, bu_longlong, bp_longlong},
1038 {'Q', 8, 0, bu_ulonglong, bp_ulonglong},
1039 {'?', 1, 0, bu_bool, bp_bool},
1040 {'f', 4, 0, bu_float, bp_float},
1041 {'d', 8, 0, bu_double, bp_double},
1042 {0}
1043 };
1044
1045 /* Little-endian routines. *****************************************************/
1046
1047 static PyObject *
1048 lu_int(const char *p, const formatdef *f)
1049 {
1050 long x = 0;
1051 Py_ssize_t i = f->size;
1052 const unsigned char *bytes = (const unsigned char *)p;
1053 do {
1054 x = (x<<8) | bytes[--i];
1055 } while (i > 0);
1056 /* Extend the sign bit. */
1057 if (SIZEOF_LONG > f->size)
1058 x |= -(x & (1L << ((8 * f->size) - 1)));
1059 return PyInt_FromLong(x);
1060 }
1061
1062 static PyObject *
1063 lu_uint(const char *p, const formatdef *f)
1064 {
1065 unsigned long x = 0;
1066 Py_ssize_t i = f->size;
1067 const unsigned char *bytes = (const unsigned char *)p;
1068 do {
1069 x = (x<<8) | bytes[--i];
1070 } while (i > 0);
1071 if (x <= LONG_MAX)
1072 return PyInt_FromLong((long)x);
1073 return PyLong_FromUnsignedLong((long)x);
1074 }
1075
1076 static PyObject *
1077 lu_longlong(const char *p, const formatdef *f)
1078 {
1079 #ifdef HAVE_LONG_LONG
1080 PY_LONG_LONG x = 0;
1081 Py_ssize_t i = f->size;
1082 const unsigned char *bytes = (const unsigned char *)p;
1083 do {
1084 x = (x<<8) | bytes[--i];
1085 } while (i > 0);
1086 /* Extend the sign bit. */
1087 if (SIZEOF_LONG_LONG > f->size)
1088 x |= -(x & ((PY_LONG_LONG)1 << ((8 * f->size) - 1)));
1089 if (x >= LONG_MIN && x <= LONG_MAX)
1090 return PyInt_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));
1091 return PyLong_FromLongLong(x);
1092 #else
1093 return _PyLong_FromByteArray((const unsigned char *)p,
1094 8,
1095 1, /* little-endian */
1096 1 /* signed */);
1097 #endif
1098 }
1099
1100 static PyObject *
1101 lu_ulonglong(const char *p, const formatdef *f)
1102 {
1103 #ifdef HAVE_LONG_LONG
1104 unsigned PY_LONG_LONG x = 0;
1105 Py_ssize_t i = f->size;
1106 const unsigned char *bytes = (const unsigned char *)p;
1107 do {
1108 x = (x<<8) | bytes[--i];
1109 } while (i > 0);
1110 if (x <= LONG_MAX)
1111 return PyInt_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));
1112 return PyLong_FromUnsignedLongLong(x);
1113 #else
1114 return _PyLong_FromByteArray((const unsigned char *)p,
1115 8,
1116 1, /* little-endian */
1117 0 /* signed */);
1118 #endif
1119 }
1120
1121 static PyObject *
1122 lu_float(const char *p, const formatdef *f)
1123 {
1124 return unpack_float(p, 1);
1125 }
1126
1127 static PyObject *
1128 lu_double(const char *p, const formatdef *f)
1129 {
1130 return unpack_double(p, 1);
1131 }
1132
1133 static int
1134 lp_int(char *p, PyObject *v, const formatdef *f)
1135 {
1136 long x;
1137 Py_ssize_t i;
1138 if (get_wrapped_long(v, &x) < 0)
1139 return -1;
1140 i = f->size;
1141 if (i != SIZEOF_LONG) {
1142 if ((i == 2) && (x < -32768 || x > 32767))
1143 RANGE_ERROR(x, f, 0, 0xffffL);
1144 #if (SIZEOF_LONG != 4)
1145 else if ((i == 4) && (x < -2147483648L || x > 2147483647L))
1146 RANGE_ERROR(x, f, 0, 0xffffffffL);
1147 #endif
1148 #ifdef PY_STRUCT_OVERFLOW_MASKING
1149 else if ((i == 1) && (x < -128 || x > 127))
1150 RANGE_ERROR(x, f, 0, 0xffL);
1151 #endif
1152 }
1153 do {
1154 *p++ = (char)x;
1155 x >>= 8;
1156 } while (--i > 0);
1157 return 0;
1158 }
1159
1160 static int
1161 lp_uint(char *p, PyObject *v, const formatdef *f)
1162 {
1163 unsigned long x;
1164 Py_ssize_t i;
1165 if (get_wrapped_ulong(v, &x) < 0)
1166 return -1;
1167 i = f->size;
1168 if (i != SIZEOF_LONG) {
1169 unsigned long maxint = 1;
1170 maxint <<= (unsigned long)(i * 8);
1171 if (x >= maxint)
1172 RANGE_ERROR(x, f, 1, maxint - 1);
1173 }
1174 do {
1175 *p++ = (char)x;
1176 x >>= 8;
1177 } while (--i > 0);
1178 return 0;
1179 }
1180
1181 static int
1182 lp_longlong(char *p, PyObject *v, const formatdef *f)
1183 {
1184 int res;
1185 v = get_pylong(v);
1186 if (v == NULL)
1187 return -1;
1188 res = _PyLong_AsByteArray((PyLongObject*)v,
1189 (unsigned char *)p,
1190 8,
1191 1, /* little_endian */
1192 1 /* signed */);
1193 Py_DECREF(v);
1194 return res;
1195 }
1196
1197 static int
1198 lp_ulonglong(char *p, PyObject *v, const formatdef *f)
1199 {
1200 int res;
1201 v = get_pylong(v);
1202 if (v == NULL)
1203 return -1;
1204 res = _PyLong_AsByteArray((PyLongObject*)v,
1205 (unsigned char *)p,
1206 8,
1207 1, /* little_endian */
1208 0 /* signed */);
1209 Py_DECREF(v);
1210 return res;
1211 }
1212
1213 static int
1214 lp_float(char *p, PyObject *v, const formatdef *f)
1215 {
1216 double x = PyFloat_AsDouble(v);
1217 if (x == -1 && PyErr_Occurred()) {
1218 PyErr_SetString(StructError,
1219 "required argument is not a float");
1220 return -1;
1221 }
1222 return _PyFloat_Pack4(x, (unsigned char *)p, 1);
1223 }
1224
1225 static int
1226 lp_double(char *p, PyObject *v, const formatdef *f)
1227 {
1228 double x = PyFloat_AsDouble(v);
1229 if (x == -1 && PyErr_Occurred()) {
1230 PyErr_SetString(StructError,
1231 "required argument is not a float");
1232 return -1;
1233 }
1234 return _PyFloat_Pack8(x, (unsigned char *)p, 1);
1235 }
1236
1237 static formatdef lilendian_table[] = {
1238 {'x', 1, 0, NULL},
1239 #ifdef PY_STRUCT_OVERFLOW_MASKING
1240 /* Native packers do range checking without overflow masking. */
1241 {'b', 1, 0, nu_byte, lp_int},
1242 {'B', 1, 0, nu_ubyte, lp_uint},
1243 #else
1244 {'b', 1, 0, nu_byte, np_byte},
1245 {'B', 1, 0, nu_ubyte, np_ubyte},
1246 #endif
1247 {'c', 1, 0, nu_char, np_char},
1248 {'s', 1, 0, NULL},
1249 {'p', 1, 0, NULL},
1250 {'h', 2, 0, lu_int, lp_int},
1251 {'H', 2, 0, lu_uint, lp_uint},
1252 {'i', 4, 0, lu_int, lp_int},
1253 {'I', 4, 0, lu_uint, lp_uint},
1254 {'l', 4, 0, lu_int, lp_int},
1255 {'L', 4, 0, lu_uint, lp_uint},
1256 {'q', 8, 0, lu_longlong, lp_longlong},
1257 {'Q', 8, 0, lu_ulonglong, lp_ulonglong},
1258 {'?', 1, 0, bu_bool, bp_bool}, /* Std rep not endian dep,
1259 but potentially different from native rep -- reuse bx_bool funcs. */
1260 {'f', 4, 0, lu_float, lp_float},
1261 {'d', 8, 0, lu_double, lp_double},
1262 {0}
1263 };
1264
1265
1266 static const formatdef *
1267 whichtable(char **pfmt)
1268 {
1269 const char *fmt = (*pfmt)++; /* May be backed out of later */
1270 switch (*fmt) {
1271 case '<':
1272 return lilendian_table;
1273 case '>':
1274 case '!': /* Network byte order is big-endian */
1275 return bigendian_table;
1276 case '=': { /* Host byte order -- different from native in aligment! */
1277 int n = 1;
1278 char *p = (char *) &n;
1279 if (*p == 1)
1280 return lilendian_table;
1281 else
1282 return bigendian_table;
1283 }
1284 default:
1285 --*pfmt; /* Back out of pointer increment */
1286 /* Fall through */
1287 case '@':
1288 return native_table;
1289 }
1290 }
1291
1292
1293 /* Get the table entry for a format code */
1294
1295 static const formatdef *
1296 getentry(int c, const formatdef *f)
1297 {
1298 for (; f->format != '\0'; f++) {
1299 if (f->format == c) {
1300 return f;
1301 }
1302 }
1303 PyErr_SetString(StructError, "bad char in struct format");
1304 return NULL;
1305 }
1306
1307
1308 /* Align a size according to a format code */
1309
1310 static int
1311 align(Py_ssize_t size, char c, const formatdef *e)
1312 {
1313 if (e->format == c) {
1314 if (e->alignment) {
1315 size = ((size + e->alignment - 1)
1316 / e->alignment)
1317 * e->alignment;
1318 }
1319 }
1320 return size;
1321 }
1322
1323
1324 /* calculate the size of a format string */
1325
1326 static int
1327 prepare_s(PyStructObject *self)
1328 {
1329 const formatdef *f;
1330 const formatdef *e;
1331 formatcode *codes;
1332
1333 const char *s;
1334 const char *fmt;
1335 char c;
1336 Py_ssize_t size, len, num, itemsize, x;
1337
1338 fmt = PyString_AS_STRING(self->s_format);
1339
1340 f = whichtable((char **)&fmt);
1341
1342 s = fmt;
1343 size = 0;
1344 len = 0;
1345 while ((c = *s++) != '\0') {
1346 if (isspace(Py_CHARMASK(c)))
1347 continue;
1348 if ('0' <= c && c <= '9') {
1349 num = c - '0';
1350 while ('0' <= (c = *s++) && c <= '9') {
1351 x = num*10 + (c - '0');
1352 if (x/10 != num) {
1353 PyErr_SetString(
1354 StructError,
1355 "overflow in item count");
1356 return -1;
1357 }
1358 num = x;
1359 }
1360 if (c == '\0')
1361 break;
1362 }
1363 else
1364 num = 1;
1365
1366 e = getentry(c, f);
1367 if (e == NULL)
1368 return -1;
1369
1370 switch (c) {
1371 case 's': /* fall through */
1372 case 'p': len++; break;
1373 case 'x': break;
1374 default: len += num; break;
1375 }
1376
1377 itemsize = e->size;
1378 size = align(size, c, e);
1379 x = num * itemsize;
1380 size += x;
1381 if (x/itemsize != num || size < 0) {
1382 PyErr_SetString(StructError,
1383 "total struct size too long");
1384 return -1;
1385 }
1386 }
1387
1388 self->s_size = size;
1389 self->s_len = len;
1390 codes = PyMem_MALLOC((len + 1) * sizeof(formatcode));
1391 if (codes == NULL) {
1392 PyErr_NoMemory();
1393 return -1;
1394 }
1395 self->s_codes = codes;
1396
1397 s = fmt;
1398 size = 0;
1399 while ((c = *s++) != '\0') {
1400 if (isspace(Py_CHARMASK(c)))
1401 continue;
1402 if ('0' <= c && c <= '9') {
1403 num = c - '0';
1404 while ('0' <= (c = *s++) && c <= '9')
1405 num = num*10 + (c - '0');
1406 if (c == '\0')
1407 break;
1408 }
1409 else
1410 num = 1;
1411
1412 e = getentry(c, f);
1413
1414 size = align(size, c, e);
1415 if (c == 's' || c == 'p') {
1416 codes->offset = size;
1417 codes->size = num;
1418 codes->fmtdef = e;
1419 codes++;
1420 size += num;
1421 } else if (c == 'x') {
1422 size += num;
1423 } else {
1424 while (--num >= 0) {
1425 codes->offset = size;
1426 codes->size = e->size;
1427 codes->fmtdef = e;
1428 codes++;
1429 size += e->size;
1430 }
1431 }
1432 }
1433 codes->fmtdef = NULL;
1434 codes->offset = size;
1435 codes->size = 0;
1436
1437 return 0;
1438 }
1439
1440 static PyObject *
1441 s_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1442 {
1443 PyObject *self;
1444
1445 assert(type != NULL && type->tp_alloc != NULL);
1446
1447 self = type->tp_alloc(type, 0);
1448 if (self != NULL) {
1449 PyStructObject *s = (PyStructObject*)self;
1450 Py_INCREF(Py_None);
1451 s->s_format = Py_None;
1452 s->s_codes = NULL;
1453 s->s_size = -1;
1454 s->s_len = -1;
1455 }
1456 return self;
1457 }
1458
1459 static int
1460 s_init(PyObject *self, PyObject *args, PyObject *kwds)
1461 {
1462 PyStructObject *soself = (PyStructObject *)self;
1463 PyObject *o_format = NULL;
1464 int ret = 0;
1465 static char *kwlist[] = {"format", 0};
1466
1467 assert(PyStruct_Check(self));
1468
1469 if (!PyArg_ParseTupleAndKeywords(args, kwds, "S:Struct", kwlist,
1470 &o_format))
1471 return -1;
1472
1473 Py_INCREF(o_format);
1474 Py_CLEAR(soself->s_format);
1475 soself->s_format = o_format;
1476
1477 ret = prepare_s(soself);
1478 return ret;
1479 }
1480
1481 static void
1482 s_dealloc(PyStructObject *s)
1483 {
1484 if (s->weakreflist != NULL)
1485 PyObject_ClearWeakRefs((PyObject *)s);
1486 if (s->s_codes != NULL) {
1487 PyMem_FREE(s->s_codes);
1488 }
1489 Py_XDECREF(s->s_format);
1490 Py_TYPE(s)->tp_free((PyObject *)s);
1491 }
1492
1493 static PyObject *
1494 s_unpack_internal(PyStructObject *soself, char *startfrom) {
1495 formatcode *code;
1496 Py_ssize_t i = 0;
1497 PyObject *result = PyTuple_New(soself->s_len);
1498 if (result == NULL)
1499 return NULL;
1500
1501 for (code = soself->s_codes; code->fmtdef != NULL; code++) {
1502 PyObject *v;
1503 const formatdef *e = code->fmtdef;
1504 const char *res = startfrom + code->offset;
1505 if (e->format == 's') {
1506 v = PyString_FromStringAndSize(res, code->size);
1507 } else if (e->format == 'p') {
1508 Py_ssize_t n = *(unsigned char*)res;
1509 if (n >= code->size)
1510 n = code->size - 1;
1511 v = PyString_FromStringAndSize(res + 1, n);
1512 } else {
1513 v = e->unpack(res, e);
1514 }
1515 if (v == NULL)
1516 goto fail;
1517 PyTuple_SET_ITEM(result, i++, v);
1518 }
1519
1520 return result;
1521 fail:
1522 Py_DECREF(result);
1523 return NULL;
1524 }
1525
1526
1527 PyDoc_STRVAR(s_unpack__doc__,
1528 "S.unpack(str) -> (v1, v2, ...)\n\
1529 \n\
1530 Return tuple containing values unpacked according to this Struct's format.\n\
1531 Requires len(str) == self.size. See struct.__doc__ for more on format\n\
1532 strings.");
1533
1534 static PyObject *
1535 s_unpack(PyObject *self, PyObject *inputstr)
1536 {
1537 char *start;
1538 Py_ssize_t len;
1539 PyObject *args=NULL, *result;
1540 PyStructObject *soself = (PyStructObject *)self;
1541 assert(PyStruct_Check(self));
1542 assert(soself->s_codes != NULL);
1543 if (inputstr == NULL)
1544 goto fail;
1545 if (PyString_Check(inputstr) &&
1546 PyString_GET_SIZE(inputstr) == soself->s_size) {
1547 return s_unpack_internal(soself, PyString_AS_STRING(inputstr));
1548 }
1549 args = PyTuple_Pack(1, inputstr);
1550 if (args == NULL)
1551 return NULL;
1552 if (!PyArg_ParseTuple(args, "s#:unpack", &start, &len))
1553 goto fail;
1554 if (soself->s_size != len)
1555 goto fail;
1556 result = s_unpack_internal(soself, start);
1557 Py_DECREF(args);
1558 return result;
1559
1560 fail:
1561 Py_XDECREF(args);
1562 PyErr_Format(StructError,
1563 "unpack requires a string argument of length %zd",
1564 soself->s_size);
1565 return NULL;
1566 }
1567
1568 PyDoc_STRVAR(s_unpack_from__doc__,
1569 "S.unpack_from(buffer[, offset]) -> (v1, v2, ...)\n\
1570 \n\
1571 Return tuple containing values unpacked according to this Struct's format.\n\
1572 Unlike unpack, unpack_from can unpack values from any object supporting\n\
1573 the buffer API, not just str. Requires len(buffer[offset:]) >= self.size.\n\
1574 See struct.__doc__ for more on format strings.");
1575
1576 static PyObject *
1577 s_unpack_from(PyObject *self, PyObject *args, PyObject *kwds)
1578 {
1579 static char *kwlist[] = {"buffer", "offset", 0};
1580 #if (PY_VERSION_HEX < 0x02050000)
1581 static char *fmt = "z#|i:unpack_from";
1582 #else
1583 static char *fmt = "z#|n:unpack_from";
1584 #endif
1585 Py_ssize_t buffer_len = 0, offset = 0;
1586 char *buffer = NULL;
1587 PyStructObject *soself = (PyStructObject *)self;
1588 assert(PyStruct_Check(self));
1589 assert(soself->s_codes != NULL);
1590
1591 if (!PyArg_ParseTupleAndKeywords(args, kwds, fmt, kwlist,
1592 &buffer, &buffer_len, &offset))
1593 return NULL;
1594
1595 if (buffer == NULL) {
1596 PyErr_Format(StructError,
1597 "unpack_from requires a buffer argument");
1598 return NULL;
1599 }
1600
1601 if (offset < 0)
1602 offset += buffer_len;
1603
1604 if (offset < 0 || (buffer_len - offset) < soself->s_size) {
1605 PyErr_Format(StructError,
1606 "unpack_from requires a buffer of at least %zd bytes",
1607 soself->s_size);
1608 return NULL;
1609 }
1610 return s_unpack_internal(soself, buffer + offset);
1611 }
1612
1613
1614 /*
1615 * Guts of the pack function.
1616 *
1617 * Takes a struct object, a tuple of arguments, and offset in that tuple of
1618 * argument for where to start processing the arguments for packing, and a
1619 * character buffer for writing the packed string. The caller must insure
1620 * that the buffer may contain the required length for packing the arguments.
1621 * 0 is returned on success, 1 is returned if there is an error.
1622 *
1623 */
1624 static int
1625 s_pack_internal(PyStructObject *soself, PyObject *args, int offset, char* buf)
1626 {
1627 formatcode *code;
1628 /* XXX(nnorwitz): why does i need to be a local? can we use
1629 the offset parameter or do we need the wider width? */
1630 Py_ssize_t i;
1631
1632 memset(buf, '\0', soself->s_size);
1633 i = offset;
1634 for (code = soself->s_codes; code->fmtdef != NULL; code++) {
1635 Py_ssize_t n;
1636 PyObject *v = PyTuple_GET_ITEM(args, i++);
1637 const formatdef *e = code->fmtdef;
1638 char *res = buf + code->offset;
1639 if (e->format == 's') {
1640 if (!PyString_Check(v)) {
1641 PyErr_SetString(StructError,
1642 "argument for 's' must be a string");
1643 return -1;
1644 }
1645 n = PyString_GET_SIZE(v);
1646 if (n > code->size)
1647 n = code->size;
1648 if (n > 0)
1649 memcpy(res, PyString_AS_STRING(v), n);
1650 } else if (e->format == 'p') {
1651 if (!PyString_Check(v)) {
1652 PyErr_SetString(StructError,
1653 "argument for 'p' must be a string");
1654 return -1;
1655 }
1656 n = PyString_GET_SIZE(v);
1657 if (n > (code->size - 1))
1658 n = code->size - 1;
1659 if (n > 0)
1660 memcpy(res + 1, PyString_AS_STRING(v), n);
1661 if (n > 255)
1662 n = 255;
1663 *res = Py_SAFE_DOWNCAST(n, Py_ssize_t, unsigned char);
1664 } else {
1665 if (e->pack(res, v, e) < 0) {
1666 if (PyLong_Check(v) && PyErr_ExceptionMatches(PyExc_OverflowError))
1667 PyErr_SetString(StructError,
1668 "long too large to convert to int");
1669 return -1;
1670 }
1671 }
1672 }
1673
1674 /* Success */
1675 return 0;
1676 }
1677
1678
1679 PyDoc_STRVAR(s_pack__doc__,
1680 "S.pack(v1, v2, ...) -> string\n\
1681 \n\
1682 Return a string containing values v1, v2, ... packed according to this\n\
1683 Struct's format. See struct.__doc__ for more on format strings.");
1684
1685 static PyObject *
1686 s_pack(PyObject *self, PyObject *args)
1687 {
1688 PyStructObject *soself;
1689 PyObject *result;
1690
1691 /* Validate arguments. */
1692 soself = (PyStructObject *)self;
1693 assert(PyStruct_Check(self));
1694 assert(soself->s_codes != NULL);
1695 if (PyTuple_GET_SIZE(args) != soself->s_len)
1696 {
1697 PyErr_Format(StructError,
1698 "pack requires exactly %zd arguments", soself->s_len);
1699 return NULL;
1700 }
1701
1702 /* Allocate a new string */
1703 result = PyString_FromStringAndSize((char *)NULL, soself->s_size);
1704 if (result == NULL)
1705 return NULL;
1706
1707 /* Call the guts */
1708 if ( s_pack_internal(soself, args, 0, PyString_AS_STRING(result)) != 0 ) {
1709 Py_DECREF(result);
1710 return NULL;
1711 }
1712
1713 return result;
1714 }
1715
1716 PyDoc_STRVAR(s_pack_into__doc__,
1717 "S.pack_into(buffer, offset, v1, v2, ...)\n\
1718 \n\
1719 Pack the values v1, v2, ... according to this Struct's format, write \n\
1720 the packed bytes into the writable buffer buf starting at offset. Note\n\
1721 that the offset is not an optional argument. See struct.__doc__ for \n\
1722 more on format strings.");
1723
1724 static PyObject *
1725 s_pack_into(PyObject *self, PyObject *args)
1726 {
1727 PyStructObject *soself;
1728 char *buffer;
1729 Py_ssize_t buffer_len, offset;
1730
1731 /* Validate arguments. +1 is for the first arg as buffer. */
1732 soself = (PyStructObject *)self;
1733 assert(PyStruct_Check(self));
1734 assert(soself->s_codes != NULL);
1735 if (PyTuple_GET_SIZE(args) != (soself->s_len + 2))
1736 {
1737 PyErr_Format(StructError,
1738 "pack_into requires exactly %zd arguments",
1739 (soself->s_len + 2));
1740 return NULL;
1741 }
1742
1743 /* Extract a writable memory buffer from the first argument */
1744 if ( PyObject_AsWriteBuffer(PyTuple_GET_ITEM(args, 0),
1745 (void**)&buffer, &buffer_len) == -1 ) {
1746 return NULL;
1747 }
1748 assert( buffer_len >= 0 );
1749
1750 /* Extract the offset from the first argument */
1751 offset = PyInt_AsSsize_t(PyTuple_GET_ITEM(args, 1));
1752
1753 /* Support negative offsets. */
1754 if (offset < 0)
1755 offset += buffer_len;
1756
1757 /* Check boundaries */
1758 if (offset < 0 || (buffer_len - offset) < soself->s_size) {
1759 PyErr_Format(StructError,
1760 "pack_into requires a buffer of at least %zd bytes",
1761 soself->s_size);
1762 return NULL;
1763 }
1764
1765 /* Call the guts */
1766 if ( s_pack_internal(soself, args, 2, buffer + offset) != 0 ) {
1767 return NULL;
1768 }
1769
1770 Py_RETURN_NONE;
1771 }
1772
1773 static PyObject *
1774 s_get_format(PyStructObject *self, void *unused)
1775 {
1776 Py_INCREF(self->s_format);
1777 return self->s_format;
1778 }
1779
1780 static PyObject *
1781 s_get_size(PyStructObject *self, void *unused)
1782 {
1783 return PyInt_FromSsize_t(self->s_size);
1784 }
1785
1786 /* List of functions */
1787
1788 static struct PyMethodDef s_methods[] = {
1789 {"pack", s_pack, METH_VARARGS, s_pack__doc__},
1790 {"pack_into", s_pack_into, METH_VARARGS, s_pack_into__doc__},
1791 {"unpack", s_unpack, METH_O, s_unpack__doc__},
1792 {"unpack_from", (PyCFunction)s_unpack_from, METH_VARARGS|METH_KEYWORDS,
1793 s_unpack_from__doc__},
1794 {NULL, NULL} /* sentinel */
1795 };
1796
1797 PyDoc_STRVAR(s__doc__, "Compiled struct object");
1798
1799 #define OFF(x) offsetof(PyStructObject, x)
1800
1801 static PyGetSetDef s_getsetlist[] = {
1802 {"format", (getter)s_get_format, (setter)NULL, "struct format string", NULL},
1803 {"size", (getter)s_get_size, (setter)NULL, "struct size in bytes", NULL},
1804 {NULL} /* sentinel */
1805 };
1806
1807 static
1808 PyTypeObject PyStructType = {
1809 PyVarObject_HEAD_INIT(NULL, 0)
1810 "Struct",
1811 sizeof(PyStructObject),
1812 0,
1813 (destructor)s_dealloc, /* tp_dealloc */
1814 0, /* tp_print */
1815 0, /* tp_getattr */
1816 0, /* tp_setattr */
1817 0, /* tp_compare */
1818 0, /* tp_repr */
1819 0, /* tp_as_number */
1820 0, /* tp_as_sequence */
1821 0, /* tp_as_mapping */
1822 0, /* tp_hash */
1823 0, /* tp_call */
1824 0, /* tp_str */
1825 PyObject_GenericGetAttr, /* tp_getattro */
1826 PyObject_GenericSetAttr, /* tp_setattro */
1827 0, /* tp_as_buffer */
1828 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_WEAKREFS,/* tp_flags */
1829 s__doc__, /* tp_doc */
1830 0, /* tp_traverse */
1831 0, /* tp_clear */
1832 0, /* tp_richcompare */
1833 offsetof(PyStructObject, weakreflist), /* tp_weaklistoffset */
1834 0, /* tp_iter */
1835 0, /* tp_iternext */
1836 s_methods, /* tp_methods */
1837 NULL, /* tp_members */
1838 s_getsetlist, /* tp_getset */
1839 0, /* tp_base */
1840 0, /* tp_dict */
1841 0, /* tp_descr_get */
1842 0, /* tp_descr_set */
1843 0, /* tp_dictoffset */
1844 s_init, /* tp_init */
1845 PyType_GenericAlloc,/* tp_alloc */
1846 s_new, /* tp_new */
1847 PyObject_Del, /* tp_free */
1848 };
1849
1850
1851 /* ---- Standalone functions ---- */
1852
1853 #define MAXCACHE 100
1854 static PyObject *cache = NULL;
1855
1856 static PyObject *
1857 cache_struct(PyObject *fmt)
1858 {
1859 PyObject * s_object;
1860
1861 if (cache == NULL) {
1862 cache = PyDict_New();
1863 if (cache == NULL)
1864 return NULL;
1865 }
1866
1867 s_object = PyDict_GetItem(cache, fmt);
1868 if (s_object != NULL) {
1869 Py_INCREF(s_object);
1870 return s_object;
1871 }
1872
1873 s_object = PyObject_CallFunctionObjArgs((PyObject *)(&PyStructType), fmt, NULL);
1874 if (s_object != NULL) {
1875 if (PyDict_Size(cache) >= MAXCACHE)
1876 PyDict_Clear(cache);
1877 /* Attempt to cache the result */
1878 if (PyDict_SetItem(cache, fmt, s_object) == -1)
1879 PyErr_Clear();
1880 }
1881 return s_object;
1882 }
1883
1884 PyDoc_STRVAR(clearcache_doc,
1885 "Clear the internal cache.");
1886
1887 static PyObject *
1888 clearcache(PyObject *self)
1889 {
1890 Py_CLEAR(cache);
1891 Py_RETURN_NONE;
1892 }
1893
1894 PyDoc_STRVAR(calcsize_doc,
1895 "Return size of C struct described by format string fmt.");
1896
1897 static PyObject *
1898 calcsize(PyObject *self, PyObject *fmt)
1899 {
1900 Py_ssize_t n;
1901 PyObject *s_object = cache_struct(fmt);
1902 if (s_object == NULL)
1903 return NULL;
1904 n = ((PyStructObject *)s_object)->s_size;
1905 Py_DECREF(s_object);
1906 return PyInt_FromSsize_t(n);
1907 }
1908
1909 PyDoc_STRVAR(pack_doc,
1910 "Return string containing values v1, v2, ... packed according to fmt.");
1911
1912 static PyObject *
1913 pack(PyObject *self, PyObject *args)
1914 {
1915 PyObject *s_object, *fmt, *newargs, *result;
1916 Py_ssize_t n = PyTuple_GET_SIZE(args);
1917
1918 if (n == 0) {
1919 PyErr_SetString(PyExc_TypeError, "missing format argument");
1920 return NULL;
1921 }
1922 fmt = PyTuple_GET_ITEM(args, 0);
1923 newargs = PyTuple_GetSlice(args, 1, n);
1924 if (newargs == NULL)
1925 return NULL;
1926
1927 s_object = cache_struct(fmt);
1928 if (s_object == NULL) {
1929 Py_DECREF(newargs);
1930 return NULL;
1931 }
1932 result = s_pack(s_object, newargs);
1933 Py_DECREF(newargs);
1934 Py_DECREF(s_object);
1935 return result;
1936 }
1937
1938 PyDoc_STRVAR(pack_into_doc,
1939 "Pack the values v1, v2, ... according to fmt.\n\
1940 Write the packed bytes into the writable buffer buf starting at offset.");
1941
1942 static PyObject *
1943 pack_into(PyObject *self, PyObject *args)
1944 {
1945 PyObject *s_object, *fmt, *newargs, *result;
1946 Py_ssize_t n = PyTuple_GET_SIZE(args);
1947
1948 if (n == 0) {
1949 PyErr_SetString(PyExc_TypeError, "missing format argument");
1950 return NULL;
1951 }
1952 fmt = PyTuple_GET_ITEM(args, 0);
1953 newargs = PyTuple_GetSlice(args, 1, n);
1954 if (newargs == NULL)
1955 return NULL;
1956
1957 s_object = cache_struct(fmt);
1958 if (s_object == NULL) {
1959 Py_DECREF(newargs);
1960 return NULL;
1961 }
1962 result = s_pack_into(s_object, newargs);
1963 Py_DECREF(newargs);
1964 Py_DECREF(s_object);
1965 return result;
1966 }
1967
1968 PyDoc_STRVAR(unpack_doc,
1969 "Unpack the string containing packed C structure data, according to fmt.\n\
1970 Requires len(string) == calcsize(fmt).");
1971
1972 static PyObject *
1973 unpack(PyObject *self, PyObject *args)
1974 {
1975 PyObject *s_object, *fmt, *inputstr, *result;
1976
1977 if (!PyArg_UnpackTuple(args, "unpack", 2, 2, &fmt, &inputstr))
1978 return NULL;
1979
1980 s_object = cache_struct(fmt);
1981 if (s_object == NULL)
1982 return NULL;
1983 result = s_unpack(s_object, inputstr);
1984 Py_DECREF(s_object);
1985 return result;
1986 }
1987
1988 PyDoc_STRVAR(unpack_from_doc,
1989 "Unpack the buffer, containing packed C structure data, according to\n\
1990 fmt, starting at offset. Requires len(buffer[offset:]) >= calcsize(fmt).");
1991
1992 static PyObject *
1993 unpack_from(PyObject *self, PyObject *args, PyObject *kwds)
1994 {
1995 PyObject *s_object, *fmt, *newargs, *result;
1996 Py_ssize_t n = PyTuple_GET_SIZE(args);
1997
1998 if (n == 0) {
1999 PyErr_SetString(PyExc_TypeError, "missing format argument");
2000 return NULL;
2001 }
2002 fmt = PyTuple_GET_ITEM(args, 0);
2003 newargs = PyTuple_GetSlice(args, 1, n);
2004 if (newargs == NULL)
2005 return NULL;
2006
2007 s_object = cache_struct(fmt);
2008 if (s_object == NULL) {
2009 Py_DECREF(newargs);
2010 return NULL;
2011 }
2012 result = s_unpack_from(s_object, newargs, kwds);
2013 Py_DECREF(newargs);
2014 Py_DECREF(s_object);
2015 return result;
2016 }
2017
2018 static struct PyMethodDef module_functions[] = {
2019 {"_clearcache", (PyCFunction)clearcache, METH_NOARGS, clearcache_doc},
2020 {"calcsize", calcsize, METH_O, calcsize_doc},
2021 {"pack", pack, METH_VARARGS, pack_doc},
2022 {"pack_into", pack_into, METH_VARARGS, pack_into_doc},
2023 {"unpack", unpack, METH_VARARGS, unpack_doc},
2024 {"unpack_from", (PyCFunction)unpack_from,
2025 METH_VARARGS|METH_KEYWORDS, unpack_from_doc},
2026 {NULL, NULL} /* sentinel */
2027 };
2028
2029
2030 /* Module initialization */
2031
2032 PyDoc_STRVAR(module_doc,
2033 "Functions to convert between Python values and C structs.\n\
2034 Python strings are used to hold the data representing the C struct\n\
2035 and also as format strings to describe the layout of data in the C struct.\n\
2036 \n\
2037 The optional first format char indicates byte order, size and alignment:\n\
2038 @: native order, size & alignment (default)\n\
2039 =: native order, std. size & alignment\n\
2040 <: little-endian, std. size & alignment\n\
2041 >: big-endian, std. size & alignment\n\
2042 !: same as >\n\
2043 \n\
2044 The remaining chars indicate types of args and must match exactly;\n\
2045 these can be preceded by a decimal repeat count:\n\
2046 x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;\n\
2047 h:short; H:unsigned short; i:int; I:unsigned int;\n\
2048 l:long; L:unsigned long; f:float; d:double.\n\
2049 Special cases (preceding decimal count indicates length):\n\
2050 s:string (array of char); p: pascal string (with count byte).\n\
2051 Special case (only available in native format):\n\
2052 P:an integer type that is wide enough to hold a pointer.\n\
2053 Special case (not in native mode unless 'long long' in platform C):\n\
2054 q:long long; Q:unsigned long long\n\
2055 Whitespace between formats is ignored.\n\
2056 \n\
2057 The variable struct.error is an exception raised on errors.\n");
2058
2059 PyMODINIT_FUNC
2060 init_struct(void)
2061 {
2062 PyObject *ver, *m;
2063
2064 ver = PyString_FromString("0.2");
2065 if (ver == NULL)
2066 return;
2067
2068 m = Py_InitModule3("_struct", module_functions, module_doc);
2069 if (m == NULL)
2070 return;
2071
2072 Py_TYPE(&PyStructType) = &PyType_Type;
2073 if (PyType_Ready(&PyStructType) < 0)
2074 return;
2075
2076 #ifdef PY_STRUCT_OVERFLOW_MASKING
2077 if (pyint_zero == NULL) {
2078 pyint_zero = PyInt_FromLong(0);
2079 if (pyint_zero == NULL)
2080 return;
2081 }
2082 if (pylong_ulong_mask == NULL) {
2083 #if (SIZEOF_LONG == 4)
2084 pylong_ulong_mask = PyLong_FromString("FFFFFFFF", NULL, 16);
2085 #else
2086 pylong_ulong_mask = PyLong_FromString("FFFFFFFFFFFFFFFF", NULL, 16);
2087 #endif
2088 if (pylong_ulong_mask == NULL)
2089 return;
2090 }
2091
2092 #else
2093 /* This speed trick can't be used until overflow masking goes away, because
2094 native endian always raises exceptions instead of overflow masking. */
2095
2096 /* Check endian and swap in faster functions */
2097 {
2098 int one = 1;
2099 formatdef *native = native_table;
2100 formatdef *other, *ptr;
2101 if ((int)*(unsigned char*)&one)
2102 other = lilendian_table;
2103 else
2104 other = bigendian_table;
2105 /* Scan through the native table, find a matching
2106 entry in the endian table and swap in the
2107 native implementations whenever possible
2108 (64-bit platforms may not have "standard" sizes) */
2109 while (native->format != '\0' && other->format != '\0') {
2110 ptr = other;
2111 while (ptr->format != '\0') {
2112 if (ptr->format == native->format) {
2113 /* Match faster when formats are
2114 listed in the same order */
2115 if (ptr == other)
2116 other++;
2117 /* Only use the trick if the
2118 size matches */
2119 if (ptr->size != native->size)
2120 break;
2121 /* Skip float and double, could be
2122 "unknown" float format */
2123 if (ptr->format == 'd' || ptr->format == 'f')
2124 break;
2125 ptr->pack = native->pack;
2126 ptr->unpack = native->unpack;
2127 break;
2128 }
2129 ptr++;
2130 }
2131 native++;
2132 }
2133 }
2134 #endif
2135
2136 /* Add some symbolic constants to the module */
2137 if (StructError == NULL) {
2138 StructError = PyErr_NewException("struct.error", NULL, NULL);
2139 if (StructError == NULL)
2140 return;
2141 }
2142
2143 Py_INCREF(StructError);
2144 PyModule_AddObject(m, "error", StructError);
2145
2146 Py_INCREF((PyObject*)&PyStructType);
2147 PyModule_AddObject(m, "Struct", (PyObject*)&PyStructType);
2148
2149 PyModule_AddObject(m, "__version__", ver);
2150
2151 PyModule_AddIntConstant(m, "_PY_STRUCT_RANGE_CHECKING", 1);
2152 #ifdef PY_STRUCT_OVERFLOW_MASKING
2153 PyModule_AddIntConstant(m, "_PY_STRUCT_OVERFLOW_MASKING", 1);
2154 #endif
2155 #ifdef PY_STRUCT_FLOAT_COERCE
2156 PyModule_AddIntConstant(m, "_PY_STRUCT_FLOAT_COERCE", 1);
2157 #endif
2158
2159 }
python git mirror