~pythonregexp2.7/python/issue2636-01+09-01-01

« back to all changes in this revision

Viewing changes to Objects/abstract.c

• browse files at revision 39068
• compare with another revision
• download diff
• download tarball
• view history from revision 39068

Show diffs side-by-side

added

removed

Objects/abstract.c

362

362

        return (*(obj->ob_type->tp_as_buffer->bf_getbuffer))(obj, view, flags);

363

363

}

364

364

 

365

 

void

366

 

PyObject_ReleaseBuffer(PyObject *obj, Py_buffer *view)

367

 

{

368

 

        if (obj->ob_type->tp_as_buffer != NULL &&

369

 

            obj->ob_type->tp_as_buffer->bf_releasebuffer != NULL) {

370

 

                (*(obj->ob_type->tp_as_buffer->bf_releasebuffer))(obj, view);

371

 

        }

372

 

}

373

 

 

374

 

 

375

365

static int

376

366

_IsFortranContiguous(Py_buffer *view)

377

367

{

603

593

 

604

594

        if (PyObject_GetBuffer(dest, &view_dest, PyBUF_FULL) != 0) return -1;

605

595

        if (PyObject_GetBuffer(src, &view_src, PyBUF_FULL_RO) != 0) {

606

 

                PyObject_ReleaseBuffer(dest, &view_dest);

 

596

                PyBuffer_Release(&view_dest);

607

597

                return -1;

608

598

        }

609

599

 

610

600

        if (view_dest.len < view_src.len) {

611

601

                PyErr_SetString(PyExc_BufferError,

612

602

                                "destination is too small to receive data from source");

613

 

                PyObject_ReleaseBuffer(dest, &view_dest);

614

 

                PyObject_ReleaseBuffer(src, &view_src);

 

603

                PyBuffer_Release(&view_dest);

 

604

                PyBuffer_Release(&view_src);

615

605

                return -1;

616

606

        }

617

607

 

621

611

             PyBuffer_IsContiguous(&view_src, 'F'))) {

622

612

                /* simplest copy is all that is needed */

623

613

                memcpy(view_dest.buf, view_src.buf, view_src.len);

624

 

                PyObject_ReleaseBuffer(dest, &view_dest);

625

 

                PyObject_ReleaseBuffer(src, &view_src);

 

614

                PyBuffer_Release(&view_dest);

 

615

                PyBuffer_Release(&view_src);

626

616

                return 0;

627

617

        }

628

618

 

632

622

        indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*view_src.ndim);

633

623

        if (indices == NULL) {

634

624

                PyErr_NoMemory();

635

 

                PyObject_ReleaseBuffer(dest, &view_dest);

636

 

                PyObject_ReleaseBuffer(src, &view_src);

 

625

                PyBuffer_Release(&view_dest);

 

626

                PyBuffer_Release(&view_src);

637

627

                return -1;

638

628

        }

639

629

        for (k=0; k<view_src.ndim;k++) {

651

641

                memcpy(dptr, sptr, view_src.itemsize);

652

642

        }

653

643

        PyMem_Free(indices);

654

 

        PyObject_ReleaseBuffer(dest, &view_dest);

655

 

        PyObject_ReleaseBuffer(src, &view_src);

 

644

        PyBuffer_Release(&view_dest);

 

645

        PyBuffer_Release(&view_src);

656

646

        return 0;

657

647

}

658

648

 

681

671

}

682

672

 

683

673

int

684

 

PyBuffer_FillInfo(Py_buffer *view, void *buf, Py_ssize_t len,

 

674

PyBuffer_FillInfo(Py_buffer *view, PyObject *obj, void *buf, Py_ssize_t len,

685

675

              int readonly, int flags)

686

676

{

687

677

        if (view == NULL) return 0;

692

682

                return -1;

693

683

        }

694

684

 

 

685

        view->obj = obj;

 

686

        if (obj)

 

687

                Py_INCREF(obj);

695

688

        view->buf = buf;

696

689

        view->len = len;

697

690

        view->readonly = readonly;

711

704

        return 0;

712

705

}

713

706

 

 

707

void

 

708

PyBuffer_Release(Py_buffer *view)

 

709

{

 

710

        PyObject *obj = view->obj;

 

711

        if (obj && Py_TYPE(obj)->tp_as_buffer && Py_TYPE(obj)->tp_as_buffer->bf_releasebuffer)

 

712

                Py_TYPE(obj)->tp_as_buffer->bf_releasebuffer(obj, view);

 

713

        Py_XDECREF(obj);

 

714

        view->obj = NULL;

 

715

}

 

716

 

714

717

PyObject *

715

718

PyObject_Format(PyObject* obj, PyObject *format_spec)

716

719

{

1946

1949

                return m->sq_item(s, i);

1947

1950

        }

1948

1951

 

1949

 

        return type_error("'%.200s' object is unindexable", s);

 

1952

        return type_error("'%.200s' object does not support indexing", s);

1950

1953

}

1951

1954

 

1952

1955

PyObject *

2775

2778

static int

2776

2779

abstract_issubclass(PyObject *derived, PyObject *cls)

2777

2780

{

2778

 

        PyObject *bases;

 

2781

        PyObject *bases = NULL;

2779

2782

        Py_ssize_t i, n;

2780

2783

        int r = 0;

2781

2784

 

2782

 

 

2783

 

        if (derived == cls)

2784

 

                return 1;

2785

 

 

2786

 

        if (PyTuple_Check(cls)) {

2787

 

                /* Not a general sequence -- that opens up the road to

2788

 

                   recursion and stack overflow. */

2789

 

                n = PyTuple_GET_SIZE(cls);

 

2785

        while (1) {

 

2786

                if (derived == cls)

 

2787

                        return 1;

 

2788

                bases = abstract_get_bases(derived);

 

2789

                if (bases == NULL) {

 

2790

                        if (PyErr_Occurred())

 

2791

                                return -1;

 

2792

                        return 0;

 

2793

                }

 

2794

                n = PyTuple_GET_SIZE(bases);

 

2795

                if (n == 0) {

 

2796

                        Py_DECREF(bases);

 

2797

                        return 0;

 

2798

                }

 

2799

                /* Avoid recursivity in the single inheritance case */

 

2800

                if (n == 1) {

 

2801

                        derived = PyTuple_GET_ITEM(bases, 0);

 

2802

                        Py_DECREF(bases);

 

2803

                        continue;

 

2804

                }

2790

2805

                for (i = 0; i < n; i++) {

2791

 

                        if (derived == PyTuple_GET_ITEM(cls, i))

2792

 

                                return 1;

 

2806

                        r = abstract_issubclass(PyTuple_GET_ITEM(bases, i), cls);

 

2807

                        if (r != 0)

 

2808

                                break;

2793

2809

                }

2794

 

        }

2795

 

        bases = abstract_get_bases(derived);

2796

 

        if (bases == NULL) {

2797

 

                if (PyErr_Occurred())

2798

 

                        return -1;

2799

 

                return 0;

2800

 

        }

2801

 

        n = PyTuple_GET_SIZE(bases);

2802

 

        for (i = 0; i < n; i++) {

2803

 

                r = abstract_issubclass(PyTuple_GET_ITEM(bases, i), cls);

2804

 

                if (r != 0)

2805

 

                        break;

2806

 

        }

2807

 

 

2808

 

        Py_DECREF(bases);

2809

 

 

2810

 

        return r;

 

2810

                Py_DECREF(bases);

 

2811

                return r;

 

2812

        }

2811

2813

}

2812

2814

 

2813

2815

static int

2825

2827

}

2826

2828

 

2827

2829

static int

2828

 

recursive_isinstance(PyObject *inst, PyObject *cls, int recursion_depth)

 

2830

recursive_isinstance(PyObject *inst, PyObject *cls)

2829

2831

{

2830

2832

        PyObject *icls;

2831

2833

        static PyObject *__class__ = NULL;

2859

2861

                        }

2860

2862

                }

2861

2863

        }

2862

 

        else if (PyTuple_Check(cls)) {

2863

 

                Py_ssize_t i, n;

2864

 

 

2865

 

                if (!recursion_depth) {

2866

 

                    PyErr_SetString(PyExc_RuntimeError,

2867

 

                                    "nest level of tuple too deep");

2868

 

                    return -1;

2869

 

                }

2870

 

 

2871

 

                n = PyTuple_GET_SIZE(cls);

2872

 

                for (i = 0; i < n; i++) {

2873

 

                        retval = recursive_isinstance(

2874

 

                                    inst,

2875

 

                                    PyTuple_GET_ITEM(cls, i),

2876

 

                                    recursion_depth-1);

2877

 

                        if (retval != 0)

2878

 

                                break;

2879

 

                }

2880

 

        }

2881

2864

        else {

2882

2865

                if (!check_class(cls,

2883

2866

                        "isinstance() arg 2 must be a class, type,"

2907

2890

        if (Py_TYPE(inst) == (PyTypeObject *)cls)

2908

2891

                return 1;

2909

2892

 

 

2893

        if (PyTuple_Check(cls)) {

 

2894

                Py_ssize_t i;

 

2895

                Py_ssize_t n;

 

2896

                int r = 0;

 

2897

 

 

2898

                if (Py_EnterRecursiveCall(" in __instancecheck__"))

 

2899

                        return -1;

 

2900

                n = PyTuple_GET_SIZE(cls);

 

2901

                for (i = 0; i < n; ++i) {

 

2902

                        PyObject *item = PyTuple_GET_ITEM(cls, i);

 

2903

                        r = PyObject_IsInstance(inst, item);

 

2904

                        if (r != 0)

 

2905

                                /* either found it, or got an error */

 

2906

                                break;

 

2907

                }

 

2908

                Py_LeaveRecursiveCall();

 

2909

                return r;

 

2910

        }

2910

2911

        if (name == NULL) {

2911

2912

                name = PyString_InternFromString("__instancecheck__");

2912

2913

                if (name == NULL)

2931

2932

                }

2932

2933

                return ok;

2933

2934

        }

2934

 

        return recursive_isinstance(inst, cls, Py_GetRecursionLimit());

 

2935

        return recursive_isinstance(inst, cls);

2935

2936

}

2936

2937

 

2937

2938

static  int

2938

 

recursive_issubclass(PyObject *derived, PyObject *cls, int recursion_depth)

 

2939

recursive_issubclass(PyObject *derived, PyObject *cls)

2939

2940

{

2940

2941

        int retval;

2941

2942

 

 

2943

        if (PyType_Check(cls) && PyType_Check(derived)) {

 

2944

                /* Fast path (non-recursive) */

 

2945

                return PyType_IsSubtype(

 

2946

                        (PyTypeObject *)derived, (PyTypeObject *)cls);

 

2947

        }

2942

2948

        if (!PyClass_Check(derived) || !PyClass_Check(cls)) {

2943

2949

                if (!check_class(derived,

2944

2950

                                 "issubclass() arg 1 must be a class"))

2945

2951

                        return -1;

2946

2952

 

2947

 

                if (PyTuple_Check(cls)) {

2948

 

                        Py_ssize_t i;

2949

 

                        Py_ssize_t n = PyTuple_GET_SIZE(cls);

2950

 

 

2951

 

                        if (!recursion_depth) {

2952

 

                            PyErr_SetString(PyExc_RuntimeError,

2953

 

                                            "nest level of tuple too deep");

2954

 

                            return -1;

2955

 

                        }

2956

 

                        for (i = 0; i < n; ++i) {

2957

 

                                retval = recursive_issubclass(

2958

 

                                            derived,

2959

 

                                            PyTuple_GET_ITEM(cls, i),

2960

 

                                            recursion_depth-1);

2961

 

                                if (retval != 0) {

2962

 

                                        /* either found it, or got an error */

2963

 

                                        return retval;

2964

 

                                }

2965

 

                        }

2966

 

                        return 0;

2967

 

                }

2968

 

                else {

2969

 

                        if (!check_class(cls,

2970

 

                                        "issubclass() arg 2 must be a class"

2971

 

                                        " or tuple of classes"))

2972

 

                                return -1;

2973

 

                }

2974

 

 

 

2953

                if (!check_class(cls,

 

2954

                                "issubclass() arg 2 must be a class"

 

2955

                                " or tuple of classes"))

 

2956

                        return -1;

2975

2957

                retval = abstract_issubclass(derived, cls);

2976

2958

        }

2977

2959

        else {

2989

2971

        static PyObject *name = NULL;

2990

2972

        PyObject *t, *v, *tb;

2991

2973

        PyObject *checker;

 

2974

        

 

2975

        if (PyTuple_Check(cls)) {

 

2976

                Py_ssize_t i;

 

2977

                Py_ssize_t n;

 

2978

                int r = 0;

 

2979

 

 

2980

                if (Py_EnterRecursiveCall(" in __subclasscheck__"))

 

2981

                        return -1;

 

2982

                n = PyTuple_GET_SIZE(cls);

 

2983

                for (i = 0; i < n; ++i) {

 

2984

                        PyObject *item = PyTuple_GET_ITEM(cls, i);

 

2985

                        r = PyObject_IsSubclass(derived, item);

 

2986

                        if (r != 0)

 

2987

                                /* either found it, or got an error */

 

2988

                                break;

 

2989

                }

 

2990

                Py_LeaveRecursiveCall();

 

2991

                return r;

 

2992

        }

 

2993

        if (name == NULL) {

 

2994

                name = PyString_InternFromString("__subclasscheck__");

 

2995

                if (name == NULL)

 

2996

                        return -1;

 

2997

        }

2992

2998

        PyErr_Fetch(&t, &v, &tb);

2993

 

        

2994

 

        if (name == NULL) {

2995

 

                name = PyString_InternFromString("__subclasscheck__");

2996

 

                if (name == NULL)

2997

 

                        return -1;

2998

 

        }

2999

2999

        checker = PyObject_GetAttr(cls, name);

3000

3000

        PyErr_Restore(t, v, tb);

3001

3001

        if (checker != NULL) {

3002

3002

                PyObject *res;

3003

3003

                int ok = -1;

3004

 

                if (Py_EnterRecursiveCall(" in __subclasscheck__"))

 

3004

                if (Py_EnterRecursiveCall(" in __subclasscheck__")) {

 

3005

                        Py_DECREF(checker);

3005

3006

                        return ok;

 

3007

                }

3006

3008

                res = PyObject_CallFunctionObjArgs(checker, derived, NULL);

3007

3009

                Py_LeaveRecursiveCall();

3008

3010

                Py_DECREF(checker);

3012

3014

                }

3013

3015

                return ok;

3014

3016

        }

3015

 

        return recursive_issubclass(derived, cls, Py_GetRecursionLimit());

 

3017

        return recursive_issubclass(derived, cls);

 

3018

}

 

3019

 

 

3020

int

 

3021

_PyObject_RealIsInstance(PyObject *inst, PyObject *cls)

 

3022

{

 

3023

        return recursive_isinstance(inst, cls);

 

3024

}

 

3025

 

 

3026

int

 

3027

_PyObject_RealIsSubclass(PyObject *derived, PyObject *cls)

 

3028

{

 

3029

        return recursive_issubclass(derived, cls);

3016

3030

}

3017

3031

 

3018

3032

 

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1