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

  • Committer: Martin
  • Date: 2017-06-27 00:10:52 UTC
  • mto: This revision was merged to the branch mainline in revision 6721.
  • Revision ID: gzlist@googlemail.com-20170627001052-o70zln144nmwhamo
Switch c_api helpers for _static_tuple_c to capsules

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/_static_tuple_c.c
26
26
#include "_static_tuple_c.h"
27
27
#include "_export_c_api.h"
28
28
 
29
 
/* Pyrex 0.9.6.4 exports _simple_set_pyx_api as
30
 
 * import__simple_set_pyx(), while Pyrex 0.9.8.5 and Cython 0.11.3 export them
31
 
 * as import_bzrlib___simple_set_pyx(). As such, we just #define one to be
32
 
 * equivalent to the other in our internal code.
33
 
 */
34
 
#define import__simple_set_pyx import_bzrlib___simple_set_pyx
35
29
#include "_simple_set_pyx_api.h"
36
30
 
37
31
#if defined(__GNUC__)
242
236
                " should not have a NULL entry.");
243
237
            return 0;
244
238
        }
245
 
        if (PyString_CheckExact(obj)
 
239
        if (PyBytes_CheckExact(obj)
246
240
            || StaticTuple_CheckExact(obj)
247
241
            || obj == Py_None
248
242
            || PyBool_Check(obj)
 
243
#if PY_MAJOR_VERSION >= 3
 
244
#else
249
245
            || PyInt_CheckExact(obj)
 
246
#endif
250
247
            || PyLong_CheckExact(obj)
251
248
            || PyFloat_CheckExact(obj)
252
249
            || PyUnicode_CheckExact(obj)
314
311
    if (tuple_repr == NULL) {
315
312
        return NULL;
316
313
    }
 
314
#if PY_MAJOR_VERSION >= 3
 
315
    result = PyUnicode_FromFormat("StaticTuple%U", tuple_repr);
 
316
#else
317
317
    result = PyString_FromFormat("StaticTuple%s",
318
318
                                 PyString_AsString(tuple_repr));
 
319
#endif
319
320
    return result;
320
321
}
321
322
 
362
363
{
363
364
    PyObject *vt;
364
365
    PyObject *result = NULL;
365
 
    
 
366
 
366
367
    vt = StaticTuple_as_tuple((StaticTuple *)v);
367
368
    if (vt == NULL) {
368
369
        goto done;
478
479
    vlen = v_st->size;
479
480
    wlen = w_st->size;
480
481
    min_len = (vlen < wlen) ? vlen : wlen;
481
 
    string_richcompare = PyString_Type.tp_richcompare;
 
482
    string_richcompare = PyBytes_Type.tp_richcompare;
482
483
    for (i = 0; i < min_len; i++) {
483
484
        PyObject *result = NULL;
484
485
        v_obj = StaticTuple_GET_ITEM(v_st, i);
487
488
            /* Shortcut case, these must be identical */
488
489
            continue;
489
490
        }
490
 
        if (PyString_CheckExact(v_obj) && PyString_CheckExact(w_obj)) {
 
491
        if (PyBytes_CheckExact(v_obj) && PyBytes_CheckExact(w_obj)) {
491
492
            result = string_richcompare(v_obj, w_obj, Py_EQ);
492
493
        } else if (StaticTuple_CheckExact(v_obj) &&
493
494
                   StaticTuple_CheckExact(w_obj))
547
548
        return Py_True;
548
549
    }
549
550
    /* It is some other comparison, go ahead and do the real check. */
550
 
    if (PyString_CheckExact(v_obj) && PyString_CheckExact(w_obj))
 
551
    if (PyBytes_CheckExact(v_obj) && PyBytes_CheckExact(w_obj))
551
552
    {
552
553
        return string_richcompare(v_obj, w_obj, op);
553
554
    } else if (StaticTuple_CheckExact(v_obj) &&
679
680
    return obj;
680
681
}
681
682
 
 
683
#if PY_MAJOR_VERSION >= 3
 
684
#else
682
685
static PyObject *
683
686
StaticTuple_slice(StaticTuple *self, Py_ssize_t ilow, Py_ssize_t ihigh)
684
687
{
692
695
    Py_DECREF(as_tuple);
693
696
    return result;
694
697
}
 
698
#endif
 
699
 
 
700
static PyObject *
 
701
StaticTuple_subscript(StaticTuple *self, PyObject *key)
 
702
{
 
703
    PyObject *as_tuple, *result;
 
704
 
 
705
    as_tuple = StaticTuple_as_tuple(self);
 
706
    if (as_tuple == NULL) {
 
707
        return NULL;
 
708
    }
 
709
    result = PyTuple_Type.tp_as_mapping->mp_subscript(as_tuple, key);
 
710
    Py_DECREF(as_tuple);
 
711
    return result;
 
712
}
695
713
 
696
714
static int
697
715
StaticTuple_traverse(StaticTuple *self, visitproc visit, void *arg)
703
721
    return 0;
704
722
}
705
723
 
 
724
 
 
725
static PyObject *
 
726
StaticTuple_sizeof(StaticTuple *self)
 
727
{
 
728
        Py_ssize_t res;
 
729
 
 
730
        res = _PyObject_SIZE(&StaticTuple_Type) + (int)self->size * sizeof(void*);
 
731
        return PyInt_FromSsize_t(res);
 
732
}
 
733
 
 
734
 
 
735
 
706
736
static char StaticTuple_doc[] =
707
737
    "C implementation of a StaticTuple structure."
708
738
    "\n This is used as StaticTuple(item1, item2, item3)"
722
752
     "Create a StaticTuple from a given sequence. This functions"
723
753
     " the same as the tuple() constructor."},
724
754
    {"__reduce__", (PyCFunction)StaticTuple_reduce, METH_NOARGS, StaticTuple_reduce_doc},
 
755
    {"__sizeof__",  (PyCFunction)StaticTuple_sizeof, METH_NOARGS}, 
725
756
    {NULL, NULL} /* sentinel */
726
757
};
727
758
 
746
777
    0,                              /* nb_or */
747
778
    0,                              /* nb_coerce */
748
779
};
749
 
    
 
780
 
750
781
 
751
782
static PySequenceMethods StaticTuple_as_sequence = {
752
783
    (lenfunc)StaticTuple_length,            /* sq_length */
753
784
    0,                              /* sq_concat */
754
785
    0,                              /* sq_repeat */
755
786
    (ssizeargfunc)StaticTuple_item,         /* sq_item */
 
787
#if PY_MAJOR_VERSION >= 3
 
788
#else
756
789
    (ssizessizeargfunc)StaticTuple_slice,   /* sq_slice */
 
790
#endif
757
791
    0,                              /* sq_ass_item */
758
792
    0,                              /* sq_ass_slice */
759
793
    0,                              /* sq_contains */
760
 
};
761
 
 
762
 
/* TODO: Implement StaticTuple_as_mapping.
763
 
 *       The only thing we really want to support from there is mp_subscript,
764
 
 *       so that we could support extended slicing (foo[::2]). Not worth it
765
 
 *       yet, though.
766
 
 */
 
794
#if PY_MAJOR_VERSION >= 3
 
795
    0,                              /* sq_inplace_concat */
 
796
    0,                              /* sq_inplace_repeat */
 
797
#endif
 
798
};
 
799
 
 
800
 
 
801
static PyMappingMethods StaticTuple_as_mapping = {
 
802
    (lenfunc)StaticTuple_length,            /* mp_length */
 
803
    (binaryfunc)StaticTuple_subscript,      /* mp_subscript */
 
804
    0,                                      /* mp_ass_subscript */
 
805
};
767
806
 
768
807
 
769
808
PyTypeObject StaticTuple_Type = {
770
 
    PyObject_HEAD_INIT(NULL)
771
 
    0,                                           /* ob_size */
772
 
    "bzrlib._static_tuple_c.StaticTuple",        /* tp_name */
 
809
    PyVarObject_HEAD_INIT(NULL, 0)
 
810
    "breezy._static_tuple_c.StaticTuple",        /* tp_name */
773
811
    sizeof(StaticTuple),                         /* tp_basicsize */
774
812
    sizeof(PyObject *),                          /* tp_itemsize */
775
813
    (destructor)StaticTuple_dealloc,             /* tp_dealloc */
780
818
    (reprfunc)StaticTuple_repr,                  /* tp_repr */
781
819
    &StaticTuple_as_number,                      /* tp_as_number */
782
820
    &StaticTuple_as_sequence,                    /* tp_as_sequence */
783
 
    0,                                           /* tp_as_mapping */
 
821
    &StaticTuple_as_mapping,                     /* tp_as_mapping */
784
822
    (hashfunc)StaticTuple_hash,                  /* tp_hash */
785
823
    0,                                           /* tp_call */
786
824
    0,                                           /* tp_str */
874
912
}
875
913
 
876
914
 
877
 
static int
878
 
_workaround_pyrex_096(void)
879
 
{
880
 
    /* Work around an incompatibility in how pyrex 0.9.6 exports a module,
881
 
     * versus how pyrex 0.9.8 and cython 0.11 export it.
882
 
     * Namely 0.9.6 exports import__simple_set_pyx and tries to
883
 
     * "import _simple_set_pyx" but it is available only as
884
 
     * "import bzrlib._simple_set_pyx"
885
 
     * It is a shame to hack up sys.modules, but that is what we've got to do.
886
 
     */
887
 
    PyObject *sys_module = NULL, *modules = NULL, *set_module = NULL;
888
 
    int retval = -1;
889
 
 
890
 
    /* Clear out the current ImportError exception, and try again. */
891
 
    PyErr_Clear();
892
 
    /* Note that this only seems to work if somewhere else imports
893
 
     * bzrlib._simple_set_pyx before importing bzrlib._static_tuple_c
894
 
     */
895
 
    set_module = PyImport_ImportModule("bzrlib._simple_set_pyx");
896
 
    if (set_module == NULL) {
897
 
        goto end;
898
 
    }
899
 
    /* Add the _simple_set_pyx into sys.modules at the appropriate location. */
900
 
    sys_module = PyImport_ImportModule("sys");
901
 
    if (sys_module == NULL) {
902
 
        goto end;
903
 
    }
904
 
    modules = PyObject_GetAttrString(sys_module, "modules");
905
 
    if (modules == NULL || !PyDict_Check(modules)) {
906
 
        goto end;
907
 
    }
908
 
    PyDict_SetItemString(modules, "_simple_set_pyx", set_module);
909
 
    /* Now that we have hacked it in, try the import again. */
910
 
    retval = import_bzrlib___simple_set_pyx();
911
 
end:
912
 
    Py_XDECREF(set_module);
913
 
    Py_XDECREF(sys_module);
914
 
    Py_XDECREF(modules);
915
 
    return retval;
916
 
}
917
 
 
918
 
 
919
 
PyMODINIT_FUNC
920
 
init_static_tuple_c(void)
 
915
PYMOD_INIT_FUNC(_static_tuple_c)
921
916
{
922
917
    PyObject* m;
923
918
 
924
919
    StaticTuple_Type.tp_getattro = PyObject_GenericGetAttr;
925
 
    if (PyType_Ready(&StaticTuple_Type) < 0)
926
 
        return;
 
920
    if (PyType_Ready(&StaticTuple_Type) < 0) {
 
921
        return PYMOD_ERROR;
 
922
    }
927
923
 
928
 
    m = Py_InitModule3("_static_tuple_c", static_tuple_c_methods,
929
 
                       "C implementation of a StaticTuple structure");
930
 
    if (m == NULL)
931
 
      return;
 
924
    PYMOD_CREATE(m, "_static_tuple_c",
 
925
                 "C implementation of a StaticTuple structure",
 
926
                 static_tuple_c_methods);
 
927
    if (m == NULL) {
 
928
      return PYMOD_ERROR;
 
929
    }
932
930
 
933
931
    Py_INCREF(&StaticTuple_Type);
934
932
    PyModule_AddObject(m, "StaticTuple", (PyObject *)&StaticTuple_Type);
935
 
    if (import_bzrlib___simple_set_pyx() == -1
936
 
        && _workaround_pyrex_096() == -1)
937
 
    {
938
 
        return;
 
933
    if (import_breezy___simple_set_pyx() == -1) {
 
934
        return PYMOD_ERROR;
939
935
    }
940
936
    setup_interned_tuples(m);
941
937
    setup_empty_tuple(m);
942
938
    setup_c_api(m);
 
939
 
 
940
    return PYMOD_SUCCESS(m);
943
941
}
944
942
 
945
943
// vim: tabstop=4 sw=4 expandtab