← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/_chk_map_pyx.pyx

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-09-19 00:32:14 UTC
  • mfrom: (4685.2.1 bzr.dev)
  • Revision ID: pqm@pqm.ubuntu.com-20090919003214-2dli9jc4y5xhjj3n
(mbp for garyvdm) Revert rename of
        test_merge_uncommitted_otherbasis_ancestor_of_thisbasis.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/_chk_map_pyx.pyx
29
29
 
30
30
cdef extern from "Python.h":
31
31
    ctypedef int Py_ssize_t # Required for older pyrex versions
32
 
    ctypedef struct PyObject:
 
32
    struct _PyObject:
33
33
        pass
 
34
    ctypedef _PyObject PyObject
34
35
    int PyTuple_CheckExact(object p)
35
36
    Py_ssize_t PyTuple_GET_SIZE(object t)
36
37
    int PyString_CheckExact(object)
51
52
    char *PyString_AS_STRING_ptr "PyString_AS_STRING" (PyObject *s)
52
53
    object PyString_FromStringAndSize(char*, Py_ssize_t)
53
54
 
54
 
# cimport all of the definitions we will need to access
55
 
from _static_tuple_c cimport StaticTuple,\
56
 
    import_static_tuple_c, StaticTuple_New, \
57
 
    StaticTuple_Intern, StaticTuple_SET_ITEM, StaticTuple_CheckExact
58
 
 
59
 
cdef extern from "_static_tuple_c.h":
60
 
    # Defined explicitly rather than cimport-ing. Trying to use cimport, the
61
 
    # type for PyObject is a different class that happens to have the same
62
 
    # name...
63
 
    PyObject * StaticTuple_GET_ITEM_ptr "StaticTuple_GET_ITEM" (StaticTuple,
64
 
                                                                Py_ssize_t)
65
 
 
66
55
cdef extern from "zlib.h":
67
56
    ctypedef unsigned long uLong
68
57
    ctypedef unsigned int uInt
71
60
    uLong crc32(uLong crc, Bytef *buf, uInt len)
72
61
 
73
62
 
74
 
# Set up the StaticTuple C_API functionality
75
 
import_static_tuple_c()
76
 
 
77
 
cdef object _LeafNode
78
63
_LeafNode = None
79
 
cdef object _InternalNode
80
64
_InternalNode = None
81
 
cdef object _unknown
82
65
_unknown = None
83
66
 
84
67
# We shouldn't just copy this from _dirstate_helpers_pyx
85
 
cdef void* _my_memrchr(void *s, int c, size_t n): # cannot_raise
 
68
cdef void* _my_memrchr(void *s, int c, size_t n):
86
69
    # memrchr seems to be a GNU extension, so we have to implement it ourselves
87
70
    cdef char *pos
88
71
    cdef char *start
108
91
    cdef char *c_out
109
92
    cdef PyObject *bit
110
93
 
111
 
    if not StaticTuple_CheckExact(key):
112
 
        raise TypeError('key %r is not a StaticTuple' % (key,))
113
 
    num_bits = len(key)
 
94
    if not PyTuple_CheckExact(key):
 
95
        raise TypeError('key %r is not a tuple' % (key,))
 
96
    num_bits = PyTuple_GET_SIZE(key)
114
97
    # 4 bytes per crc32, and another 1 byte between bits
115
98
    num_out_bytes = (9 * num_bits) - 1
116
99
    out = PyString_FromStringAndSize(NULL, num_out_bytes)
122
105
        # We use the _ptr variant, because GET_ITEM returns a borrowed
123
106
        # reference, and Pyrex assumes that returned 'object' are a new
124
107
        # reference
125
 
        bit = StaticTuple_GET_ITEM_ptr(key, i)
 
108
        bit = PyTuple_GET_ITEM_ptr(key, i)
126
109
        if not PyString_CheckExact_ptr(bit):
127
110
            raise TypeError('Bit %d of %r is not a string' % (i, key))
128
111
        c_bit = <Bytef *>PyString_AS_STRING_ptr(bit)
146
129
    cdef char *c_out
147
130
    cdef PyObject *bit
148
131
 
149
 
    if not StaticTuple_CheckExact(key):
150
 
        raise TypeError('key %r is not a StaticTuple' % (key,))
151
 
    num_bits = len(key)
 
132
    if not PyTuple_CheckExact(key):
 
133
        raise TypeError('key %r is not a tuple' % (key,))
 
134
    num_bits = PyTuple_GET_SIZE(key)
152
135
    # 4 bytes per crc32, and another 1 byte between bits
153
136
    num_out_bytes = (5 * num_bits) - 1
154
137
    out = PyString_FromStringAndSize(NULL, num_out_bytes)
157
140
        if i > 0:
158
141
            c_out[0] = c'\x00'
159
142
            c_out = c_out + 1
160
 
        bit = StaticTuple_GET_ITEM_ptr(key, i)
 
143
        bit = PyTuple_GET_ITEM_ptr(key, i)
161
144
        if not PyString_CheckExact_ptr(bit):
162
 
            raise TypeError('Bit %d of %r is not a string: %r'
163
 
                            % (i, key, <object>bit))
 
145
            raise TypeError('Bit %d of %r is not a string: %r' % (i, key,
 
146
            <object>bit))
164
147
        c_bit = <Bytef *>PyString_AS_STRING_ptr(bit)
165
148
        c_len = PyString_GET_SIZE_ptr(bit)
166
149
        crc_val = crc32(0, c_bit, c_len)
212
195
    cdef char *prefix, *value_start, *prefix_tail
213
196
    cdef char *next_null, *last_null, *line_start
214
197
    cdef char *c_entry, *entry_start
215
 
    cdef StaticTuple entry_bits
216
198
 
217
199
    if _LeafNode is None:
218
200
        from bzrlib import chk_map
283
265
            if next_line == NULL:
284
266
                raise ValueError('missing trailing newline')
285
267
            cur = next_line + 1
286
 
        entry_bits = StaticTuple_New(width)
 
268
        entry_bits = PyTuple_New(width)
287
269
        for i from 0 <= i < num_prefix_bits:
288
 
            # TODO: Use PyList_GetItem, or turn prefix_bits into a
289
 
            #       tuple/StaticTuple
290
270
            entry = prefix_bits[i]
291
271
            # SET_ITEM 'steals' a reference
292
272
            Py_INCREF(entry)
293
 
            StaticTuple_SET_ITEM(entry_bits, i, entry)
 
273
            PyTuple_SET_ITEM(entry_bits, i, entry)
294
274
        value = PyString_FromStringAndSize(value_start, next_line - value_start)
295
275
        # The next entry bit needs the 'tail' from the prefix, and first part
296
276
        # of the line
308
288
            memcpy(c_entry + prefix_tail_len, line_start, next_null - line_start)
309
289
        Py_INCREF(entry)
310
290
        i = num_prefix_bits
311
 
        StaticTuple_SET_ITEM(entry_bits, i, entry)
 
291
        PyTuple_SET_ITEM(entry_bits, i, entry)
312
292
        while next_null != last_null: # We have remaining bits
313
293
            i = i + 1
314
294
            if i > width:
321
301
            entry = PyString_FromStringAndSize(entry_start,
322
302
                                               next_null - entry_start)
323
303
            Py_INCREF(entry)
324
 
            StaticTuple_SET_ITEM(entry_bits, i, entry)
 
304
            PyTuple_SET_ITEM(entry_bits, i, entry)
325
305
        if len(entry_bits) != width:
326
306
            raise AssertionError(
327
307
                'Incorrect number of elements (%d vs %d)'
328
308
                % (len(entry_bits)+1, width + 1))
329
 
        entry_bits = StaticTuple_Intern(entry_bits)
330
309
        PyDict_SetItem(items, entry_bits, value)
331
310
    if len(items) != length:
332
311
        raise ValueError("item count (%d) mismatch for key %s,"
364
343
        _unknown = chk_map._unknown
365
344
    result = _InternalNode(search_key_func=search_key_func)
366
345
 
367
 
    if not StaticTuple_CheckExact(key):
368
 
        raise TypeError('key %r is not a StaticTuple' % (key,))
369
346
    if not PyString_CheckExact(bytes):
370
347
        raise TypeError('bytes must be a plain string not %s' % (type(bytes),))
371
348
 
407
384
        memcpy(c_item_prefix + prefix_length, cur, next_null - cur)
408
385
        flat_key = PyString_FromStringAndSize(next_null + 1,
409
386
                                              next_line - next_null - 1)
410
 
        flat_key = StaticTuple(flat_key).intern()
411
 
        PyDict_SetItem(items, item_prefix, flat_key)
 
387
        PyDict_SetItem(items, item_prefix, (flat_key,))
412
388
        cur = next_line + 1
413
389
    assert len(items) > 0
414
390
    result._items = items
422
398
    result._node_width = len(item_prefix)
423
399
    result._search_prefix = PyString_FromStringAndSize(prefix, prefix_length)
424
400
    return result
 
401