/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/_bencode_pyx.pyx

  • Committer: Martin Pool
  • Date: 2009-07-27 06:28:35 UTC
  • mto: This revision was merged to the branch mainline in revision 4587.
  • Revision ID: mbp@sourcefrog.net-20090727062835-o66p8it658tq1sma
Add CountedLock.get_physical_lock_status

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/_bencode_pyx.pyx
1
 
# Copyright (C) 2007, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2007,2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
"""Pyrex implementation for bencode coder/decoder"""
18
18
 
19
 
from __future__ import absolute_import
20
 
 
21
 
from cpython.bool cimport (
22
 
    PyBool_Check,
23
 
    )
24
 
from cpython.bytes cimport (
25
 
    PyBytes_CheckExact,
26
 
    PyBytes_FromStringAndSize,
27
 
    PyBytes_AS_STRING,
28
 
    PyBytes_GET_SIZE,
29
 
    )
30
 
from cpython.dict cimport (
31
 
    PyDict_CheckExact,
32
 
    )
33
 
from cpython.int cimport (
34
 
    PyInt_CheckExact,
35
 
    PyInt_FromString,
36
 
    )
37
 
from cpython.list cimport (
38
 
    PyList_CheckExact,
39
 
    PyList_Append,
40
 
    )
41
 
from cpython.long cimport (
42
 
    PyLong_CheckExact,
43
 
    )
44
 
from cpython.mem cimport (
45
 
    PyMem_Free,
46
 
    PyMem_Malloc,
47
 
    PyMem_Realloc,
48
 
    )
49
 
from cpython.tuple cimport (
50
 
    PyTuple_CheckExact,
51
 
    )
52
 
 
53
 
from libc.stdlib cimport (
54
 
    strtol,
55
 
    )
56
 
from libc.string cimport (
57
 
    memcpy,
58
 
    )
 
19
 
 
20
cdef extern from "stddef.h":
 
21
    ctypedef unsigned int size_t
 
22
 
 
23
cdef extern from "Python.h":
 
24
    ctypedef int  Py_ssize_t
 
25
    int PyInt_CheckExact(object o)
 
26
    int PyLong_CheckExact(object o)
 
27
    int PyString_CheckExact(object o)
 
28
    int PyTuple_CheckExact(object o)
 
29
    int PyList_CheckExact(object o)
 
30
    int PyDict_CheckExact(object o)
 
31
    int PyBool_Check(object o)
 
32
    object PyString_FromStringAndSize(char *v, Py_ssize_t len)
 
33
    char *PyString_AS_STRING(object o) except NULL
 
34
    Py_ssize_t PyString_GET_SIZE(object o) except -1
 
35
    object PyInt_FromString(char *str, char **pend, int base)
 
36
    int Py_GetRecursionLimit()
 
37
    int Py_EnterRecursiveCall(char *)
 
38
    void Py_LeaveRecursiveCall()
 
39
 
 
40
    int PyList_Append(object, object) except -1
 
41
 
 
42
cdef extern from "stdlib.h":
 
43
    void free(void *memblock)
 
44
    void *malloc(size_t size)
 
45
    void *realloc(void *memblock, size_t size)
 
46
    long strtol(char *, char **, int)
 
47
 
 
48
cdef extern from "string.h":
 
49
    void *memcpy(void *dest, void *src, size_t count)
59
50
 
60
51
cdef extern from "python-compat.h":
61
52
    int snprintf(char* buffer, size_t nsize, char* fmt, ...)
62
 
    # Use wrapper with inverted error return so Cython can propogate
63
 
    int BrzPy_EnterRecursiveCall(char *) except 0
64
 
 
65
 
cdef extern from "Python.h":
66
 
    void Py_LeaveRecursiveCall()
67
53
 
68
54
cdef class Decoder
69
55
cdef class Encoder
72
58
    void D_UPDATE_TAIL(Decoder, int n)
73
59
    void E_UPDATE_TAIL(Encoder, int n)
74
60
 
75
 
from ._static_tuple_c cimport StaticTuple, StaticTuple_CheckExact, \
76
 
    import_static_tuple_c
77
 
 
78
 
import_static_tuple_c()
79
 
 
80
61
 
81
62
cdef class Decoder:
82
63
    """Bencode decoder"""
90
71
        """Initialize decoder engine.
91
72
        @param  s:  Python string.
92
73
        """
93
 
        if not PyBytes_CheckExact(s):
94
 
            raise TypeError("bytes required")
 
74
        if not PyString_CheckExact(s):
 
75
            raise TypeError("String required")
95
76
 
96
77
        self.text = s
97
 
        self.tail = PyBytes_AS_STRING(s)
98
 
        self.size = PyBytes_GET_SIZE(s)
 
78
        self.tail = PyString_AS_STRING(s)
 
79
        self.size = PyString_GET_SIZE(s)
99
80
        self._yield_tuples = int(yield_tuples)
100
81
 
101
82
    def decode(self):
113
94
        if 0 == self.size:
114
95
            raise ValueError('stream underflow')
115
96
 
116
 
        BrzPy_EnterRecursiveCall(" while bencode decoding")
 
97
        if Py_EnterRecursiveCall("_decode_object"):
 
98
            raise RuntimeError("too deeply nested")
117
99
        try:
118
100
            ch = self.tail[0]
119
101
            if c'0' <= ch <= c'9':
127
109
            elif ch == c'd':
128
110
                D_UPDATE_TAIL(self, 1)
129
111
                return self._decode_dict()
 
112
            else:
 
113
                raise ValueError('unknown object type identifier %r' % ch)
130
114
        finally:
131
115
            Py_LeaveRecursiveCall()
132
 
        raise ValueError('unknown object type identifier %r' % ch)
133
116
 
134
117
    cdef int _read_digits(self, char stop_char) except -1:
135
118
        cdef int i
176
159
            raise ValueError('leading zeros are not allowed')
177
160
        D_UPDATE_TAIL(self, next_tail - self.tail + 1)
178
161
        if n == 0:
179
 
            return b''
 
162
            return ''
180
163
        if n > self.size:
181
164
            raise ValueError('stream underflow')
182
165
        if n < 0:
183
166
            raise ValueError('string size below zero: %d' % n)
184
167
 
185
 
        result = PyBytes_FromStringAndSize(self.tail, n)
 
168
        result = PyString_FromStringAndSize(self.tail, n)
186
169
        D_UPDATE_TAIL(self, n)
187
170
        return result
188
171
 
220
203
                if self.tail[0] < c'0' or self.tail[0] > c'9':
221
204
                    raise ValueError('key was not a simple string.')
222
205
                key = self._decode_string()
223
 
                if lastkey is not None and lastkey >= key:
 
206
                if lastkey >= key:
224
207
                    raise ValueError('dict keys disordered')
225
208
                else:
226
209
                    lastkey = key
270
253
        self.size = 0
271
254
        self.tail = NULL
272
255
 
273
 
        p = <char*>PyMem_Malloc(maxsize)
 
256
        p = <char*>malloc(maxsize)
274
257
        if p == NULL:
275
258
            raise MemoryError('Not enough memory to allocate buffer '
276
259
                              'for encoder')
278
261
        self.maxsize = maxsize
279
262
        self.tail = p
280
263
 
281
 
    def __dealloc__(self):
282
 
        PyMem_Free(self.buffer)
 
264
    def __del__(self):
 
265
        free(self.buffer)
283
266
        self.buffer = NULL
284
267
        self.maxsize = 0
285
268
 
286
 
    def to_bytes(self):
 
269
    def __str__(self):
287
270
        if self.buffer != NULL and self.size != 0:
288
 
            return PyBytes_FromStringAndSize(self.buffer, self.size)
289
 
        return b''
 
271
            return PyString_FromStringAndSize(self.buffer, self.size)
 
272
        else:
 
273
            return ''
290
274
 
291
275
    cdef int _ensure_buffer(self, int required) except 0:
292
276
        """Ensure that tail of CharTail buffer has enough size.
302
286
        new_size = self.maxsize
303
287
        while new_size < self.size + required:
304
288
            new_size = new_size * 2
305
 
        new_buffer = <char*>PyMem_Realloc(self.buffer, <size_t>new_size)
 
289
        new_buffer = <char*>realloc(self.buffer, <size_t>new_size)
306
290
        if new_buffer == NULL:
307
291
            raise MemoryError('Cannot realloc buffer for encoder')
308
292
 
317
301
        """
318
302
        cdef int n
319
303
        self._ensure_buffer(INT_BUF_SIZE)
320
 
        n = snprintf(self.tail, INT_BUF_SIZE, b"i%de", x)
 
304
        n = snprintf(self.tail, INT_BUF_SIZE, "i%de", x)
321
305
        if n < 0:
322
306
            raise MemoryError('int %d too big to encode' % x)
323
307
        E_UPDATE_TAIL(self, n)
324
308
        return 1
325
309
 
326
310
    cdef int _encode_long(self, x) except 0:
327
 
        return self._append_string(b'i%de' % x)
 
311
        return self._append_string(''.join(('i', str(x), 'e')))
328
312
 
329
313
    cdef int _append_string(self, s) except 0:
330
314
        cdef Py_ssize_t n
331
 
        n = PyBytes_GET_SIZE(s)
 
315
        n = PyString_GET_SIZE(s)
332
316
        self._ensure_buffer(n)
333
 
        memcpy(self.tail, PyBytes_AS_STRING(s), n)
 
317
        memcpy(self.tail, PyString_AS_STRING(s), n)
334
318
        E_UPDATE_TAIL(self, n)
335
319
        return 1
336
320
 
337
321
    cdef int _encode_string(self, x) except 0:
338
322
        cdef int n
339
323
        cdef Py_ssize_t x_len
340
 
        x_len = PyBytes_GET_SIZE(x)
 
324
        x_len = PyString_GET_SIZE(x)
341
325
        self._ensure_buffer(x_len + INT_BUF_SIZE)
342
 
        n = snprintf(self.tail, INT_BUF_SIZE, b'%ld:', x_len)
 
326
        n = snprintf(self.tail, INT_BUF_SIZE, '%d:', x_len)
343
327
        if n < 0:
344
328
            raise MemoryError('string %s too big to encode' % x)
345
 
        memcpy(<void *>(self.tail+n), PyBytes_AS_STRING(x), x_len)
 
329
        memcpy(<void *>(self.tail+n), PyString_AS_STRING(x), x_len)
346
330
        E_UPDATE_TAIL(self, n + x_len)
347
331
        return 1
348
332
 
364
348
        self.tail[0] = c'd'
365
349
        E_UPDATE_TAIL(self, 1)
366
350
 
367
 
        for k in sorted(x):
368
 
            if not PyBytes_CheckExact(k):
 
351
        keys = x.keys()
 
352
        keys.sort()
 
353
        for k in keys:
 
354
            if not PyString_CheckExact(k):
369
355
                raise TypeError('key in dict should be string')
370
356
            self._encode_string(k)
371
357
            self.process(x[k])
375
361
        E_UPDATE_TAIL(self, 1)
376
362
        return 1
377
363
 
378
 
    cpdef object process(self, object x):
379
 
        BrzPy_EnterRecursiveCall(" while bencode encoding")
 
364
    def process(self, object x):
 
365
        if Py_EnterRecursiveCall("encode"):
 
366
            raise RuntimeError("too deeply nested")
380
367
        try:
381
 
            if PyBytes_CheckExact(x):
 
368
            if PyString_CheckExact(x):
382
369
                self._encode_string(x)
383
 
            elif PyInt_CheckExact(x) and x.bit_length() < 32:
 
370
            elif PyInt_CheckExact(x):
384
371
                self._encode_int(x)
385
372
            elif PyLong_CheckExact(x):
386
373
                self._encode_long(x)
387
 
            elif (PyList_CheckExact(x) or PyTuple_CheckExact(x)
388
 
                  or isinstance(x, StaticTuple)):
 
374
            elif PyList_CheckExact(x) or PyTuple_CheckExact(x):
389
375
                self._encode_list(x)
390
376
            elif PyDict_CheckExact(x):
391
377
                self._encode_dict(x)
403
389
    """Encode Python object x to string"""
404
390
    encoder = Encoder()
405
391
    encoder.process(x)
406
 
    return encoder.to_bytes()
 
392
    return str(encoder)