summaryrefslogtreecommitdiffstats
path: root/Include
diff options
context:
space:
mode:
Diffstat (limited to 'Include')
-rw-r--r--Include/Python.h2
-rw-r--r--Include/code.h1
-rw-r--r--Include/frameobject.h13
-rw-r--r--Include/longobject.h1
-rw-r--r--Include/osdefs.h4
-rw-r--r--Include/pyerrors.h69
-rw-r--r--Include/pyport.h58
-rw-r--r--Include/unicodeobject.h48
8 files changed, 181 insertions, 15 deletions
diff --git a/Include/Python.h b/Include/Python.h
index fffc688..ca16c64 100644
--- a/Include/Python.h
+++ b/Include/Python.h
@@ -35,7 +35,9 @@
#endif
#include <string.h>
+#ifndef DONT_HAVE_ERRNO_H
#include <errno.h>
+#endif
#include <stdlib.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
diff --git a/Include/code.h b/Include/code.h
index 23d9e17..432ec8e 100644
--- a/Include/code.h
+++ b/Include/code.h
@@ -24,6 +24,7 @@ typedef struct {
PyObject *co_name; /* string (name, for reference) */
int co_firstlineno; /* first source line number */
PyObject *co_lnotab; /* string (encoding addr<->lineno mapping) */
+ void *co_zombieframe; /* for optimization only (see frameobject.c) */
} PyCodeObject;
/* Masks for co_flags above */
diff --git a/Include/frameobject.h b/Include/frameobject.h
index 7dc14e3..cce598b 100644
--- a/Include/frameobject.h
+++ b/Include/frameobject.h
@@ -26,7 +26,16 @@ typedef struct _frame {
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
+
+ /* If an exception is raised in this frame, the next three are used to
+ * record the exception info (if any) originally in the thread state. See
+ * comments before set_exc_info() -- it's not obvious.
+ * Invariant: if _type is NULL, then so are _value and _traceback.
+ * Desired invariant: all three are NULL, or all three are non-NULL. That
+ * one isn't currently true, but "should be".
+ */
PyObject *f_exc_type, *f_exc_value, *f_exc_traceback;
+
PyThreadState *f_tstate;
int f_lasti; /* Last instruction if called */
/* As of 2.3 f_lineno is only valid when tracing is active (i.e. when
@@ -36,10 +45,6 @@ typedef struct _frame {
in this scope */
int f_iblock; /* index in f_blockstack */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
- int f_nlocals; /* number of locals */
- int f_ncells;
- int f_nfreevars;
- int f_stacksize; /* size of value stack */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
} PyFrameObject;
diff --git a/Include/longobject.h b/Include/longobject.h
index 77544ef..eef4e9b 100644
--- a/Include/longobject.h
+++ b/Include/longobject.h
@@ -25,6 +25,7 @@ PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLongMask(PyObject *);
PyAPI_FUNC(Py_ssize_t) _PyLong_AsSsize_t(PyObject *);
PyAPI_FUNC(PyObject *) _PyLong_FromSize_t(size_t);
PyAPI_FUNC(PyObject *) _PyLong_FromSsize_t(Py_ssize_t);
+PyAPI_DATA(int) _PyLong_DigitValue[256];
/* _PyLong_AsScaledDouble returns a double x and an exponent e such that
the true value is approximately equal to x * 2**(SHIFT*e). e is >= 0.
diff --git a/Include/osdefs.h b/Include/osdefs.h
index 8190a75..6937659 100644
--- a/Include/osdefs.h
+++ b/Include/osdefs.h
@@ -37,8 +37,12 @@ extern "C" {
/* Max pathname length */
#ifndef MAXPATHLEN
+#if defined(PATH_MAX) && PATH_MAX > 1024
+#define MAXPATHLEN PATH_MAX
+#else
#define MAXPATHLEN 1024
#endif
+#endif
/* Search path entry delimiter */
#ifndef DELIM
diff --git a/Include/pyerrors.h b/Include/pyerrors.h
index 0e7718c..6006ac7 100644
--- a/Include/pyerrors.h
+++ b/Include/pyerrors.h
@@ -4,6 +4,72 @@
extern "C" {
#endif
+/* Error objects */
+
+typedef struct {
+ PyObject_HEAD
+ PyObject *dict;
+ PyObject *args;
+ PyObject *message;
+} PyBaseExceptionObject;
+
+typedef struct {
+ PyObject_HEAD
+ PyObject *dict;
+ PyObject *args;
+ PyObject *message;
+ PyObject *msg;
+ PyObject *filename;
+ PyObject *lineno;
+ PyObject *offset;
+ PyObject *text;
+ PyObject *print_file_and_line;
+} PySyntaxErrorObject;
+
+#ifdef Py_USING_UNICODE
+typedef struct {
+ PyObject_HEAD
+ PyObject *dict;
+ PyObject *args;
+ PyObject *message;
+ PyObject *encoding;
+ PyObject *object;
+ PyObject *start;
+ PyObject *end;
+ PyObject *reason;
+} PyUnicodeErrorObject;
+#endif
+
+typedef struct {
+ PyObject_HEAD
+ PyObject *dict;
+ PyObject *args;
+ PyObject *message;
+ PyObject *code;
+} PySystemExitObject;
+
+typedef struct {
+ PyObject_HEAD
+ PyObject *dict;
+ PyObject *args;
+ PyObject *message;
+ PyObject *myerrno;
+ PyObject *strerror;
+ PyObject *filename;
+} PyEnvironmentErrorObject;
+
+#ifdef MS_WINDOWS
+typedef struct {
+ PyObject_HEAD
+ PyObject *dict;
+ PyObject *args;
+ PyObject *message;
+ PyObject *myerrno;
+ PyObject *strerror;
+ PyObject *filename;
+ PyObject *winerror;
+} PyWindowsErrorObject;
+#endif
/* Error handling definitions */
@@ -97,10 +163,9 @@ PyAPI_DATA(PyObject *) PyExc_UserWarning;
PyAPI_DATA(PyObject *) PyExc_DeprecationWarning;
PyAPI_DATA(PyObject *) PyExc_PendingDeprecationWarning;
PyAPI_DATA(PyObject *) PyExc_SyntaxWarning;
-/* PyExc_OverflowWarning will go away for Python 2.5 */
-PyAPI_DATA(PyObject *) PyExc_OverflowWarning;
PyAPI_DATA(PyObject *) PyExc_RuntimeWarning;
PyAPI_DATA(PyObject *) PyExc_FutureWarning;
+PyAPI_DATA(PyObject *) PyExc_ImportWarning;
/* Convenience functions */
diff --git a/Include/pyport.h b/Include/pyport.h
index 2bce415..74ce993 100644
--- a/Include/pyport.h
+++ b/Include/pyport.h
@@ -137,6 +137,43 @@ typedef Py_intptr_t Py_ssize_t;
# endif
#endif
+/* Py_LOCAL can be used instead of static to get the fastest possible calling
+ * convention for functions that are local to a given module.
+ *
+ * Py_LOCAL_INLINE does the same thing, and also explicitly requests inlining,
+ * for platforms that support that.
+ *
+ * If PY_LOCAL_AGGRESSIVE is defined before python.h is included, more
+ * "aggressive" inlining/optimizaion is enabled for the entire module. This
+ * may lead to code bloat, and may slow things down for those reasons. It may
+ * also lead to errors, if the code relies on pointer aliasing. Use with
+ * care.
+ *
+ * NOTE: You can only use this for functions that are entirely local to a
+ * module; functions that are exported via method tables, callbacks, etc,
+ * should keep using static.
+ */
+
+#undef USE_INLINE /* XXX - set via configure? */
+
+#if defined(_MSC_VER)
+#if defined(PY_LOCAL_AGGRESSIVE)
+/* enable more aggressive optimization for visual studio */
+#pragma optimize("agtw", on)
+#endif
+/* ignore warnings if the compiler decides not to inline a function */
+#pragma warning(disable: 4710)
+/* fastest possible local call under MSVC */
+#define Py_LOCAL(type) static type __fastcall
+#define Py_LOCAL_INLINE(type) static __inline type __fastcall
+#elif defined(USE_INLINE)
+#define Py_LOCAL(type) static type
+#define Py_LOCAL_INLINE(type) static inline type
+#else
+#define Py_LOCAL(type) static type
+#define Py_LOCAL_INLINE(type) static type
+#endif
+
#include <stdlib.h>
#include <math.h> /* Moved here from the math section, before extern "C" */
@@ -295,6 +332,15 @@ extern "C" {
#define Py_IS_INFINITY(X) ((X) && (X)*0.5 == (X))
#endif
+/* Py_IS_FINITE(X)
+ * Return 1 if float or double arg is neither infinite nor NAN, else 0.
+ * Some compilers (e.g. VisualStudio) have intrisics for this, so a special
+ * macro for this particular test is useful
+ */
+#ifndef Py_IS_FINITE
+#define Py_IS_FINITE(X) (!Py_IS_INFINITY(X) && !Py_IS_NAN(X))
+#endif
+
/* HUGE_VAL is supposed to expand to a positive double infinity. Python
* uses Py_HUGE_VAL instead because some platforms are broken in this
* respect. We used to embed code in pyport.h to try to worm around that,
@@ -685,4 +731,16 @@ typedef struct fd_set {
#pragma error_messages (off,E_END_OF_LOOP_CODE_NOT_REACHED)
#endif
+/*
+ * Older Microsoft compilers don't support the C99 long long literal suffixes,
+ * so these will be defined in PC/pyconfig.h for those compilers.
+ */
+#ifndef Py_LL
+#define Py_LL(x) x##LL
+#endif
+
+#ifndef Py_ULL
+#define Py_ULL(x) Py_LL(x##U)
+#endif
+
#endif /* Py_PYPORT_H */
diff --git a/Include/unicodeobject.h b/Include/unicodeobject.h
index 9012257..0531aed 100644
--- a/Include/unicodeobject.h
+++ b/Include/unicodeobject.h
@@ -184,11 +184,13 @@ typedef PY_UNICODE_TYPE Py_UNICODE;
# define PyUnicode_GetMax PyUnicodeUCS2_GetMax
# define PyUnicode_GetSize PyUnicodeUCS2_GetSize
# define PyUnicode_Join PyUnicodeUCS2_Join
+# define PyUnicode_Partition PyUnicodeUCS2_Partition
+# define PyUnicode_RPartition PyUnicodeUCS2_RPartition
+# define PyUnicode_RSplit PyUnicodeUCS2_RSplit
# define PyUnicode_Replace PyUnicodeUCS2_Replace
# define PyUnicode_Resize PyUnicodeUCS2_Resize
# define PyUnicode_SetDefaultEncoding PyUnicodeUCS2_SetDefaultEncoding
# define PyUnicode_Split PyUnicodeUCS2_Split
-# define PyUnicode_RSplit PyUnicodeUCS2_RSplit
# define PyUnicode_Splitlines PyUnicodeUCS2_Splitlines
# define PyUnicode_Tailmatch PyUnicodeUCS2_Tailmatch
# define PyUnicode_Translate PyUnicodeUCS2_Translate
@@ -259,6 +261,9 @@ typedef PY_UNICODE_TYPE Py_UNICODE;
# define PyUnicode_GetMax PyUnicodeUCS4_GetMax
# define PyUnicode_GetSize PyUnicodeUCS4_GetSize
# define PyUnicode_Join PyUnicodeUCS4_Join
+# define PyUnicode_Partition PyUnicodeUCS4_Partition
+# define PyUnicode_RPartition PyUnicodeUCS4_RPartition
+# define PyUnicode_RSplit PyUnicodeUCS4_RSplit
# define PyUnicode_Replace PyUnicodeUCS4_Replace
# define PyUnicode_Resize PyUnicodeUCS4_Resize
# define PyUnicode_SetDefaultEncoding PyUnicodeUCS4_SetDefaultEncoding
@@ -352,17 +357,27 @@ typedef PY_UNICODE_TYPE Py_UNICODE;
Py_UNICODE_ISDIGIT(ch) || \
Py_UNICODE_ISNUMERIC(ch))
-#define Py_UNICODE_COPY(target, source, length)\
- (memcpy((target), (source), (length)*sizeof(Py_UNICODE)))
+/* memcpy has a considerable setup overhead on many platforms; use a
+ loop for short strings (the "16" below is pretty arbitary) */
+#define Py_UNICODE_COPY(target, source, length) do\
+ {Py_ssize_t i_; Py_UNICODE *t_ = (target); const Py_UNICODE *s_ = (source);\
+ if (length > 16)\
+ memcpy(t_, s_, (length)*sizeof(Py_UNICODE));\
+ else\
+ for (i_ = 0; i_ < (length); i_++) t_[i_] = s_[i_];\
+ } while (0)
#define Py_UNICODE_FILL(target, value, length) do\
- {int i; for (i = 0; i < (length); i++) (target)[i] = (value);}\
- while (0)
+ {Py_ssize_t i_; Py_UNICODE *t_ = (target); Py_UNICODE v_ = (value);\
+ for (i_ = 0; i_ < (length); i_++) t_[i_] = v_;\
+ } while (0)
-#define Py_UNICODE_MATCH(string, offset, substring)\
- ((*((string)->str + (offset)) == *((substring)->str)) &&\
- !memcmp((string)->str + (offset), (substring)->str,\
- (substring)->length*sizeof(Py_UNICODE)))
+/* check if substring matches at given offset. the offset must be
+ valid, and the substring must not be empty */
+#define Py_UNICODE_MATCH(string, offset, substring) \
+ ((*((string)->str + (offset)) == *((substring)->str)) && \
+ ((*((string)->str + (offset) + (substring)->length-1) == *((substring)->str + (substring)->length-1))) && \
+ !memcmp((string)->str + (offset), (substring)->str, (substring)->length*sizeof(Py_UNICODE)))
#ifdef __cplusplus
extern "C" {
@@ -1008,6 +1023,21 @@ PyAPI_FUNC(PyObject*) PyUnicode_Splitlines(
int keepends /* If true, line end markers are included */
);
+/* Partition a string using a given separator. */
+
+PyAPI_FUNC(PyObject*) PyUnicode_Partition(
+ PyObject *s, /* String to partition */
+ PyObject *sep /* String separator */
+ );
+
+/* Partition a string using a given separator, searching from the end of the
+ string. */
+
+PyAPI_FUNC(PyObject*) PyUnicode_RPartition(
+ PyObject *s, /* String to partition */
+ PyObject *sep /* String separator */
+ );
+
/* Split a string giving a list of Unicode strings.
If sep is NULL, splitting will be done at all whitespace
generated by cgit v0.12 at 2025-02-17 15:16:22 (GMT)