0UT1S's

usr/include/python3.6m/

By Order of Mr.0UT1S

N/A

21.75 KB

3.15 KB

1.33 KB

46.34 KB

1016 bytes

1.18 KB

477 bytes

792 bytes

264 bytes

886 bytes

bytearrayobject.h

2.06 KB

bytes_methods.h

3.12 KB

8.17 KB

701 bytes

8.32 KB

1.63 KB

5.81 KB

6.63 KB

2.11 KB

complexobject.h

1.76 KB

9.19 KB

2.89 KB

7.01 KB

458 bytes

dynamic_annotations.h

21.94 KB

253 bytes

1.46 KB

597 bytes

1.61 KB

3.44 KB

4.68 KB

3.45 KB

3.98 KB

3.50 KB

1.92 KB

2.03 KB

4.13 KB

513 bytes

567 bytes

2.83 KB

3.67 KB

9.60 KB

803 bytes

2.70 KB

253 bytes

3.76 KB

7.15 KB

2.23 KB

namespaceobject.h

349 bytes

1007 bytes

41.21 KB

13.91 KB

1.26 KB

4.95 KB

691 bytes

291 bytes

2.82 KB

1.10 KB

253 bytes

1.15 KB

4.21 KB

2.68 KB

7.94 KB

1.69 KB

43.58 KB

162 bytes

1.29 KB

1.23 KB

1.92 KB

16.82 KB

2.39 KB

8.27 KB

410 bytes

4.04 KB

3.98 KB

2.92 KB

3.42 KB

8.12 KB

8.36 KB

26.93 KB

10.88 KB

436 bytes

495 bytes

1.45 KB

6.62 KB

2.92 KB

7.43 KB

629 bytes

3.25 KB

2.43 KB

1.97 KB

1.32 KB

4.88 KB

1.32 KB

1.90 KB

3.56 KB

2.39 KB

2.20 KB

1.03 KB

unicodeobject.h

79.86 KB

1.65 KB

weakrefobject.h

2.80 KB

/* Method object interface */

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

/* This is about the type 'builtin_function_or_method',
   not Python methods in user-defined classes.  See classobject.h
   for the latter. */

PyAPI_DATA(PyTypeObject) PyCFunction_Type;

#define PyCFunction_Check(op) (Py_TYPE(op) == &PyCFunction_Type)

typedef PyObject *(*PyCFunction)(PyObject *, PyObject *);
typedef PyObject *(*_PyCFunctionFast) (PyObject *self, PyObject **args,
                                       Py_ssize_t nargs, PyObject *kwnames);
typedef PyObject *(*PyCFunctionWithKeywords)(PyObject *, PyObject *,
                                             PyObject *);
typedef PyObject *(*PyNoArgsFunction)(PyObject *);

PyAPI_FUNC(PyCFunction) PyCFunction_GetFunction(PyObject *);
PyAPI_FUNC(PyObject *) PyCFunction_GetSelf(PyObject *);
PyAPI_FUNC(int) PyCFunction_GetFlags(PyObject *);

/* Macros for direct access to these values. Type checks are *not*
   done, so use with care. */
#ifndef Py_LIMITED_API
#define PyCFunction_GET_FUNCTION(func) \
        (((PyCFunctionObject *)func) -> m_ml -> ml_meth)
#define PyCFunction_GET_SELF(func) \
        (((PyCFunctionObject *)func) -> m_ml -> ml_flags & METH_STATIC ? \
         NULL : ((PyCFunctionObject *)func) -> m_self)
#define PyCFunction_GET_FLAGS(func) \
        (((PyCFunctionObject *)func) -> m_ml -> ml_flags)
#endif
PyAPI_FUNC(PyObject *) PyCFunction_Call(PyObject *, PyObject *, PyObject *);

#ifndef Py_LIMITED_API
PyAPI_FUNC(PyObject *) _PyCFunction_FastCallDict(PyObject *func,
    PyObject **args,
    Py_ssize_t nargs,
    PyObject *kwargs);

PyAPI_FUNC(PyObject *) _PyCFunction_FastCallKeywords(PyObject *func,
    PyObject **stack,
    Py_ssize_t nargs,
    PyObject *kwnames);
#endif

struct PyMethodDef {
    const char  *ml_name;   /* The name of the built-in function/method */
    PyCFunction ml_meth;    /* The C function that implements it */
    int         ml_flags;   /* Combination of METH_xxx flags, which mostly
                               describe the args expected by the C func */
    const char  *ml_doc;    /* The __doc__ attribute, or NULL */
};
typedef struct PyMethodDef PyMethodDef;

#define PyCFunction_New(ML, SELF) PyCFunction_NewEx((ML), (SELF), NULL)
PyAPI_FUNC(PyObject *) PyCFunction_NewEx(PyMethodDef *, PyObject *,
                                         PyObject *);

/* Flag passed to newmethodobject */
/* #define METH_OLDARGS  0x0000   -- unsupported now */
#define METH_VARARGS  0x0001
#define METH_KEYWORDS 0x0002
/* METH_NOARGS and METH_O must not be combined with the flags above. */
#define METH_NOARGS   0x0004
#define METH_O        0x0008

/* METH_CLASS and METH_STATIC are a little different; these control
   the construction of methods for a class.  These cannot be used for
   functions in modules. */
#define METH_CLASS    0x0010
#define METH_STATIC   0x0020

/* METH_COEXIST allows a method to be entered even though a slot has
   already filled the entry.  When defined, the flag allows a separate
   method, "__contains__" for example, to coexist with a defined
   slot like sq_contains. */

#define METH_COEXIST   0x0040

#ifndef Py_LIMITED_API
#define METH_FASTCALL  0x0080

typedef struct {
    PyObject_HEAD
    PyMethodDef *m_ml; /* Description of the C function to call */
    PyObject    *m_self; /* Passed as 'self' arg to the C func, can be NULL */
    PyObject    *m_module; /* The __module__ attribute, can be anything */
    PyObject    *m_weakreflist; /* List of weak references */
} PyCFunctionObject;
#endif

PyAPI_FUNC(int) PyCFunction_ClearFreeList(void);

#ifndef Py_LIMITED_API
PyAPI_FUNC(void) _PyCFunction_DebugMallocStats(FILE *out);
PyAPI_FUNC(void) _PyMethod_DebugMallocStats(FILE *out);
#endif

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