0UT1S's

usr/include/python2.7/

By Order of Mr.0UT1S

N/A

20.62 KB

4.27 KB

44.17 KB

1.07 KB

230 bytes

792 bytes

912 bytes

922 bytes

bytearrayobject.h

1.90 KB

bytes_methods.h

2.74 KB

1.13 KB

1.96 KB

651 bytes

4.94 KB

2.93 KB

2.86 KB

4.30 KB

6.03 KB

1.04 KB

complexobject.h

1.81 KB

8.12 KB

2.42 KB

6.73 KB

338 bytes

253 bytes

1.37 KB

557 bytes

3.58 KB

5.49 KB

3.18 KB

2.92 KB

891 bytes

1.87 KB

2.00 KB

2.17 KB

2.91 KB

274 bytes

522 bytes

2.51 KB

3.82 KB

5.67 KB

713 bytes

2.76 KB

253 bytes

3.28 KB

4.91 KB

609 bytes

938 bytes

39.12 KB

14.00 KB

4.70 KB

1.03 KB

1.74 KB

1.42 KB

253 bytes

1.15 KB

4.17 KB

2.63 KB

1.64 KB

37.02 KB

162 bytes

1.24 KB

1.29 KB

11.47 KB

2.07 KB

8.27 KB

348 bytes

2.92 KB

8.43 KB

7.16 KB

4.60 KB

31.79 KB

6.25 KB

463 bytes

1.54 KB

7.06 KB

1.13 KB

646 bytes

3.06 KB

1.64 KB

7.79 KB

2.83 KB

862 bytes

3.64 KB

865 bytes

541 bytes

1.76 KB

697 bytes

2.18 KB

924 bytes

unicodeobject.h

51.00 KB

635 bytes

weakrefobject.h

2.74 KB

/* Function object interface */

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

/* Function objects and code objects should not be confused with each other:
 *
 * Function objects are created by the execution of the 'def' statement.
 * They reference a code object in their func_code attribute, which is a
 * purely syntactic object, i.e. nothing more than a compiled version of some
 * source code lines.  There is one code object per source code "fragment",
 * but each code object can be referenced by zero or many function objects
 * depending only on how many times the 'def' statement in the source was
 * executed so far.
 */

typedef struct {
    PyObject_HEAD
    PyObject *func_code;	/* A code object */
    PyObject *func_globals;	/* A dictionary (other mappings won't do) */
    PyObject *func_defaults;	/* NULL or a tuple */
    PyObject *func_closure;	/* NULL or a tuple of cell objects */
    PyObject *func_doc;		/* The __doc__ attribute, can be anything */
    PyObject *func_name;	/* The __name__ attribute, a string object */
    PyObject *func_dict;	/* The __dict__ attribute, a dict or NULL */
    PyObject *func_weakreflist;	/* List of weak references */
    PyObject *func_module;	/* The __module__ attribute, can be anything */

/* Invariant:
     *     func_closure contains the bindings for func_code->co_freevars, so
     *     PyTuple_Size(func_closure) == PyCode_GetNumFree(func_code)
     *     (func_closure may be NULL if PyCode_GetNumFree(func_code) == 0).
     */
} PyFunctionObject;

PyAPI_DATA(PyTypeObject) PyFunction_Type;

#define PyFunction_Check(op) (Py_TYPE(op) == &PyFunction_Type)

PyAPI_FUNC(PyObject *) PyFunction_New(PyObject *, PyObject *);
PyAPI_FUNC(PyObject *) PyFunction_GetCode(PyObject *);
PyAPI_FUNC(PyObject *) PyFunction_GetGlobals(PyObject *);
PyAPI_FUNC(PyObject *) PyFunction_GetModule(PyObject *);
PyAPI_FUNC(PyObject *) PyFunction_GetDefaults(PyObject *);
PyAPI_FUNC(int) PyFunction_SetDefaults(PyObject *, PyObject *);
PyAPI_FUNC(PyObject *) PyFunction_GetClosure(PyObject *);
PyAPI_FUNC(int) PyFunction_SetClosure(PyObject *, PyObject *);

/* Macros for direct access to these values. Type checks are *not*
   done, so use with care. */
#define PyFunction_GET_CODE(func) \
        (((PyFunctionObject *)func) -> func_code)
#define PyFunction_GET_GLOBALS(func) \
	(((PyFunctionObject *)func) -> func_globals)
#define PyFunction_GET_MODULE(func) \
	(((PyFunctionObject *)func) -> func_module)
#define PyFunction_GET_DEFAULTS(func) \
	(((PyFunctionObject *)func) -> func_defaults)
#define PyFunction_GET_CLOSURE(func) \
	(((PyFunctionObject *)func) -> func_closure)

/* The classmethod and staticmethod types lives here, too */
PyAPI_DATA(PyTypeObject) PyClassMethod_Type;
PyAPI_DATA(PyTypeObject) PyStaticMethod_Type;

PyAPI_FUNC(PyObject *) PyClassMethod_New(PyObject *);
PyAPI_FUNC(PyObject *) PyStaticMethod_New(PyObject *);

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