0UT1S's

opt/alt/python34/include/python3.4m/

By Order of Mr.0UT1S

N/A

19.03 KB

2.79 KB

42.07 KB

1016 bytes

1.16 KB

477 bytes

792 bytes

264 bytes

886 bytes

bytearrayobject.h

2.06 KB

bytes_methods.h

1.98 KB

4.81 KB

701 bytes

7.03 KB

1.63 KB

4.13 KB

6.40 KB

2.07 KB

complexobject.h

1.91 KB

8.34 KB

2.84 KB

5.06 KB

458 bytes

dynamic_annotations.h

21.94 KB

253 bytes

1.46 KB

597 bytes

1.82 KB

1.47 KB

4.53 KB

3.47 KB

3.68 KB

1.10 KB

1.83 KB

2.00 KB

3.81 KB

460 bytes

567 bytes

2.77 KB

3.90 KB

7.98 KB

803 bytes

2.79 KB

253 bytes

3.23 KB

4.78 KB

1.58 KB

namespaceobject.h

297 bytes

1008 bytes

37.62 KB

13.52 KB

5.09 KB

848 bytes

2.82 KB

1.10 KB

253 bytes

1.12 KB

4.08 KB

2.68 KB

5.80 KB

1.69 KB

42.32 KB

162 bytes

1.29 KB

1019 bytes

15.65 KB

2.39 KB

8.29 KB

388 bytes

4.17 KB

2.92 KB

2.75 KB

7.05 KB

6.62 KB

30.15 KB

8.91 KB

436 bytes

1.25 KB

9.95 KB

2.96 KB

2.85 KB

629 bytes

3.22 KB

1.55 KB

2.02 KB

1.32 KB

4.98 KB

1.32 KB

1.84 KB

2.16 KB

2.39 KB

1.95 KB

1.03 KB

unicodeobject.h

76.30 KB

1.39 KB

weakrefobject.h

2.80 KB

/* Set object interface */

#ifndef Py_SETOBJECT_H
#define Py_SETOBJECT_H
#ifdef __cplusplus
extern "C" {
#endif

/*
There are three kinds of slots in the table:

1. Unused:  key == NULL
2. Active:  key != NULL and key != dummy
3. Dummy:   key == dummy

Note: .pop() abuses the hash field of an Unused or Dummy slot to
hold a search finger.  The hash field of Unused or Dummy slots has
no meaning otherwise.
*/
#ifndef Py_LIMITED_API
#define PySet_MINSIZE 8

typedef struct {
    /* Cached hash code of the key. */
    PyObject *key;
    Py_hash_t hash;
} setentry;

/*
This data structure is shared by set and frozenset objects.
*/

typedef struct _setobject PySetObject;
struct _setobject {
    PyObject_HEAD

Py_ssize_t fill;  /* # Active + # Dummy */
    Py_ssize_t used;  /* # Active */

/* The table contains mask + 1 slots, and that's a power of 2.
     * We store the mask instead of the size because the mask is more
     * frequently needed.
     */
    Py_ssize_t mask;

/* table points to smalltable for small tables, else to
     * additional malloc'ed memory.  table is never NULL!  This rule
     * saves repeated runtime null-tests.
     */
    setentry *table;
    setentry *(*lookup)(PySetObject *so, PyObject *key, Py_hash_t hash);
    Py_hash_t hash;             /* only used by frozenset objects */
    setentry smalltable[PySet_MINSIZE];

PyObject *weakreflist;      /* List of weak references */
};
#endif /* Py_LIMITED_API */

PyAPI_DATA(PyTypeObject) PySet_Type;
PyAPI_DATA(PyTypeObject) PyFrozenSet_Type;
PyAPI_DATA(PyTypeObject) PySetIter_Type;
#ifndef Py_LIMITED_API
PyAPI_DATA(PyObject *) _PySet_Dummy;
#endif

/* Invariants for frozensets:
 *     data is immutable.
 *     hash is the hash of the frozenset or -1 if not computed yet.
 * Invariants for sets:
 *     hash is -1
 */

#define PyFrozenSet_CheckExact(ob) (Py_TYPE(ob) == &PyFrozenSet_Type)
#define PyAnySet_CheckExact(ob) \
    (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type)
#define PyAnySet_Check(ob) \
    (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type || \
      PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \
      PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
#define PySet_Check(ob) \
    (Py_TYPE(ob) == &PySet_Type || \
    PyType_IsSubtype(Py_TYPE(ob), &PySet_Type))
#define   PyFrozenSet_Check(ob) \
    (Py_TYPE(ob) == &PyFrozenSet_Type || \
      PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))

PyAPI_FUNC(PyObject *) PySet_New(PyObject *);
PyAPI_FUNC(PyObject *) PyFrozenSet_New(PyObject *);
PyAPI_FUNC(Py_ssize_t) PySet_Size(PyObject *anyset);
#ifndef Py_LIMITED_API
#define PySet_GET_SIZE(so) (((PySetObject *)(so))->used)
#endif
PyAPI_FUNC(int) PySet_Clear(PyObject *set);
PyAPI_FUNC(int) PySet_Contains(PyObject *anyset, PyObject *key);
PyAPI_FUNC(int) PySet_Discard(PyObject *set, PyObject *key);
PyAPI_FUNC(int) PySet_Add(PyObject *set, PyObject *key);
#ifndef Py_LIMITED_API
PyAPI_FUNC(int) _PySet_NextEntry(PyObject *set, Py_ssize_t *pos, PyObject **key, Py_hash_t *hash);
#endif
PyAPI_FUNC(PyObject *) PySet_Pop(PyObject *set);
#ifndef Py_LIMITED_API
PyAPI_FUNC(int) _PySet_Update(PyObject *set, PyObject *iterable);

PyAPI_FUNC(int) PySet_ClearFreeList(void);
#endif

#ifdef __cplusplus
}
#endif
#endif /* !Py_SETOBJECT_H */