/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/_static_tuple_c.c

  • Committer: Aaron Bentley
  • Date: 2009-10-23 03:35:32 UTC
  • mto: (4603.1.22 shelve-editor)
  • mto: This revision was merged to the branch mainline in revision 4795.
  • Revision ID: aaron@aaronbentley.com-20091023033532-exo2sfgc3rn1e434
Remove test code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/_static_tuple_c.c
1
 
/* Copyright (C) 2009, 2010 Canonical Ltd
 
1
/* Copyright (C) 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
140
140
StaticTuple_New(Py_ssize_t size)
141
141
{
142
142
    StaticTuple *stuple;
 
143
    if (size < 0) {
 
144
        PyErr_BadInternalCall();
 
145
        return NULL;
 
146
    }
143
147
 
144
148
    if (size < 0 || size > 255) {
145
149
        /* Too big or too small */
179
183
static StaticTuple *
180
184
StaticTuple_FromSequence(PyObject *sequence)
181
185
{
182
 
    StaticTuple *new = NULL;
183
 
    PyObject *as_tuple = NULL;
 
186
    StaticTuple *new;
184
187
    PyObject *item;
185
188
    Py_ssize_t i, size;
186
189
 
189
192
        return (StaticTuple *)sequence;
190
193
    }
191
194
    if (!PySequence_Check(sequence)) {
192
 
        as_tuple = PySequence_Tuple(sequence);
193
 
        if (as_tuple == NULL)
194
 
            goto done;
195
 
        sequence = as_tuple;
 
195
        PyErr_Format(PyExc_TypeError, "Type %s is not a sequence type",
 
196
                     Py_TYPE(sequence)->tp_name);
 
197
        return NULL;
196
198
    }
197
199
    size = PySequence_Size(sequence);
198
 
    if (size == -1) {
199
 
        goto done;
200
 
    }
 
200
    if (size == -1)
 
201
        return NULL;
201
202
    new = StaticTuple_New(size);
202
203
    if (new == NULL) {
203
 
        goto done;
 
204
        return NULL;
204
205
    }
205
206
    for (i = 0; i < size; ++i) {
206
207
        // This returns a new reference, which we then 'steal' with 
208
209
        item = PySequence_GetItem(sequence, i);
209
210
        if (item == NULL) {
210
211
            Py_DECREF(new);
211
 
            new = NULL;
212
 
            goto done;
 
212
            return NULL;
213
213
        }
214
214
        StaticTuple_SET_ITEM(new, i, item);
215
215
    }
216
 
done:
217
 
    Py_XDECREF(as_tuple);
218
216
    return (StaticTuple *)new;
219
217
}
220
218
 
276
274
        return NULL;
277
275
    }
278
276
    len = PyTuple_GET_SIZE(args);
279
 
    if (len < 0 || len > 255) {
280
 
        /* Check the length here so we can raise a TypeError instead of
281
 
         * StaticTuple_New's ValueError.
282
 
         */
283
 
        PyErr_SetString(PyExc_TypeError, "StaticTuple(...)"
284
 
            " takes from 0 to 255 items");
285
 
        return NULL;
286
 
    }
287
277
    self = (StaticTuple *)StaticTuple_New(len);
288
278
    if (self == NULL) {
289
279
        return NULL;
314
304
    if (tuple_repr == NULL) {
315
305
        return NULL;
316
306
    }
317
 
    result = PyString_FromFormat("StaticTuple%s",
318
 
                                 PyString_AsString(tuple_repr));
 
307
    result = PyString_FromFormat("%s%s", Py_TYPE(self)->tp_name,
 
308
                                         PyString_AsString(tuple_repr));
319
309
    return result;
320
310
}
321
311
 
584
574
 
585
575
 
586
576
static PyObject *
587
 
StaticTuple_reduce(StaticTuple *self)
588
 
{
589
 
    PyObject *result = NULL, *as_tuple = NULL;
590
 
 
591
 
    result = PyTuple_New(2);
592
 
    if (!result) {
593
 
        return NULL;
594
 
    }
595
 
    as_tuple = StaticTuple_as_tuple(self);
596
 
    if (as_tuple == NULL) {
597
 
        Py_DECREF(result);
598
 
        return NULL;
599
 
    }
600
 
    Py_INCREF(&StaticTuple_Type);
601
 
    PyTuple_SET_ITEM(result, 0, (PyObject *)&StaticTuple_Type);
602
 
    PyTuple_SET_ITEM(result, 1, as_tuple);
603
 
    return result;
604
 
}
605
 
 
606
 
static char StaticTuple_reduce_doc[] = "__reduce__() => tuple\n";
607
 
 
608
 
 
609
 
static PyObject *
610
577
StaticTuple_add(PyObject *v, PyObject *w)
611
578
{
612
579
    Py_ssize_t i, len_v, len_w;
721
688
     METH_STATIC | METH_VARARGS,
722
689
     "Create a StaticTuple from a given sequence. This functions"
723
690
     " the same as the tuple() constructor."},
724
 
    {"__reduce__", (PyCFunction)StaticTuple_reduce, METH_NOARGS, StaticTuple_reduce_doc},
725
691
    {NULL, NULL} /* sentinel */
726
692
};
727
693
 
769
735
PyTypeObject StaticTuple_Type = {
770
736
    PyObject_HEAD_INIT(NULL)
771
737
    0,                                           /* ob_size */
772
 
    "bzrlib._static_tuple_c.StaticTuple",        /* tp_name */
 
738
    "StaticTuple",                               /* tp_name */
773
739
    sizeof(StaticTuple),                         /* tp_basicsize */
774
740
    sizeof(PyObject *),                          /* tp_itemsize */
775
741
    (destructor)StaticTuple_dealloc,             /* tp_dealloc */