File Manager

X7ROOT File Manager

Current Path: /opt/alt/python33/include/python3.3m

opt / alt / python33 / include / python3.3m /

ðŸ“ ..
ðŸ“„ Python-ast.h(18.87 KB)
ðŸ“„ Python.h(2.77 KB)
ðŸ“„ abstract.h(41.61 KB)
ðŸ“„ accu.h(1016 B)
ðŸ“„ asdl.h(1.07 KB)
ðŸ“„ ast.h(344 B)
ðŸ“„ bitset.h(792 B)
ðŸ“„ bltinmodule.h(264 B)
ðŸ“„ boolobject.h(886 B)
ðŸ“„ bytearrayobject.h(1.95 KB)
ðŸ“„ bytes_methods.h(1.98 KB)
ðŸ“„ bytesobject.h(4.78 KB)
ðŸ“„ cellobject.h(701 B)
ðŸ“„ ceval.h(7.03 KB)
ðŸ“„ classobject.h(1.63 KB)
ðŸ“„ code.h(4.13 KB)
ðŸ“„ codecs.h(6.33 KB)
ðŸ“„ compile.h(1.62 KB)
ðŸ“„ complexobject.h(1.91 KB)
ðŸ“„ datetime.h(8.34 KB)
ðŸ“„ descrobject.h(2.84 KB)
ðŸ“„ dictobject.h(4.86 KB)
ðŸ“„ dtoa.h(458 B)
ðŸ“„ dynamic_annotations.h(21.94 KB)
ðŸ“„ enumobject.h(253 B)
ðŸ“„ errcode.h(1.46 KB)
ðŸ“„ eval.h(597 B)
ðŸ“„ fileobject.h(1.73 KB)
ðŸ“„ fileutils.h(1.06 KB)
ðŸ“„ floatobject.h(4.53 KB)
ðŸ“„ frameobject.h(3.29 KB)
ðŸ“„ funcobject.h(3.68 KB)
ðŸ“„ genobject.h(1.05 KB)
ðŸ“„ graminit.h(1.83 KB)
ðŸ“„ grammar.h(1.97 KB)
ðŸ“„ import.h(3.79 KB)
ðŸ“„ intrcheck.h(460 B)
ðŸ“„ iterobject.h(567 B)
ðŸ“„ listobject.h(2.77 KB)
ðŸ“„ longintrepr.h(3.9 KB)
ðŸ“„ longobject.h(7.55 KB)
ðŸ“„ marshal.h(743 B)
ðŸ“„ memoryobject.h(2.8 KB)
ðŸ“„ metagrammar.h(253 B)
ðŸ“„ methodobject.h(3.23 KB)
ðŸ“„ modsupport.h(4.75 KB)
ðŸ“„ moduleobject.h(1.53 KB)
ðŸ“„ namespaceobject.h(297 B)
ðŸ“„ node.h(996 B)
ðŸ“„ object.h(37.09 KB)
ðŸ“„ objimpl.h(13.08 KB)
ðŸ“„ opcode.h(5.09 KB)
ðŸ“„ osdefs.h(986 B)
ðŸ“„ parsetok.h(2.23 KB)
ðŸ“„ patchlevel.h(1.1 KB)
ðŸ“„ pgen.h(253 B)
ðŸ“„ pgenheaders.h(1.12 KB)
ðŸ“„ py_curses.h(4.08 KB)
ðŸ“„ pyarena.h(2.68 KB)
ðŸ“„ pyatomic.h(5.8 KB)
ðŸ“„ pycapsule.h(1.69 KB)
ðŸ“„ pyconfig-64.h(41.43 KB)
ðŸ“„ pyconfig.h(162 B)
ðŸ“„ pyctype.h(1.29 KB)
ðŸ“„ pydebug.h(986 B)
ðŸ“„ pyerrors.h(14.34 KB)
ðŸ“„ pyexpat.h(2.29 KB)
ðŸ“„ pyfpe.h(8.29 KB)
ðŸ“„ pygetopt.h(388 B)
ðŸ“„ pymacconfig.h(2.92 KB)
ðŸ“„ pymacro.h(2.62 KB)
ðŸ“„ pymath.h(6.26 KB)
ðŸ“„ pymem.h(4.59 KB)
ðŸ“„ pyport.h(30.32 KB)
ðŸ“„ pystate.h(7.58 KB)
ðŸ“„ pystrcmp.h(436 B)
ðŸ“„ pystrtod.h(1.25 KB)
ðŸ“„ pythonrun.h(8.79 KB)
ðŸ“„ pythread.h(2.96 KB)
ðŸ“„ pytime.h(2.64 KB)
ðŸ“„ rangeobject.h(629 B)
ðŸ“„ setobject.h(3.21 KB)
ðŸ“„ sliceobject.h(1.35 KB)
ðŸ“„ structmember.h(2.02 KB)
ðŸ“„ structseq.h(1.19 KB)
ðŸ“„ symtable.h(4.58 KB)
ðŸ“„ sysmodule.h(1.08 KB)
ðŸ“„ token.h(1.84 KB)
ðŸ“„ traceback.h(2.09 KB)
ðŸ“„ tupleobject.h(2.39 KB)
ðŸ“„ typeslots.h(1.95 KB)
ðŸ“„ ucnhash.h(1.03 KB)
ðŸ“„ unicodeobject.h(74.41 KB)
ðŸ“„ warnings.h(953 B)
ðŸ“„ weakrefobject.h(2.8 KB)

Editing: pystate.h

/* Thread and interpreter state structures and their interfaces */

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

/* State shared between threads */

struct _ts; /* Forward */
struct _is; /* Forward */

#ifdef Py_LIMITED_API
typedef struct _is PyInterpreterState;
#else
typedef struct _is {

struct _is *next;
    struct _ts *tstate_head;

PyObject *modules;
    PyObject *modules_by_index;
    PyObject *sysdict;
    PyObject *builtins;
    PyObject *importlib;

PyObject *codec_search_path;
    PyObject *codec_search_cache;
    PyObject *codec_error_registry;
    int codecs_initialized;
    int fscodec_initialized;

#ifdef HAVE_DLOPEN
    int dlopenflags;
#endif
#ifdef WITH_TSC
    int tscdump;
#endif

} PyInterpreterState;
#endif

/* State unique per thread */

struct _frame; /* Avoid including frameobject.h */

#ifndef Py_LIMITED_API
/* Py_tracefunc return -1 when raising an exception, or 0 for success. */
typedef int (*Py_tracefunc)(PyObject *, struct _frame *, int, PyObject *);

/* The following values are used for 'what' for tracefunc functions: */
#define PyTrace_CALL 0
#define PyTrace_EXCEPTION 1
#define PyTrace_LINE 2
#define PyTrace_RETURN 3
#define PyTrace_C_CALL 4
#define PyTrace_C_EXCEPTION 5
#define PyTrace_C_RETURN 6
#endif

#ifdef Py_LIMITED_API
typedef struct _ts PyThreadState;
#else
typedef struct _ts {
    /* See Python/ceval.c for comments explaining most fields */

struct _ts *next;
    PyInterpreterState *interp;

struct _frame *frame;
    int recursion_depth;
    char overflowed; /* The stack has overflowed. Allow 50 more calls
                        to handle the runtime error. */
    char recursion_critical; /* The current calls must not cause
                                a stack overflow. */
    /* 'tracing' keeps track of the execution depth when tracing/profiling.
       This is to prevent the actual trace/profile code from being recorded in
       the trace/profile. */
    int tracing;
    int use_tracing;

Py_tracefunc c_profilefunc;
    Py_tracefunc c_tracefunc;
    PyObject *c_profileobj;
    PyObject *c_traceobj;

PyObject *curexc_type;
    PyObject *curexc_value;
    PyObject *curexc_traceback;

PyObject *exc_type;
    PyObject *exc_value;
    PyObject *exc_traceback;

PyObject *dict;  /* Stores per-thread state */

/* XXX doesn't mean anything anymore (the comment below is obsolete)
       => deprecate or remove? */
    /* tick_counter is incremented whenever the check_interval ticker
     * reaches zero. The purpose is to give a useful measure of the number
     * of interpreted bytecode instructions in a given thread.  This
     * extremely lightweight statistic collector may be of interest to
     * profilers (like psyco.jit()), although nothing in the core uses it.
     */
    int tick_counter;

int gilstate_counter;

PyObject *async_exc; /* Asynchronous exception to raise */
    long thread_id; /* Thread id where this tstate was created */

int trash_delete_nesting;
    PyObject *trash_delete_later;

/* XXX signal handlers should also be here */

} PyThreadState;
#endif

PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_New(void);
PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState *);
PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState *);
PyAPI_FUNC(int) _PyState_AddModule(PyObject*, struct PyModuleDef*);
#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
/* New in 3.3 */
PyAPI_FUNC(int) PyState_AddModule(PyObject*, struct PyModuleDef*);
PyAPI_FUNC(int) PyState_RemoveModule(struct PyModuleDef*);
#endif
PyAPI_FUNC(PyObject*) PyState_FindModule(struct PyModuleDef*);

PyAPI_FUNC(PyThreadState *) PyThreadState_New(PyInterpreterState *);
PyAPI_FUNC(PyThreadState *) _PyThreadState_Prealloc(PyInterpreterState *);
PyAPI_FUNC(void) _PyThreadState_Init(PyThreadState *);
PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState *);
PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *);
#ifdef WITH_THREAD
PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void);
PyAPI_FUNC(void) _PyGILState_Reinit(void);
#endif

PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void);
PyAPI_FUNC(PyThreadState *) PyThreadState_Swap(PyThreadState *);
PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void);
PyAPI_FUNC(int) PyThreadState_SetAsyncExc(long, PyObject *);

/* Variable and macro for in-line access to current thread state */

/* Assuming the current thread holds the GIL, this is the
   PyThreadState for the current thread. */
#ifndef Py_LIMITED_API
PyAPI_DATA(_Py_atomic_address) _PyThreadState_Current;
#endif

#if defined(Py_DEBUG) || defined(Py_LIMITED_API)
#define PyThreadState_GET() PyThreadState_Get()
#else
#define PyThreadState_GET() \
    ((PyThreadState*)_Py_atomic_load_relaxed(&_PyThreadState_Current))
#endif

typedef
    enum {PyGILState_LOCKED, PyGILState_UNLOCKED}
        PyGILState_STATE;

#ifdef WITH_THREAD

/* Ensure that the current thread is ready to call the Python
   C API, regardless of the current state of Python, or of its
   thread lock.  This may be called as many times as desired
   by a thread so long as each call is matched with a call to
   PyGILState_Release().  In general, other thread-state APIs may
   be used between _Ensure() and _Release() calls, so long as the
   thread-state is restored to its previous state before the Release().
   For example, normal use of the Py_BEGIN_ALLOW_THREADS/
   Py_END_ALLOW_THREADS macros are acceptable.

The return value is an opaque "handle" to the thread state when
   PyGILState_Ensure() was called, and must be passed to
   PyGILState_Release() to ensure Python is left in the same state. Even
   though recursive calls are allowed, these handles can *not* be shared -
   each unique call to PyGILState_Ensure must save the handle for its
   call to PyGILState_Release.

When the function returns, the current thread will hold the GIL.

Failure is a fatal error.
*/
PyAPI_FUNC(PyGILState_STATE) PyGILState_Ensure(void);

/* Release any resources previously acquired.  After this call, Python's
   state will be the same as it was prior to the corresponding
   PyGILState_Ensure() call (but generally this state will be unknown to
   the caller, hence the use of the GILState API.)

Every call to PyGILState_Ensure must be matched by a call to
   PyGILState_Release on the same thread.
*/
PyAPI_FUNC(void) PyGILState_Release(PyGILState_STATE);

/* Helper/diagnostic function - get the current thread state for
   this thread.  May return NULL if no GILState API has been used
   on the current thread.  Note that the main thread always has such a
   thread-state, even if no auto-thread-state call has been made
   on the main thread.
*/
PyAPI_FUNC(PyThreadState *) PyGILState_GetThisThreadState(void);

#endif   /* #ifdef WITH_THREAD */

/* The implementation of sys._current_frames()  Returns a dict mapping
   thread id to that thread's current frame.
*/
#ifndef Py_LIMITED_API
PyAPI_FUNC(PyObject *) _PyThread_CurrentFrames(void);
#endif

/* Routines for advanced debuggers, requested by David Beazley.
   Don't use unless you know what you are doing! */
#ifndef Py_LIMITED_API
PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void);
PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Next(PyInterpreterState *);
PyAPI_FUNC(PyThreadState *) PyInterpreterState_ThreadHead(PyInterpreterState *);
PyAPI_FUNC(PyThreadState *) PyThreadState_Next(PyThreadState *);

typedef struct _frame *(*PyThreadFrameGetter)(PyThreadState *self_);
#endif

/* hook for PyEval_GetFrame(), requested for Psyco */
#ifndef Py_LIMITED_API
PyAPI_DATA(PyThreadFrameGetter) _PyThreadState_GetFrame;
#endif

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

X7ROOT File Manager

Editing: pystate.h

Upload File

Create Folder