← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/_chk_map_pyx.pyx

Merge the 2.1-simple-set branch

But revert the changes to bzrlib/_btree_serializer_pyx.pyx that didn't end up in that branch.
And restore the export and import headers.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/_chk_map_pyx.pyx
59
59
 
60
60
    uLong crc32(uLong crc, Bytef *buf, uInt len)
61
61
 
62
 
# It seems we need to import the definitions so that the pyrex compiler has
63
 
# local names to access them.
64
 
from _static_tuple_c cimport StaticTuple,\
65
 
    import_static_tuple_c, StaticTuple_New, \
66
 
    StaticTuple_Intern, StaticTuple_SET_ITEM, StaticTuple_CheckExact
67
 
 
68
 
 
69
 
# This sets up the StaticTuple C_API functionality
70
 
import_static_tuple_c()
71
 
 
72
 
cdef object _LeafNode
 
62
 
73
63
_LeafNode = None
74
 
cdef object _InternalNode
75
64
_InternalNode = None
76
 
cdef object _unknown
77
65
_unknown = None
78
66
 
79
67
# We shouldn't just copy this from _dirstate_helpers_pyx
101
89
    cdef uInt crc_val
102
90
    cdef Py_ssize_t out_off
103
91
    cdef char *c_out
104
 
    # cdef PyObject *bit
 
92
    cdef PyObject *bit
105
93
 
106
 
    if not PyTuple_CheckExact(key) and not StaticTuple_CheckExact(key):
 
94
    if not PyTuple_CheckExact(key):
107
95
        raise TypeError('key %r is not a tuple' % (key,))
108
 
    num_bits = len(key)
 
96
    num_bits = PyTuple_GET_SIZE(key)
109
97
    # 4 bytes per crc32, and another 1 byte between bits
110
98
    num_out_bytes = (9 * num_bits) - 1
111
99
    out = PyString_FromStringAndSize(NULL, num_out_bytes)
117
105
        # We use the _ptr variant, because GET_ITEM returns a borrowed
118
106
        # reference, and Pyrex assumes that returned 'object' are a new
119
107
        # reference
120
 
        # XXX: This needs to be updated for PySequence_GetItem since both
121
 
        #      PyTuple and StaticTuple support that api
122
 
        bit = key[i]# PyTuple_GET_ITEM_ptr(key, i)
123
 
        if not PyString_CheckExact(bit):
 
108
        bit = PyTuple_GET_ITEM_ptr(key, i)
 
109
        if not PyString_CheckExact_ptr(bit):
124
110
            raise TypeError('Bit %d of %r is not a string' % (i, key))
125
 
        c_bit = <Bytef *>PyString_AS_STRING(bit)
126
 
        c_len = PyString_GET_SIZE(bit)
 
111
        c_bit = <Bytef *>PyString_AS_STRING_ptr(bit)
 
112
        c_len = PyString_GET_SIZE_ptr(bit)
127
113
        crc_val = crc32(0, c_bit, c_len)
128
114
        # Hex(val) order
129
115
        sprintf(c_out, '%08X', crc_val)
141
127
    cdef uInt crc_val
142
128
    cdef Py_ssize_t out_off
143
129
    cdef char *c_out
144
 
    # cdef PyObject *bit
 
130
    cdef PyObject *bit
145
131
 
146
 
    if not PyTuple_CheckExact(key) and not StaticTuple_CheckExact(key):
 
132
    if not PyTuple_CheckExact(key):
147
133
        raise TypeError('key %r is not a tuple' % (key,))
148
 
    num_bits = len(key)
 
134
    num_bits = PyTuple_GET_SIZE(key)
149
135
    # 4 bytes per crc32, and another 1 byte between bits
150
136
    num_out_bytes = (5 * num_bits) - 1
151
137
    out = PyString_FromStringAndSize(NULL, num_out_bytes)
154
140
        if i > 0:
155
141
            c_out[0] = c'\x00'
156
142
            c_out = c_out + 1
157
 
        bit = key[i] # PyTuple_GET_ITEM_ptr(key, i)
158
 
        if not PyString_CheckExact(bit):
 
143
        bit = PyTuple_GET_ITEM_ptr(key, i)
 
144
        if not PyString_CheckExact_ptr(bit):
159
145
            raise TypeError('Bit %d of %r is not a string: %r' % (i, key,
160
 
            bit))
161
 
        c_bit = <Bytef *>PyString_AS_STRING(bit)
162
 
        c_len = PyString_GET_SIZE(bit)
 
146
            <object>bit))
 
147
        c_bit = <Bytef *>PyString_AS_STRING_ptr(bit)
 
148
        c_len = PyString_GET_SIZE_ptr(bit)
163
149
        crc_val = crc32(0, c_bit, c_len)
164
150
        # MSB order
165
151
        c_out[0] = (crc_val >> 24) & 0xFF
209
195
    cdef char *prefix, *value_start, *prefix_tail
210
196
    cdef char *next_null, *last_null, *line_start
211
197
    cdef char *c_entry, *entry_start
212
 
    cdef StaticTuple entry_bits
213
198
 
214
199
    if _LeafNode is None:
215
200
        from bzrlib import chk_map
280
265
            if next_line == NULL:
281
266
                raise ValueError('missing trailing newline')
282
267
            cur = next_line + 1
283
 
        entry_bits = StaticTuple_New(width)
 
268
        entry_bits = PyTuple_New(width)
284
269
        for i from 0 <= i < num_prefix_bits:
285
270
            entry = prefix_bits[i]
286
271
            # SET_ITEM 'steals' a reference
287
272
            Py_INCREF(entry)
288
 
            StaticTuple_SET_ITEM(entry_bits, i, entry)
 
273
            PyTuple_SET_ITEM(entry_bits, i, entry)
289
274
        value = PyString_FromStringAndSize(value_start, next_line - value_start)
290
275
        # The next entry bit needs the 'tail' from the prefix, and first part
291
276
        # of the line
303
288
            memcpy(c_entry + prefix_tail_len, line_start, next_null - line_start)
304
289
        Py_INCREF(entry)
305
290
        i = num_prefix_bits
306
 
        StaticTuple_SET_ITEM(entry_bits, i, entry)
 
291
        PyTuple_SET_ITEM(entry_bits, i, entry)
307
292
        while next_null != last_null: # We have remaining bits
308
293
            i = i + 1
309
294
            if i > width:
316
301
            entry = PyString_FromStringAndSize(entry_start,
317
302
                                               next_null - entry_start)
318
303
            Py_INCREF(entry)
319
 
            StaticTuple_SET_ITEM(entry_bits, i, entry)
 
304
            PyTuple_SET_ITEM(entry_bits, i, entry)
320
305
        if len(entry_bits) != width:
321
306
            raise AssertionError(
322
307
                'Incorrect number of elements (%d vs %d)'
323
308
                % (len(entry_bits)+1, width + 1))
324
 
        entry_bits = StaticTuple_Intern(entry_bits)
325
309
        PyDict_SetItem(items, entry_bits, value)
326
310
    if len(items) != length:
327
311
        raise ValueError("item count (%d) mismatch for key %s,"
400
384
        memcpy(c_item_prefix + prefix_length, cur, next_null - cur)
401
385
        flat_key = PyString_FromStringAndSize(next_null + 1,
402
386
                                              next_line - next_null - 1)
403
 
        flat_key = StaticTuple(flat_key).intern()
404
 
        PyDict_SetItem(items, item_prefix, flat_key)
 
387
        PyDict_SetItem(items, item_prefix, (flat_key,))
405
388
        cur = next_line + 1
406
389
    assert len(items) > 0
407
390
    result._items = items
416
399
    result._search_prefix = PyString_FromStringAndSize(prefix, prefix_length)
417
400
    return result
418
401
 
419
 
 
420
 
_key_type = StaticTuple