home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 June / PCWorld_2005-06_cd.bin / software / vyzkuste / firewally / firewally.exe / framework-2.3.exe / ceval.h < prev    next >
C/C++ Source or Header  |  2003-12-30  |  4KB  |  139 lines
  1. #ifndef Py_CEVAL_H
  2. #define Py_CEVAL_H
  3. #ifdef __cplusplus
  4. extern "C" {
  5. #endif
  6.  
  7.  
  8. /* Interface to random parts in ceval.c */
  9.  
  10. PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords(
  11.     PyObject *, PyObject *, PyObject *);
  12.  
  13. /* DLL-level Backwards compatibility: */
  14. #undef PyEval_CallObject
  15. PyAPI_FUNC(PyObject *) PyEval_CallObject(PyObject *, PyObject *);
  16.  
  17. /* Inline this */
  18. #define PyEval_CallObject(func,arg) \
  19.         PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
  20.  
  21. PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *obj, char *format, ...);
  22. PyAPI_FUNC(PyObject *) PyEval_CallMethod(PyObject *obj,
  23.                                         char *methodname, char *format, ...);
  24.  
  25. PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *);
  26. PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *);
  27.  
  28. struct _frame; /* Avoid including frameobject.h */
  29.  
  30. PyAPI_FUNC(PyObject *) PyEval_GetBuiltins(void);
  31. PyAPI_FUNC(PyObject *) PyEval_GetGlobals(void);
  32. PyAPI_FUNC(PyObject *) PyEval_GetLocals(void);
  33. PyAPI_FUNC(struct _frame *) PyEval_GetFrame(void);
  34. PyAPI_FUNC(int) PyEval_GetRestricted(void);
  35.  
  36. /* Look at the current frame's (if any) code's co_flags, and turn on
  37.    the corresponding compiler flags in cf->cf_flags.  Return 1 if any
  38.    flag was set, else return 0. */
  39. PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf);
  40.  
  41. PyAPI_FUNC(int) Py_FlushLine(void);
  42.  
  43. PyAPI_FUNC(int) Py_AddPendingCall(int (*func)(void *), void *arg);
  44. PyAPI_FUNC(int) Py_MakePendingCalls(void);
  45.  
  46. PyAPI_FUNC(void) Py_SetRecursionLimit(int);
  47. PyAPI_FUNC(int) Py_GetRecursionLimit(void);
  48.  
  49. PyAPI_FUNC(char *) PyEval_GetFuncName(PyObject *);
  50. PyAPI_FUNC(char *) PyEval_GetFuncDesc(PyObject *);
  51.  
  52. PyAPI_FUNC(PyObject *) PyEval_GetCallStats(PyObject *);
  53.  
  54. /* this used to be handled on a per-thread basis - now just two globals */
  55. PyAPI_DATA(volatile int) _Py_Ticker;
  56. PyAPI_DATA(int) _Py_CheckInterval;
  57.  
  58. /* Interface for threads.
  59.  
  60.    A module that plans to do a blocking system call (or something else
  61.    that lasts a long time and doesn't touch Python data) can allow other
  62.    threads to run as follows:
  63.  
  64.     ...preparations here...
  65.     Py_BEGIN_ALLOW_THREADS
  66.     ...blocking system call here...
  67.     Py_END_ALLOW_THREADS
  68.     ...interpret result here...
  69.  
  70.    The Py_BEGIN_ALLOW_THREADS/Py_END_ALLOW_THREADS pair expands to a
  71.    {}-surrounded block.
  72.    To leave the block in the middle (e.g., with return), you must insert
  73.    a line containing Py_BLOCK_THREADS before the return, e.g.
  74.  
  75.     if (...premature_exit...) {
  76.         Py_BLOCK_THREADS
  77.         PyErr_SetFromErrno(PyExc_IOError);
  78.         return NULL;
  79.     }
  80.  
  81.    An alternative is:
  82.  
  83.     Py_BLOCK_THREADS
  84.     if (...premature_exit...) {
  85.         PyErr_SetFromErrno(PyExc_IOError);
  86.         return NULL;
  87.     }
  88.     Py_UNBLOCK_THREADS
  89.  
  90.    For convenience, that the value of 'errno' is restored across
  91.    Py_END_ALLOW_THREADS and Py_BLOCK_THREADS.
  92.  
  93.    WARNING: NEVER NEST CALLS TO Py_BEGIN_ALLOW_THREADS AND
  94.    Py_END_ALLOW_THREADS!!!
  95.  
  96.    The function PyEval_InitThreads() should be called only from
  97.    initthread() in "threadmodule.c".
  98.  
  99.    Note that not yet all candidates have been converted to use this
  100.    mechanism!
  101. */
  102.  
  103. PyAPI_FUNC(PyThreadState *) PyEval_SaveThread(void);
  104. PyAPI_FUNC(void) PyEval_RestoreThread(PyThreadState *);
  105.  
  106. #ifdef WITH_THREAD
  107.  
  108. PyAPI_FUNC(void) PyEval_InitThreads(void);
  109. PyAPI_FUNC(void) PyEval_AcquireLock(void);
  110. PyAPI_FUNC(void) PyEval_ReleaseLock(void);
  111. PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState *tstate);
  112. PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate);
  113. PyAPI_FUNC(void) PyEval_ReInitThreads(void);
  114.  
  115. #define Py_BEGIN_ALLOW_THREADS { \
  116.             PyThreadState *_save; \
  117.             _save = PyEval_SaveThread();
  118. #define Py_BLOCK_THREADS    PyEval_RestoreThread(_save);
  119. #define Py_UNBLOCK_THREADS    _save = PyEval_SaveThread();
  120. #define Py_END_ALLOW_THREADS    PyEval_RestoreThread(_save); \
  121.          }
  122.  
  123. #else /* !WITH_THREAD */
  124.  
  125. #define Py_BEGIN_ALLOW_THREADS {
  126. #define Py_BLOCK_THREADS
  127. #define Py_UNBLOCK_THREADS
  128. #define Py_END_ALLOW_THREADS }
  129.  
  130. #endif /* !WITH_THREAD */
  131.  
  132. PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, int *);
  133.  
  134.  
  135. #ifdef __cplusplus
  136. }
  137. #endif
  138. #endif /* !Py_CEVAL_H */
  139.