extern "C" {\r
#endif\r
\r
-PyDoc_STRVAR(posix__doc__,\r
-"This module provides access to operating system functionality that is\n\\r
-standardized by the C Standard and the POSIX standard (a thinly\n\\r
-disguised Unix interface). Refer to the library manual and\n\\r
-corresponding Unix manual entries for more information on calls.");\r
+PyDoc_STRVAR(edk2__doc__,\r
+ "This module provides access to UEFI firmware functionality that is\n\\r
+ standardized by the C Standard and the POSIX standard (a thinly\n\\r
+ disguised Unix interface). Refer to the library manual and\n\\r
+ corresponding UEFI Specification entries for more information on calls.");\r
\r
#ifndef Py_USING_UNICODE\r
/* This is used in signatures of functions. */\r
\r
/* POSIX generic methods */\r
\r
-static PyObject *\r
-posix_fildes(PyObject *fdobj, int (*func)(int))\r
-{\r
- int fd;\r
- int res;\r
- fd = PyObject_AsFileDescriptor(fdobj);\r
- if (fd < 0)\r
- return NULL;\r
- if (!_PyVerify_fd(fd))\r
- return posix_error();\r
- Py_BEGIN_ALLOW_THREADS\r
- res = (*func)(fd);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return posix_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
+#ifndef UEFI_C_SOURCE\r
+ static PyObject *\r
+ posix_fildes(PyObject *fdobj, int (*func)(int))\r
+ {\r
+ int fd;\r
+ int res;\r
+ fd = PyObject_AsFileDescriptor(fdobj);\r
+ if (fd < 0)\r
+ return NULL;\r
+ if (!_PyVerify_fd(fd))\r
+ return posix_error();\r
+ Py_BEGIN_ALLOW_THREADS\r
+ res = (*func)(fd);\r
+ Py_END_ALLOW_THREADS\r
+ if (res < 0)\r
+ return posix_error();\r
+ Py_INCREF(Py_None);\r
+ return Py_None;\r
+ }\r
+#endif /* UEFI_C_SOURCE */\r
\r
static PyObject *\r
posix_1str(PyObject *args, char *format, int (*func)(const char*))\r
statvfs_result_fields,\r
10\r
};\r
+\r
+static PyTypeObject StatVFSResultType;\r
#endif\r
\r
static int initialized;\r
static PyTypeObject StatResultType;\r
-static PyTypeObject StatVFSResultType;\r
static newfunc structseq_new;\r
\r
static PyObject *\r
static int _stat_float_times = 0;\r
#else\r
static int _stat_float_times = 1;\r
-#endif\r
\r
PyDoc_STRVAR(stat_float_times__doc__,\r
"stat_float_times([newval]) -> oldval\n\n\\r
Py_INCREF(Py_None);\r
return Py_None;\r
}\r
+#endif /* UEFI_C_SOURCE */\r
\r
static void\r
fill_time(PyObject *v, int index, time_t sec, unsigned long nsec)\r
}\r
#endif\r
\r
+#ifndef UEFI_C_SOURCE\r
PyDoc_STRVAR(posix_getuid__doc__,\r
"getuid() -> uid\n\n\\r
Return the current process's user id.");\r
{\r
return PyInt_FromLong((long)getuid());\r
}\r
-\r
+#endif /* UEFI_C_SOURCE */\r
\r
#ifdef HAVE_KILL\r
PyDoc_STRVAR(posix_kill__doc__,\r
long value;\r
};\r
\r
+#ifndef UEFI_C_SOURCE\r
static int\r
conv_confname(PyObject *arg, int *valuep, struct constdef *table,\r
size_t tablesize)\r
"configuration names must be strings or integers");\r
return 0;\r
}\r
-\r
+#endif /* UEFI_C_SOURCE */\r
\r
#if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF)\r
static struct constdef posix_constants_pathconf[] = {\r
#endif\r
\r
\r
+#if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF) || defined(HAVE_CONFSTR) || defined(HAVE_SYSCONF)\r
/* This code is used to ensure that the tables of configuration value names\r
* are in sorted order as required by conv_confname(), and also to build the\r
* the exported dictionaries that are used to publish information about the\r
}\r
return PyModule_AddObject(module, tablename, d);\r
}\r
+#endif /* HAVE_FPATHCONF || HAVE_PATHCONF || HAVE_CONFSTR || HAVE_SYSCONF */\r
\r
/* Return -1 on failure, 0 on success. */\r
static int\r
PyMODINIT_FUNC\r
INITFUNC(void)\r
{\r
- PyObject *m, *v;\r
+ PyObject *m;\r
+\r
+#ifndef UEFI_C_SOURCE\r
+ PyObject *v;\r
+#endif\r
\r
m = Py_InitModule3(MODNAME,\r
posix_methods,\r
- posix__doc__);\r
+ edk2__doc__);\r
if (m == NULL)\r
return;\r
\r
/Efi/StdLib/lib/python.VERSION The platform independent Python modules.\r
/Efi/StdLib/lib/python.VERSION/dynalib Dynamically loadable Python extension modules.\r
\r
- Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials are licensed and made available under\r
the terms and conditions of the BSD License that accompanies this distribution.\r
The full text of the license may be found at\r
#endif\r
\r
#ifndef PYTHONPATH\r
-//#define PYTHONPATH PREFIX LIBPYTHON sDELIM \\r
-// EXEC_PREFIX LIBPYTHON "/lib-dynload"\r
- #define PYTHONPATH LIBPYTHON // sDELIM\r
-// LIBPYTHON "/lib-dynload"\r
+ #ifdef HAVE_ENVIRONMENT_OPS\r
+ #define PYTHONPATH PREFIX LIBPYTHON sDELIM \\r
+ EXEC_PREFIX LIBPYTHON "/lib-dynload"\r
+ #else\r
+ #define PYTHONPATH LIBPYTHON\r
+ #endif\r
#endif\r
\r
#ifndef LANDMARK\r
dir[i] = '\0';\r
}\r
\r
+#ifndef UEFI_C_SOURCE\r
/** Does filename point to a file and not directory?\r
\r
@param[in] filename The fully qualified path to the object to test.\r
\r
return 1;\r
}\r
+#endif /* UEFI_C_SOURCE */\r
\r
/** Determine if a path is absolute, or not.\r
An absolute path consists of a volume name, "VOL:", followed by a rooted path,\r
+++ /dev/null
-\r
-/* File object interface */\r
-\r
-#ifndef Py_FILEOBJECT_H\r
-#define Py_FILEOBJECT_H\r
-#ifdef __cplusplus\r
-extern "C" {\r
-#endif\r
-\r
-typedef struct {\r
- PyObject_HEAD\r
- FILE *f_fp;\r
- PyObject *f_name;\r
- PyObject *f_mode;\r
- int (*f_close)(FILE *);\r
- int f_softspace; /* Flag used by 'print' command */\r
- int f_binary; /* Flag which indicates whether the file is\r
- open in binary (1) or text (0) mode */\r
- char* f_buf; /* Allocated readahead buffer */\r
- char* f_bufend; /* Points after last occupied position */\r
- char* f_bufptr; /* Current buffer position */\r
- char *f_setbuf; /* Buffer for setbuf(3) and setvbuf(3) */\r
- int f_univ_newline; /* Handle any newline convention */\r
- int f_newlinetypes; /* Types of newlines seen */\r
- int f_skipnextlf; /* Skip next \n */\r
- PyObject *f_encoding;\r
- PyObject *f_errors;\r
- PyObject *weakreflist; /* List of weak references */\r
- int unlocked_count; /* Num. currently running sections of code\r
- using f_fp with the GIL released. */\r
- int readable;\r
- int writable;\r
-} PyFileObject;\r
-\r
-PyAPI_DATA(PyTypeObject) PyFile_Type;\r
-\r
-#define PyFile_Check(op) PyObject_TypeCheck(op, &PyFile_Type)\r
-#define PyFile_CheckExact(op) (Py_TYPE(op) == &PyFile_Type)\r
-\r
-PyAPI_FUNC(PyObject *) PyFile_FromString(char *, char *);\r
-PyAPI_FUNC(void) PyFile_SetBufSize(PyObject *, int);\r
-PyAPI_FUNC(int) PyFile_SetEncoding(PyObject *, const char *);\r
-PyAPI_FUNC(int) PyFile_SetEncodingAndErrors(PyObject *, const char *, char *errors);\r
-PyAPI_FUNC(PyObject *) PyFile_FromFile(FILE *, char *, char *,\r
- int (*)(FILE *));\r
-PyAPI_FUNC(FILE *) PyFile_AsFile(PyObject *);\r
-PyAPI_FUNC(void) PyFile_IncUseCount(PyFileObject *);\r
-PyAPI_FUNC(void) PyFile_DecUseCount(PyFileObject *);\r
-PyAPI_FUNC(PyObject *) PyFile_Name(PyObject *);\r
-PyAPI_FUNC(PyObject *) PyFile_GetLine(PyObject *, int);\r
-PyAPI_FUNC(int) PyFile_WriteObject(PyObject *, PyObject *, int);\r
-PyAPI_FUNC(int) PyFile_SoftSpace(PyObject *, int);\r
-PyAPI_FUNC(int) PyFile_WriteString(const char *, PyObject *);\r
-PyAPI_FUNC(int) PyObject_AsFileDescriptor(PyObject *);\r
-\r
-/* The default encoding used by the platform file system APIs\r
- If non-NULL, this is different than the default encoding for strings\r
-*/\r
-PyAPI_DATA(const char *) Py_FileSystemDefaultEncoding;\r
-\r
-/* Routines to replace fread() and fgets() which accept any of \r, \n\r
- or \r\n as line terminators.\r
-*/\r
-#define PY_STDIOTEXTMODE "b"\r
-char *Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *);\r
-size_t Py_UniversalNewlineFread(char *, size_t, FILE *, PyObject *);\r
-\r
-/* A routine to do sanity checking on the file mode string. returns\r
- non-zero on if an exception occurred\r
-*/\r
-int _PyFile_SanitizeMode(char *mode);\r
-\r
-//#if defined _MSC_VER && _MSC_VER >= 1400\r
-/* A routine to check if a file descriptor is valid on Windows. Returns 0\r
- * and sets errno to EBADF if it isn't. This is to avoid Assertions\r
- * from various functions in the Windows CRT beginning with\r
- * Visual Studio 2005\r
- */\r
-//int _PyVerify_fd(int fd);\r
-//#elif defined _MSC_VER && _MSC_VER >= 1200\r
-/* fdopen doesn't set errno EBADF and crashes for large fd on debug build */\r
-//#define _PyVerify_fd(fd) (_get_osfhandle(fd) >= 0)\r
-//#else\r
-#define _PyVerify_fd(A) (1) /* dummy */\r
-//#endif\r
-\r
-#ifdef __cplusplus\r
-}\r
-#endif\r
-#endif /* !Py_FILEOBJECT_H */\r
+++ /dev/null
-#ifndef Py_PYPORT_H\r
-#define Py_PYPORT_H\r
-\r
-#include "pyconfig.h" /* include for defines */\r
-\r
-/* Some versions of HP-UX & Solaris need inttypes.h for int32_t,\r
- INT32_MAX, etc. */\r
-#ifdef HAVE_INTTYPES_H\r
-#include <inttypes.h>\r
-#endif\r
-\r
-#ifdef HAVE_STDINT_H\r
-#include <stdint.h>\r
-#endif\r
-\r
-/**************************************************************************\r
-Symbols and macros to supply platform-independent interfaces to basic\r
-C language & library operations whose spellings vary across platforms.\r
-\r
-Please try to make documentation here as clear as possible: by definition,\r
-the stuff here is trying to illuminate C's darkest corners.\r
-\r
-Config #defines referenced here:\r
-\r
-SIGNED_RIGHT_SHIFT_ZERO_FILLS\r
-Meaning: To be defined iff i>>j does not extend the sign bit when i is a\r
- signed integral type and i < 0.\r
-Used in: Py_ARITHMETIC_RIGHT_SHIFT\r
-\r
-Py_DEBUG\r
-Meaning: Extra checks compiled in for debug mode.\r
-Used in: Py_SAFE_DOWNCAST\r
-\r
-HAVE_UINTPTR_T\r
-Meaning: The C9X type uintptr_t is supported by the compiler\r
-Used in: Py_uintptr_t\r
-\r
-HAVE_LONG_LONG\r
-Meaning: The compiler supports the C type "long long"\r
-Used in: PY_LONG_LONG\r
-\r
-**************************************************************************/\r
-\r
-\r
-/* For backward compatibility only. Obsolete, do not use. */\r
-#ifdef HAVE_PROTOTYPES\r
-#define Py_PROTO(x) x\r
-#else\r
-#define Py_PROTO(x) ()\r
-#endif\r
-#ifndef Py_FPROTO\r
-#define Py_FPROTO(x) Py_PROTO(x)\r
-#endif\r
-\r
-/* typedefs for some C9X-defined synonyms for integral types.\r
- *\r
- * The names in Python are exactly the same as the C9X names, except with a\r
- * Py_ prefix. Until C9X is universally implemented, this is the only way\r
- * to ensure that Python gets reliable names that don't conflict with names\r
- * in non-Python code that are playing their own tricks to define the C9X\r
- * names.\r
- *\r
- * NOTE: don't go nuts here! Python has no use for *most* of the C9X\r
- * integral synonyms. Only define the ones we actually need.\r
- */\r
-\r
-#ifdef HAVE_LONG_LONG\r
-#ifndef PY_LONG_LONG\r
-#define PY_LONG_LONG long long\r
-#if defined(LLONG_MAX)\r
-/* If LLONG_MAX is defined in limits.h, use that. */\r
-#define PY_LLONG_MIN LLONG_MIN\r
-#define PY_LLONG_MAX LLONG_MAX\r
-#define PY_ULLONG_MAX ULLONG_MAX\r
-#elif defined(__LONG_LONG_MAX__)\r
-/* Otherwise, if GCC has a builtin define, use that. */\r
-#define PY_LLONG_MAX __LONG_LONG_MAX__\r
-#define PY_LLONG_MIN (-PY_LLONG_MAX-1)\r
-#define PY_ULLONG_MAX (__LONG_LONG_MAX__*2ULL + 1ULL)\r
-#else\r
-/* Otherwise, rely on two's complement. */\r
-#define PY_ULLONG_MAX (~0ULL)\r
-#define PY_LLONG_MAX ((long long)(PY_ULLONG_MAX>>1))\r
-#define PY_LLONG_MIN (-PY_LLONG_MAX-1)\r
-#endif /* LLONG_MAX */\r
-#endif\r
-#endif /* HAVE_LONG_LONG */\r
-\r
-/* a build with 30-bit digits for Python long integers needs an exact-width\r
- * 32-bit unsigned integer type to store those digits. (We could just use\r
- * type 'unsigned long', but that would be wasteful on a system where longs\r
- * are 64-bits.) On Unix systems, the autoconf macro AC_TYPE_UINT32_T defines\r
- * uint32_t to be such a type unless stdint.h or inttypes.h defines uint32_t.\r
- * However, it doesn't set HAVE_UINT32_T, so we do that here.\r
- */\r
-#if (defined UINT32_MAX || defined uint32_t)\r
-#ifndef PY_UINT32_T\r
-#define HAVE_UINT32_T 1\r
-#define PY_UINT32_T uint32_t\r
-#endif\r
-#endif\r
-\r
-/* Macros for a 64-bit unsigned integer type; used for type 'twodigits' in the\r
- * long integer implementation, when 30-bit digits are enabled.\r
- */\r
-#if (defined UINT64_MAX || defined uint64_t)\r
-#ifndef PY_UINT64_T\r
-#define HAVE_UINT64_T 1\r
-#define PY_UINT64_T uint64_t\r
-#endif\r
-#endif\r
-\r
-/* Signed variants of the above */\r
-#if (defined INT32_MAX || defined int32_t)\r
-#ifndef PY_INT32_T\r
-#define HAVE_INT32_T 1\r
-#define PY_INT32_T int32_t\r
-#endif\r
-#endif\r
-#if (defined INT64_MAX || defined int64_t)\r
-#ifndef PY_INT64_T\r
-#define HAVE_INT64_T 1\r
-#define PY_INT64_T int64_t\r
-#endif\r
-#endif\r
-\r
-/* If PYLONG_BITS_IN_DIGIT is not defined then we'll use 30-bit digits if all\r
- the necessary integer types are available, and we're on a 64-bit platform\r
- (as determined by SIZEOF_VOID_P); otherwise we use 15-bit digits. */\r
-\r
-#ifndef PYLONG_BITS_IN_DIGIT\r
-#if (defined HAVE_UINT64_T && defined HAVE_INT64_T && \\r
- defined HAVE_UINT32_T && defined HAVE_INT32_T && SIZEOF_VOID_P >= 8)\r
-#define PYLONG_BITS_IN_DIGIT 30\r
-#else\r
-#define PYLONG_BITS_IN_DIGIT 15\r
-#endif\r
-#endif\r
-\r
-/* uintptr_t is the C9X name for an unsigned integral type such that a\r
- * legitimate void* can be cast to uintptr_t and then back to void* again\r
- * without loss of information. Similarly for intptr_t, wrt a signed\r
- * integral type.\r
- */\r
-#ifdef HAVE_UINTPTR_T\r
-typedef uintptr_t Py_uintptr_t;\r
-typedef intptr_t Py_intptr_t;\r
-\r
-#elif SIZEOF_VOID_P <= SIZEOF_INT\r
-typedef unsigned int Py_uintptr_t;\r
-typedef int Py_intptr_t;\r
-\r
-#elif SIZEOF_VOID_P <= SIZEOF_LONG\r
-typedef unsigned long Py_uintptr_t;\r
-typedef long Py_intptr_t;\r
-\r
-#elif defined(HAVE_LONG_LONG) && (SIZEOF_VOID_P <= SIZEOF_LONG_LONG)\r
-typedef unsigned PY_LONG_LONG Py_uintptr_t;\r
-typedef PY_LONG_LONG Py_intptr_t;\r
-\r
-#else\r
-# error "Python needs a typedef for Py_uintptr_t in pyport.h."\r
-#endif /* HAVE_UINTPTR_T */\r
-\r
-/* Py_ssize_t is a signed integral type such that sizeof(Py_ssize_t) ==\r
- * sizeof(size_t). C99 doesn't define such a thing directly (size_t is an\r
- * unsigned integral type). See PEP 353 for details.\r
- */\r
-#ifdef HAVE_SSIZE_T\r
-typedef ssize_t Py_ssize_t;\r
-#elif SIZEOF_VOID_P == SIZEOF_SIZE_T\r
-typedef Py_intptr_t Py_ssize_t;\r
-#else\r
-# error "Python needs a typedef for Py_ssize_t in pyport.h."\r
-#endif\r
-\r
-/* Largest possible value of size_t.\r
- SIZE_MAX is part of C99, so it might be defined on some\r
- platforms. If it is not defined, (size_t)-1 is a portable\r
- definition for C89, due to the way signed->unsigned\r
- conversion is defined. */\r
-#ifdef SIZE_MAX\r
-#define PY_SIZE_MAX SIZE_MAX\r
-#else\r
-#define PY_SIZE_MAX ((size_t)-1)\r
-#endif\r
-\r
-/* Largest positive value of type Py_ssize_t. */\r
-#define PY_SSIZE_T_MAX ((Py_ssize_t)(((size_t)-1)>>1))\r
-/* Smallest negative value of type Py_ssize_t. */\r
-#define PY_SSIZE_T_MIN (-PY_SSIZE_T_MAX-1)\r
-\r
-#if SIZEOF_PID_T > SIZEOF_LONG\r
-# error "Python doesn't support sizeof(pid_t) > sizeof(long)"\r
-#endif\r
-\r
-/* PY_FORMAT_SIZE_T is a platform-specific modifier for use in a printf\r
- * format to convert an argument with the width of a size_t or Py_ssize_t.\r
- * C99 introduced "z" for this purpose, but not all platforms support that;\r
- * e.g., MS compilers use "I" instead.\r
- *\r
- * These "high level" Python format functions interpret "z" correctly on\r
- * all platforms (Python interprets the format string itself, and does whatever\r
- * the platform C requires to convert a size_t/Py_ssize_t argument):\r
- *\r
- * PyString_FromFormat\r
- * PyErr_Format\r
- * PyString_FromFormatV\r
- *\r
- * Lower-level uses require that you interpolate the correct format modifier\r
- * yourself (e.g., calling printf, fprintf, sprintf, PyOS_snprintf); for\r
- * example,\r
- *\r
- * Py_ssize_t index;\r
- * fprintf(stderr, "index %" PY_FORMAT_SIZE_T "d sucks\n", index);\r
- *\r
- * That will expand to %ld, or %Id, or to something else correct for a\r
- * Py_ssize_t on the platform.\r
- */\r
-#ifndef PY_FORMAT_SIZE_T\r
-# if SIZEOF_SIZE_T == SIZEOF_INT && !defined(__APPLE__)\r
-# define PY_FORMAT_SIZE_T ""\r
-# elif SIZEOF_SIZE_T == SIZEOF_LONG\r
-# define PY_FORMAT_SIZE_T "l"\r
-# elif defined(MS_WINDOWS)\r
-# define PY_FORMAT_SIZE_T "I"\r
-# else\r
-# error "This platform's pyconfig.h needs to define PY_FORMAT_SIZE_T"\r
-# endif\r
-#endif\r
-\r
-/* PY_FORMAT_LONG_LONG is analogous to PY_FORMAT_SIZE_T above, but for\r
- * the long long type instead of the size_t type. It's only available\r
- * when HAVE_LONG_LONG is defined. The "high level" Python format\r
- * functions listed above will interpret "lld" or "llu" correctly on\r
- * all platforms.\r
- */\r
-#ifdef HAVE_LONG_LONG\r
-# ifndef PY_FORMAT_LONG_LONG\r
-# if defined(MS_WIN64) || defined(MS_WINDOWS)\r
-# define PY_FORMAT_LONG_LONG "I64"\r
-# else\r
-# error "This platform's pyconfig.h needs to define PY_FORMAT_LONG_LONG"\r
-# endif\r
-# endif\r
-#endif\r
-\r
-/* Py_LOCAL can be used instead of static to get the fastest possible calling\r
- * convention for functions that are local to a given module.\r
- *\r
- * Py_LOCAL_INLINE does the same thing, and also explicitly requests inlining,\r
- * for platforms that support that.\r
- *\r
- * If PY_LOCAL_AGGRESSIVE is defined before python.h is included, more\r
- * "aggressive" inlining/optimizaion is enabled for the entire module. This\r
- * may lead to code bloat, and may slow things down for those reasons. It may\r
- * also lead to errors, if the code relies on pointer aliasing. Use with\r
- * care.\r
- *\r
- * NOTE: You can only use this for functions that are entirely local to a\r
- * module; functions that are exported via method tables, callbacks, etc,\r
- * should keep using static.\r
- */\r
-\r
-#undef USE_INLINE /* XXX - set via configure? */\r
-\r
-#if defined(_MSC_VER)\r
-#if defined(PY_LOCAL_AGGRESSIVE)\r
-/* enable more aggressive optimization for visual studio */\r
-//#pragma optimize("agtw", on)\r
-#pragma optimize("gt", on) // a and w are not legal for VS2005\r
-#endif\r
-/* ignore warnings if the compiler decides not to inline a function */\r
-#pragma warning(disable: 4710)\r
-/* fastest possible local call under MSVC */\r
-#define Py_LOCAL(type) static type __fastcall\r
-#define Py_LOCAL_INLINE(type) static __inline type __fastcall\r
-#elif defined(USE_INLINE)\r
-#define Py_LOCAL(type) static type\r
-#define Py_LOCAL_INLINE(type) static inline type\r
-#else\r
-#define Py_LOCAL(type) static type\r
-#define Py_LOCAL_INLINE(type) static type\r
-#endif\r
-\r
-/* Py_MEMCPY can be used instead of memcpy in cases where the copied blocks\r
- * are often very short. While most platforms have highly optimized code for\r
- * large transfers, the setup costs for memcpy are often quite high. MEMCPY\r
- * solves this by doing short copies "in line".\r
- */\r
-\r
-#if defined(_MSC_VER)\r
-#define Py_MEMCPY(target, source, length) do { \\r
- size_t i_, n_ = (length); \\r
- char *t_ = (void*) (target); \\r
- const char *s_ = (void*) (source); \\r
- if (n_ >= 16) \\r
- memcpy(t_, s_, n_); \\r
- else \\r
- for (i_ = 0; i_ < n_; i_++) \\r
- t_[i_] = s_[i_]; \\r
- } while (0)\r
-#else\r
-#define Py_MEMCPY memcpy\r
-#endif\r
-\r
-#include <stdlib.h>\r
-\r
-#ifdef HAVE_IEEEFP_H\r
-#include <ieeefp.h> /* needed for 'finite' declaration on some platforms */\r
-#endif\r
-\r
-#include <math.h> /* Moved here from the math section, before extern "C" */\r
-\r
-/********************************************\r
- * WRAPPER FOR <time.h> and/or <sys/time.h> *\r
- ********************************************/\r
-\r
-#ifdef TIME_WITH_SYS_TIME\r
-#include <sys/time.h>\r
-#include <time.h>\r
-#else /* !TIME_WITH_SYS_TIME */\r
-#ifdef HAVE_SYS_TIME_H\r
-#include <sys/time.h>\r
-#else /* !HAVE_SYS_TIME_H */\r
-#include <time.h>\r
-#endif /* !HAVE_SYS_TIME_H */\r
-#endif /* !TIME_WITH_SYS_TIME */\r
-\r
-\r
-/******************************\r
- * WRAPPER FOR <sys/select.h> *\r
- ******************************/\r
-\r
-/* NB caller must include <sys/types.h> */\r
-\r
-#ifdef HAVE_SYS_SELECT_H\r
-\r
-#include <sys/select.h>\r
-\r
-#endif /* !HAVE_SYS_SELECT_H */\r
-\r
-/*******************************\r
- * stat() and fstat() fiddling *\r
- *******************************/\r
-\r
-/* We expect that stat and fstat exist on most systems.\r
- * It's confirmed on Unix, Mac and Windows.\r
- * If you don't have them, add\r
- * #define DONT_HAVE_STAT\r
- * and/or\r
- * #define DONT_HAVE_FSTAT\r
- * to your pyconfig.h. Python code beyond this should check HAVE_STAT and\r
- * HAVE_FSTAT instead.\r
- * Also\r
- * #define HAVE_SYS_STAT_H\r
- * if <sys/stat.h> exists on your platform, and\r
- * #define HAVE_STAT_H\r
- * if <stat.h> does.\r
- */\r
-#ifndef DONT_HAVE_STAT\r
-#define HAVE_STAT\r
-#endif\r
-\r
-#ifndef DONT_HAVE_FSTAT\r
-#define HAVE_FSTAT\r
-#endif\r
-\r
-#ifdef RISCOS\r
-#include <sys/types.h>\r
-#include "unixstuff.h"\r
-#endif\r
-\r
-#ifdef HAVE_SYS_STAT_H\r
-#if defined(PYOS_OS2) && defined(PYCC_GCC)\r
-#include <sys/types.h>\r
-#endif\r
-#include <sys/stat.h>\r
-#elif defined(HAVE_STAT_H)\r
-#include <stat.h>\r
-#endif\r
-\r
-#if defined(PYCC_VACPP)\r
-/* VisualAge C/C++ Failed to Define MountType Field in sys/stat.h */\r
-#define S_IFMT (S_IFDIR|S_IFCHR|S_IFREG)\r
-#endif\r
-\r
-#ifndef S_ISREG\r
-#define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)\r
-#endif\r
-\r
-#ifndef S_ISDIR\r
-#define S_ISDIR(x) (((x) & S_IFMT) == S_IFDIR)\r
-#endif\r
-\r
-\r
-#ifdef __cplusplus\r
-/* Move this down here since some C++ #include's don't like to be included\r
- inside an extern "C" */\r
-extern "C" {\r
-#endif\r
-\r
-\r
-/* Py_ARITHMETIC_RIGHT_SHIFT\r
- * C doesn't define whether a right-shift of a signed integer sign-extends\r
- * or zero-fills. Here a macro to force sign extension:\r
- * Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J)\r
- * Return I >> J, forcing sign extension. Arithmetically, return the\r
- * floor of I/2**J.\r
- * Requirements:\r
- * I should have signed integer type. In the terminology of C99, this can\r
- * be either one of the five standard signed integer types (signed char,\r
- * short, int, long, long long) or an extended signed integer type.\r
- * J is an integer >= 0 and strictly less than the number of bits in the\r
- * type of I (because C doesn't define what happens for J outside that\r
- * range either).\r
- * TYPE used to specify the type of I, but is now ignored. It's been left\r
- * in for backwards compatibility with versions <= 2.6 or 3.0.\r
- * Caution:\r
- * I may be evaluated more than once.\r
- */\r
-#ifdef SIGNED_RIGHT_SHIFT_ZERO_FILLS\r
-#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) \\r
- ((I) < 0 ? -1-((-1-(I)) >> (J)) : (I) >> (J))\r
-#else\r
-#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) ((I) >> (J))\r
-#endif\r
-\r
-/* Py_FORCE_EXPANSION(X)\r
- * "Simply" returns its argument. However, macro expansions within the\r
- * argument are evaluated. This unfortunate trickery is needed to get\r
- * token-pasting to work as desired in some cases.\r
- */\r
-#define Py_FORCE_EXPANSION(X) X\r
-\r
-/* Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW)\r
- * Cast VALUE to type NARROW from type WIDE. In Py_DEBUG mode, this\r
- * assert-fails if any information is lost.\r
- * Caution:\r
- * VALUE may be evaluated more than once.\r
- */\r
-#ifdef Py_DEBUG\r
-#define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) \\r
- (assert((WIDE)(NARROW)(VALUE) == (VALUE)), (NARROW)(VALUE))\r
-#else\r
-#define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) (NARROW)(VALUE)\r
-#endif\r
-\r
-/* Py_SET_ERRNO_ON_MATH_ERROR(x)\r
- * If a libm function did not set errno, but it looks like the result\r
- * overflowed or not-a-number, set errno to ERANGE or EDOM. Set errno\r
- * to 0 before calling a libm function, and invoke this macro after,\r
- * passing the function result.\r
- * Caution:\r
- * This isn't reliable. See Py_OVERFLOWED comments.\r
- * X is evaluated more than once.\r
- */\r
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || (defined(__hpux) && defined(__ia64))\r
-#define _Py_SET_EDOM_FOR_NAN(X) if (isnan(X)) errno = EDOM;\r
-#else\r
-#define _Py_SET_EDOM_FOR_NAN(X) ;\r
-#endif\r
-#define Py_SET_ERRNO_ON_MATH_ERROR(X) \\r
- do { \\r
- if (errno == 0) { \\r
- if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \\r
- errno = ERANGE; \\r
- else _Py_SET_EDOM_FOR_NAN(X) \\r
- } \\r
- } while(0)\r
-\r
-/* Py_SET_ERANGE_ON_OVERFLOW(x)\r
- * An alias of Py_SET_ERRNO_ON_MATH_ERROR for backward-compatibility.\r
- */\r
-#define Py_SET_ERANGE_IF_OVERFLOW(X) Py_SET_ERRNO_ON_MATH_ERROR(X)\r
-\r
-/* Py_ADJUST_ERANGE1(x)\r
- * Py_ADJUST_ERANGE2(x, y)\r
- * Set errno to 0 before calling a libm function, and invoke one of these\r
- * macros after, passing the function result(s) (Py_ADJUST_ERANGE2 is useful\r
- * for functions returning complex results). This makes two kinds of\r
- * adjustments to errno: (A) If it looks like the platform libm set\r
- * errno=ERANGE due to underflow, clear errno. (B) If it looks like the\r
- * platform libm overflowed but didn't set errno, force errno to ERANGE. In\r
- * effect, we're trying to force a useful implementation of C89 errno\r
- * behavior.\r
- * Caution:\r
- * This isn't reliable. See Py_OVERFLOWED comments.\r
- * X and Y may be evaluated more than once.\r
- */\r
-#define Py_ADJUST_ERANGE1(X) \\r
- do { \\r
- if (errno == 0) { \\r
- if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \\r
- errno = ERANGE; \\r
- } \\r
- else if (errno == ERANGE && (X) == 0.0) \\r
- errno = 0; \\r
- } while(0)\r
-\r
-#define Py_ADJUST_ERANGE2(X, Y) \\r
- do { \\r
- if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL || \\r
- (Y) == Py_HUGE_VAL || (Y) == -Py_HUGE_VAL) { \\r
- if (errno == 0) \\r
- errno = ERANGE; \\r
- } \\r
- else if (errno == ERANGE) \\r
- errno = 0; \\r
- } while(0)\r
-\r
-/* The functions _Py_dg_strtod and _Py_dg_dtoa in Python/dtoa.c (which are\r
- * required to support the short float repr introduced in Python 3.1) require\r
- * that the floating-point unit that's being used for arithmetic operations\r
- * on C doubles is set to use 53-bit precision. It also requires that the\r
- * FPU rounding mode is round-half-to-even, but that's less often an issue.\r
- *\r
- * If your FPU isn't already set to 53-bit precision/round-half-to-even, and\r
- * you want to make use of _Py_dg_strtod and _Py_dg_dtoa, then you should\r
- *\r
- * #define HAVE_PY_SET_53BIT_PRECISION 1\r
- *\r
- * and also give appropriate definitions for the following three macros:\r
- *\r
- * _PY_SET_53BIT_PRECISION_START : store original FPU settings, and\r
- * set FPU to 53-bit precision/round-half-to-even\r
- * _PY_SET_53BIT_PRECISION_END : restore original FPU settings\r
- * _PY_SET_53BIT_PRECISION_HEADER : any variable declarations needed to\r
- * use the two macros above.\r
- *\r
- * The macros are designed to be used within a single C function: see\r
- * Python/pystrtod.c for an example of their use.\r
- */\r
-\r
-/* get and set x87 control word for gcc/x86 */\r
-#ifdef HAVE_GCC_ASM_FOR_X87\r
-#define HAVE_PY_SET_53BIT_PRECISION 1\r
-/* _Py_get/set_387controlword functions are defined in Python/pymath.c */\r
-#define _Py_SET_53BIT_PRECISION_HEADER \\r
- unsigned short old_387controlword, new_387controlword\r
-#define _Py_SET_53BIT_PRECISION_START \\r
- do { \\r
- old_387controlword = _Py_get_387controlword(); \\r
- new_387controlword = (old_387controlword & ~0x0f00) | 0x0200; \\r
- if (new_387controlword != old_387controlword) \\r
- _Py_set_387controlword(new_387controlword); \\r
- } while (0)\r
-#define _Py_SET_53BIT_PRECISION_END \\r
- if (new_387controlword != old_387controlword) \\r
- _Py_set_387controlword(old_387controlword)\r
-#endif\r
-\r
-/* default definitions are empty */\r
-#ifndef HAVE_PY_SET_53BIT_PRECISION\r
-#define _Py_SET_53BIT_PRECISION_HEADER\r
-#define _Py_SET_53BIT_PRECISION_START\r
-#define _Py_SET_53BIT_PRECISION_END\r
-#endif\r
-\r
-/* If we can't guarantee 53-bit precision, don't use the code\r
- in Python/dtoa.c, but fall back to standard code. This\r
- means that repr of a float will be long (17 sig digits).\r
-\r
- Realistically, there are two things that could go wrong:\r
-\r
- (1) doubles aren't IEEE 754 doubles, or\r
- (2) we're on x86 with the rounding precision set to 64-bits\r
- (extended precision), and we don't know how to change\r
- the rounding precision.\r
- */\r
-\r
-#if !defined(DOUBLE_IS_LITTLE_ENDIAN_IEEE754) && \\r
- !defined(DOUBLE_IS_BIG_ENDIAN_IEEE754) && \\r
- !defined(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754)\r
-#define PY_NO_SHORT_FLOAT_REPR\r
-#endif\r
-\r
-/* double rounding is symptomatic of use of extended precision on x86. If\r
- we're seeing double rounding, and we don't have any mechanism available for\r
- changing the FPU rounding precision, then don't use Python/dtoa.c. */\r
-#if defined(X87_DOUBLE_ROUNDING) && !defined(HAVE_PY_SET_53BIT_PRECISION)\r
-#define PY_NO_SHORT_FLOAT_REPR\r
-#endif\r
-\r
-/* Py_DEPRECATED(version)\r
- * Declare a variable, type, or function deprecated.\r
- * Usage:\r
- * extern int old_var Py_DEPRECATED(2.3);\r
- * typedef int T1 Py_DEPRECATED(2.4);\r
- * extern int x() Py_DEPRECATED(2.5);\r
- */\r
-#if defined(__GNUC__) && ((__GNUC__ >= 4) || \\r
- (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))\r
-#define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__))\r
-#else\r
-#define Py_DEPRECATED(VERSION_UNUSED)\r
-#endif\r
-\r
-/**************************************************************************\r
-Prototypes that are missing from the standard include files on some systems\r
-(and possibly only some versions of such systems.)\r
-\r
-Please be conservative with adding new ones, document them and enclose them\r
-in platform-specific #ifdefs.\r
-**************************************************************************/\r
-\r
-#ifdef SOLARIS\r
-/* Unchecked */\r
-extern int gethostname(char *, int);\r
-#endif\r
-\r
-#ifdef __BEOS__\r
-/* Unchecked */\r
-/* It's in the libs, but not the headers... - [cjh] */\r
-int shutdown( int, int );\r
-#endif\r
-\r
-#ifdef HAVE__GETPTY\r
-#include <sys/types.h> /* we need to import mode_t */\r
-extern char * _getpty(int *, int, mode_t, int);\r
-#endif\r
-\r
-/* On QNX 6, struct termio must be declared by including sys/termio.h\r
- if TCGETA, TCSETA, TCSETAW, or TCSETAF are used. sys/termio.h must\r
- be included before termios.h or it will generate an error. */\r
-#ifdef HAVE_SYS_TERMIO_H\r
-#include <sys/termio.h>\r
-#endif\r
-\r
-#if defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY)\r
-#if !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H) && !defined(HAVE_UTIL_H)\r
-/* BSDI does not supply a prototype for the 'openpty' and 'forkpty'\r
- functions, even though they are included in libutil. */\r
-#include <termios.h>\r
-extern int openpty(int *, int *, char *, struct termios *, struct winsize *);\r
-extern pid_t forkpty(int *, char *, struct termios *, struct winsize *);\r
-#endif /* !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H) */\r
-#endif /* defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) */\r
-\r
-\r
-/* These are pulled from various places. It isn't obvious on what platforms\r
- they are necessary, nor what the exact prototype should look like (which\r
- is likely to vary between platforms!) If you find you need one of these\r
- declarations, please move them to a platform-specific block and include\r
- proper prototypes. */\r
-#if 0\r
-\r
-/* From Modules/resource.c */\r
-extern int getrusage();\r
-extern int getpagesize();\r
-\r
-/* From Python/sysmodule.c and Modules/posixmodule.c */\r
-extern int fclose(FILE *);\r
-\r
-/* From Modules/posixmodule.c */\r
-extern int fdatasync(int);\r
-#endif /* 0 */\r
-\r
-\r
-/* On 4.4BSD-descendants, ctype functions serves the whole range of\r
- * wchar_t character set rather than single byte code points only.\r
- * This characteristic can break some operations of string object\r
- * including str.upper() and str.split() on UTF-8 locales. This\r
- * workaround was provided by Tim Robbins of FreeBSD project.\r
- */\r
-\r
-#ifdef __FreeBSD__\r
-#include <osreldate.h>\r
-#if __FreeBSD_version > 500039\r
-# define _PY_PORT_CTYPE_UTF8_ISSUE\r
-#endif\r
-#endif\r
-\r
-\r
-#if defined(__APPLE__)\r
-# define _PY_PORT_CTYPE_UTF8_ISSUE\r
-#endif\r
-\r
-#ifdef _PY_PORT_CTYPE_UTF8_ISSUE\r
-#include <ctype.h>\r
-#include <wctype.h>\r
-#undef isalnum\r
-#define isalnum(c) iswalnum(btowc(c))\r
-#undef isalpha\r
-#define isalpha(c) iswalpha(btowc(c))\r
-#undef islower\r
-#define islower(c) iswlower(btowc(c))\r
-#undef isspace\r
-#define isspace(c) iswspace(btowc(c))\r
-#undef isupper\r
-#define isupper(c) iswupper(btowc(c))\r
-#undef tolower\r
-#define tolower(c) towlower(btowc(c))\r
-#undef toupper\r
-#define toupper(c) towupper(btowc(c))\r
-#endif\r
-\r
-\r
-/* Declarations for symbol visibility.\r
-\r
- PyAPI_FUNC(type): Declares a public Python API function and return type\r
- PyAPI_DATA(type): Declares public Python data and its type\r
- PyMODINIT_FUNC: A Python module init function. If these functions are\r
- inside the Python core, they are private to the core.\r
- If in an extension module, it may be declared with\r
- external linkage depending on the platform.\r
-\r
- As a number of platforms support/require "__declspec(dllimport/dllexport)",\r
- we support a HAVE_DECLSPEC_DLL macro to save duplication.\r
-*/\r
-\r
-/*\r
- All windows ports, except cygwin, are handled in PC/pyconfig.h.\r
-\r
- BeOS and cygwin are the only other autoconf platform requiring special\r
- linkage handling and both of these use __declspec().\r
-*/\r
-#if defined(__CYGWIN__) || defined(__BEOS__)\r
-# define HAVE_DECLSPEC_DLL\r
-#endif\r
-\r
-/* only get special linkage if built as shared or platform is Cygwin */\r
-#if defined(Py_ENABLE_SHARED) || defined(__CYGWIN__)\r
-# if defined(HAVE_DECLSPEC_DLL)\r
-# ifdef Py_BUILD_CORE\r
-# define PyAPI_FUNC(RTYPE) __declspec(dllexport) RTYPE\r
-# define PyAPI_DATA(RTYPE) extern __declspec(dllexport) RTYPE\r
- /* module init functions inside the core need no external linkage */\r
- /* except for Cygwin to handle embedding (FIXME: BeOS too?) */\r
-# if defined(__CYGWIN__)\r
-# define PyMODINIT_FUNC __declspec(dllexport) void\r
-# else /* __CYGWIN__ */\r
-# define PyMODINIT_FUNC void\r
-# endif /* __CYGWIN__ */\r
-# else /* Py_BUILD_CORE */\r
- /* Building an extension module, or an embedded situation */\r
- /* public Python functions and data are imported */\r
- /* Under Cygwin, auto-import functions to prevent compilation */\r
- /* failures similar to those described at the bottom of 4.1: */\r
- /* http://docs.python.org/extending/windows.html#a-cookbook-approach */\r
-# if !defined(__CYGWIN__)\r
-# define PyAPI_FUNC(RTYPE) __declspec(dllimport) RTYPE\r
-# endif /* !__CYGWIN__ */\r
-# define PyAPI_DATA(RTYPE) extern __declspec(dllimport) RTYPE\r
- /* module init functions outside the core must be exported */\r
-# if defined(__cplusplus)\r
-# define PyMODINIT_FUNC extern "C" __declspec(dllexport) void\r
-# else /* __cplusplus */\r
-# define PyMODINIT_FUNC __declspec(dllexport) void\r
-# endif /* __cplusplus */\r
-# endif /* Py_BUILD_CORE */\r
-# endif /* HAVE_DECLSPEC */\r
-#endif /* Py_ENABLE_SHARED */\r
-\r
-/* If no external linkage macros defined by now, create defaults */\r
-#ifndef PyAPI_FUNC\r
-# define PyAPI_FUNC(RTYPE) RTYPE\r
-#endif\r
-#ifndef PyAPI_DATA\r
-# define PyAPI_DATA(RTYPE) extern RTYPE\r
-#endif\r
-#ifndef PyMODINIT_FUNC\r
-# if defined(__cplusplus)\r
-# define PyMODINIT_FUNC extern "C" void\r
-# else /* __cplusplus */\r
-# define PyMODINIT_FUNC void\r
-# endif /* __cplusplus */\r
-#endif\r
-\r
-/* Deprecated DL_IMPORT and DL_EXPORT macros */\r
-#if defined(Py_ENABLE_SHARED) && defined (HAVE_DECLSPEC_DLL)\r
-# if defined(Py_BUILD_CORE)\r
-# define DL_IMPORT(RTYPE) __declspec(dllexport) RTYPE\r
-# define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE\r
-# else\r
-# define DL_IMPORT(RTYPE) __declspec(dllimport) RTYPE\r
-# define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE\r
-# endif\r
-#endif\r
-#ifndef DL_EXPORT\r
-# define DL_EXPORT(RTYPE) RTYPE\r
-#endif\r
-#ifndef DL_IMPORT\r
-# define DL_IMPORT(RTYPE) RTYPE\r
-#endif\r
-/* End of deprecated DL_* macros */\r
-\r
-/* If the fd manipulation macros aren't defined,\r
- here is a set that should do the job */\r
-\r
-#if 0 /* disabled and probably obsolete */\r
-\r
-#ifndef FD_SETSIZE\r
-#define FD_SETSIZE 256\r
-#endif\r
-\r
-#ifndef FD_SET\r
-\r
-typedef long fd_mask;\r
-\r
-#define NFDBITS (sizeof(fd_mask) * NBBY) /* bits per mask */\r
-#ifndef howmany\r
-#define howmany(x, y) (((x)+((y)-1))/(y))\r
-#endif /* howmany */\r
-\r
-typedef struct fd_set {\r
- fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)];\r
-} fd_set;\r
-\r
-#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))\r
-#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))\r
-#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))\r
-#define FD_ZERO(p) memset((char *)(p), '\0', sizeof(*(p)))\r
-\r
-#endif /* FD_SET */\r
-\r
-#endif /* fd manipulation macros */\r
-\r
-\r
-/* limits.h constants that may be missing */\r
-\r
-#ifndef INT_MAX\r
-#define INT_MAX 2147483647\r
-#endif\r
-\r
-#ifndef LONG_MAX\r
-#if SIZEOF_LONG == 4\r
-#define LONG_MAX 0X7FFFFFFFL\r
-#elif SIZEOF_LONG == 8\r
-#define LONG_MAX 0X7FFFFFFFFFFFFFFFL\r
-#else\r
-#error "could not set LONG_MAX in pyport.h"\r
-#endif\r
-#endif\r
-\r
-#ifndef LONG_MIN\r
-#define LONG_MIN (-LONG_MAX-1)\r
-#endif\r
-\r
-#ifndef LONG_BIT\r
-#define LONG_BIT (8 * SIZEOF_LONG)\r
-#endif\r
-\r
-#if LONG_BIT != 8 * SIZEOF_LONG\r
-/* 04-Oct-2000 LONG_BIT is apparently (mis)defined as 64 on some recent\r
- * 32-bit platforms using gcc. We try to catch that here at compile-time\r
- * rather than waiting for integer multiplication to trigger bogus\r
- * overflows.\r
- */\r
-#error "LONG_BIT definition appears wrong for platform (bad gcc/glibc config?)."\r
-#endif\r
-\r
-#ifdef __cplusplus\r
-}\r
-#endif\r
-\r
-/*\r
- * Hide GCC attributes from compilers that don't support them.\r
- */\r
-#if (!defined(__GNUC__) || __GNUC__ < 2 || \\r
- (__GNUC__ == 2 && __GNUC_MINOR__ < 7) ) && \\r
- !defined(RISCOS)\r
-#define Py_GCC_ATTRIBUTE(x)\r
-#else\r
-#define Py_GCC_ATTRIBUTE(x) __attribute__(x)\r
-#endif\r
-\r
-/*\r
- * Add PyArg_ParseTuple format where available.\r
- */\r
-#ifdef HAVE_ATTRIBUTE_FORMAT_PARSETUPLE\r
-#define Py_FORMAT_PARSETUPLE(func,p1,p2) __attribute__((format(func,p1,p2)))\r
-#else\r
-#define Py_FORMAT_PARSETUPLE(func,p1,p2)\r
-#endif\r
-\r
-/*\r
- * Specify alignment on compilers that support it.\r
- */\r
-#if defined(__GNUC__) && __GNUC__ >= 3\r
-#define Py_ALIGNED(x) __attribute__((aligned(x)))\r
-#else\r
-#define Py_ALIGNED(x)\r
-#endif\r
-\r
-/* Eliminate end-of-loop code not reached warnings from SunPro C\r
- * when using do{...}while(0) macros\r
- */\r
-#ifdef __SUNPRO_C\r
-#pragma error_messages (off,E_END_OF_LOOP_CODE_NOT_REACHED)\r
-#endif\r
-\r
-/*\r
- * Older Microsoft compilers don't support the C99 long long literal suffixes,\r
- * so these will be defined in PC/pyconfig.h for those compilers.\r
- */\r
-#ifndef Py_LL\r
-#define Py_LL(x) x##LL\r
-#endif\r
-\r
-#ifndef Py_ULL\r
-#define Py_ULL(x) Py_LL(x##U)\r
-#endif\r
-\r
-#endif /* Py_PYPORT_H */\r
+++ /dev/null
-/*\r
- * Secret Labs' Regular Expression Engine\r
- *\r
- * regular expression matching engine\r
- *\r
- * partial history:\r
- * 1999-10-24 fl created (based on existing template matcher code)\r
- * 2000-03-06 fl first alpha, sort of\r
- * 2000-08-01 fl fixes for 1.6b1\r
- * 2000-08-07 fl use PyOS_CheckStack() if available\r
- * 2000-09-20 fl added expand method\r
- * 2001-03-20 fl lots of fixes for 2.1b2\r
- * 2001-04-15 fl export copyright as Python attribute, not global\r
- * 2001-04-28 fl added __copy__ methods (work in progress)\r
- * 2001-05-14 fl fixes for 1.5.2 compatibility\r
- * 2001-07-01 fl added BIGCHARSET support (from Martin von Loewis)\r
- * 2001-10-18 fl fixed group reset issue (from Matthew Mueller)\r
- * 2001-10-20 fl added split primitive; reenable unicode for 1.6/2.0/2.1\r
- * 2001-10-21 fl added sub/subn primitive\r
- * 2001-10-24 fl added finditer primitive (for 2.2 only)\r
- * 2001-12-07 fl fixed memory leak in sub/subn (Guido van Rossum)\r
- * 2002-11-09 fl fixed empty sub/subn return type\r
- * 2003-04-18 mvl fully support 4-byte codes\r
- * 2003-10-17 gn implemented non recursive scheme\r
- *\r
- * Copyright (c) 1997-2001 by Secret Labs AB. All rights reserved.\r
- *\r
- * This version of the SRE library can be redistributed under CNRI's\r
- * Python 1.6 license. For any other use, please contact Secret Labs\r
- * AB (info@pythonware.com).\r
- *\r
- * Portions of this engine have been developed in cooperation with\r
- * CNRI. Hewlett-Packard provided funding for 1.6 integration and\r
- * other compatibility work.\r
- */\r
-\r
-/* Get rid of these macros to prevent collisions between EFI and Python in this file. */\r
-#undef RETURN_ERROR\r
-#undef RETURN_SUCCESS\r
-\r
-#ifndef SRE_RECURSIVE\r
-\r
-static char copyright[] =\r
- " SRE 2.2.2 Copyright (c) 1997-2002 by Secret Labs AB ";\r
-\r
-#define PY_SSIZE_T_CLEAN\r
-\r
-#include "Python.h"\r
-#include "structmember.h" /* offsetof */\r
-\r
-#include "sre.h"\r
-\r
-#include <ctype.h>\r
-\r
-/* name of this module, minus the leading underscore */\r
-#if !defined(SRE_MODULE)\r
-#define SRE_MODULE "sre"\r
-#endif\r
-\r
-#define SRE_PY_MODULE "re"\r
-\r
-/* defining this one enables tracing */\r
-#undef VERBOSE\r
-\r
-#if PY_VERSION_HEX >= 0x01060000\r
-#if PY_VERSION_HEX < 0x02020000 || defined(Py_USING_UNICODE)\r
-/* defining this enables unicode support (default under 1.6a1 and later) */\r
-#define HAVE_UNICODE\r
-#endif\r
-#endif\r
-\r
-/* -------------------------------------------------------------------- */\r
-/* optional features */\r
-\r
-/* enables fast searching */\r
-#define USE_FAST_SEARCH\r
-\r
-/* enables aggressive inlining (always on for Visual C) */\r
-#undef USE_INLINE\r
-\r
-/* enables copy/deepcopy handling (work in progress) */\r
-#undef USE_BUILTIN_COPY\r
-\r
-#if PY_VERSION_HEX < 0x01060000\r
-#define PyObject_DEL(op) PyMem_DEL((op))\r
-#endif\r
-\r
-/* -------------------------------------------------------------------- */\r
-\r
-#if defined(_MSC_VER)\r
-#pragma optimize("gt", on) /* doesn't seem to make much difference... */\r
-#pragma warning(disable: 4710) /* who cares if functions are not inlined ;-) */\r
-/* fastest possible local call under MSVC */\r
-#define LOCAL(type) static __inline type __fastcall\r
-#elif defined(USE_INLINE)\r
-#define LOCAL(type) static inline type\r
-#else\r
-#define LOCAL(type) static type\r
-#endif\r
-\r
-/* error codes */\r
-#define SRE_ERROR_ILLEGAL -1 /* illegal opcode */\r
-#define SRE_ERROR_STATE -2 /* illegal state */\r
-#define SRE_ERROR_RECURSION_LIMIT -3 /* runaway recursion */\r
-#define SRE_ERROR_MEMORY -9 /* out of memory */\r
-#define SRE_ERROR_INTERRUPTED -10 /* signal handler raised exception */\r
-\r
-#if defined(VERBOSE)\r
-#define TRACE(v) printf v\r
-#else\r
-#define TRACE(v)\r
-#endif\r
-\r
-/* -------------------------------------------------------------------- */\r
-/* search engine state */\r
-\r
-/* default character predicates (run sre_chars.py to regenerate tables) */\r
-\r
-#define SRE_DIGIT_MASK 1\r
-#define SRE_SPACE_MASK 2\r
-#define SRE_LINEBREAK_MASK 4\r
-#define SRE_ALNUM_MASK 8\r
-#define SRE_WORD_MASK 16\r
-\r
-/* FIXME: this assumes ASCII. create tables in init_sre() instead */\r
-\r
-static char sre_char_info[128] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 6, 2,\r
-2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0,\r
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 25, 25, 25, 25, 25, 25, 25,\r
-25, 25, 0, 0, 0, 0, 0, 0, 0, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\r
-24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 0, 0,\r
-0, 0, 16, 0, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\r
-24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 0, 0, 0, 0, 0 };\r
-\r
-static char sre_char_lower[128] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,\r
-10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,\r
-27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,\r
-44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,\r
-61, 62, 63, 64, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,\r
-108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,\r
-122, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,\r
-106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,\r
-120, 121, 122, 123, 124, 125, 126, 127 };\r
-\r
-#define SRE_IS_DIGIT(ch)\\r
- ((ch) < 128 ? (sre_char_info[(ch)] & SRE_DIGIT_MASK) : 0)\r
-#define SRE_IS_SPACE(ch)\\r
- ((ch) < 128 ? (sre_char_info[(ch)] & SRE_SPACE_MASK) : 0)\r
-#define SRE_IS_LINEBREAK(ch)\\r
- ((ch) < 128 ? (sre_char_info[(ch)] & SRE_LINEBREAK_MASK) : 0)\r
-#define SRE_IS_ALNUM(ch)\\r
- ((ch) < 128 ? (sre_char_info[(ch)] & SRE_ALNUM_MASK) : 0)\r
-#define SRE_IS_WORD(ch)\\r
- ((ch) < 128 ? (sre_char_info[(ch)] & SRE_WORD_MASK) : 0)\r
-\r
-static unsigned int sre_lower(unsigned int ch)\r
-{\r
- return ((ch) < 128 ? (unsigned int)sre_char_lower[ch] : ch);\r
-}\r
-\r
-/* locale-specific character predicates */\r
-/* !(c & ~N) == (c < N+1) for any unsigned c, this avoids\r
- * warnings when c's type supports only numbers < N+1 */\r
-#define SRE_LOC_IS_DIGIT(ch) (!((ch) & ~255) ? isdigit((ch)) : 0)\r
-#define SRE_LOC_IS_SPACE(ch) (!((ch) & ~255) ? isspace((ch)) : 0)\r
-#define SRE_LOC_IS_LINEBREAK(ch) ((ch) == '\n')\r
-#define SRE_LOC_IS_ALNUM(ch) (!((ch) & ~255) ? isalnum((ch)) : 0)\r
-#define SRE_LOC_IS_WORD(ch) (SRE_LOC_IS_ALNUM((ch)) || (ch) == '_')\r
-\r
-static unsigned int sre_lower_locale(unsigned int ch)\r
-{\r
- return ((ch) < 256 ? (unsigned int)tolower((ch)) : ch);\r
-}\r
-\r
-/* unicode-specific character predicates */\r
-\r
-#if defined(HAVE_UNICODE)\r
-\r
-#define SRE_UNI_IS_DIGIT(ch) Py_UNICODE_ISDECIMAL((Py_UNICODE)(ch))\r
-#define SRE_UNI_IS_SPACE(ch) Py_UNICODE_ISSPACE((Py_UNICODE)(ch))\r
-#define SRE_UNI_IS_LINEBREAK(ch) Py_UNICODE_ISLINEBREAK((Py_UNICODE)(ch))\r
-#define SRE_UNI_IS_ALNUM(ch) Py_UNICODE_ISALNUM((Py_UNICODE)(ch))\r
-#define SRE_UNI_IS_WORD(ch) (SRE_UNI_IS_ALNUM((ch)) || (ch) == '_')\r
-\r
-static unsigned int sre_lower_unicode(unsigned int ch)\r
-{\r
- return (unsigned int) Py_UNICODE_TOLOWER((Py_UNICODE)(ch));\r
-}\r
-\r
-#endif\r
-\r
-LOCAL(int)\r
-sre_category(SRE_CODE category, unsigned int ch)\r
-{\r
- switch (category) {\r
-\r
- case SRE_CATEGORY_DIGIT:\r
- return SRE_IS_DIGIT(ch);\r
- case SRE_CATEGORY_NOT_DIGIT:\r
- return !SRE_IS_DIGIT(ch);\r
- case SRE_CATEGORY_SPACE:\r
- return SRE_IS_SPACE(ch);\r
- case SRE_CATEGORY_NOT_SPACE:\r
- return !SRE_IS_SPACE(ch);\r
- case SRE_CATEGORY_WORD:\r
- return SRE_IS_WORD(ch);\r
- case SRE_CATEGORY_NOT_WORD:\r
- return !SRE_IS_WORD(ch);\r
- case SRE_CATEGORY_LINEBREAK:\r
- return SRE_IS_LINEBREAK(ch);\r
- case SRE_CATEGORY_NOT_LINEBREAK:\r
- return !SRE_IS_LINEBREAK(ch);\r
-\r
- case SRE_CATEGORY_LOC_WORD:\r
- return SRE_LOC_IS_WORD(ch);\r
- case SRE_CATEGORY_LOC_NOT_WORD:\r
- return !SRE_LOC_IS_WORD(ch);\r
-\r
-#if defined(HAVE_UNICODE)\r
- case SRE_CATEGORY_UNI_DIGIT:\r
- return SRE_UNI_IS_DIGIT(ch);\r
- case SRE_CATEGORY_UNI_NOT_DIGIT:\r
- return !SRE_UNI_IS_DIGIT(ch);\r
- case SRE_CATEGORY_UNI_SPACE:\r
- return SRE_UNI_IS_SPACE(ch);\r
- case SRE_CATEGORY_UNI_NOT_SPACE:\r
- return !SRE_UNI_IS_SPACE(ch);\r
- case SRE_CATEGORY_UNI_WORD:\r
- return SRE_UNI_IS_WORD(ch);\r
- case SRE_CATEGORY_UNI_NOT_WORD:\r
- return !SRE_UNI_IS_WORD(ch);\r
- case SRE_CATEGORY_UNI_LINEBREAK:\r
- return SRE_UNI_IS_LINEBREAK(ch);\r
- case SRE_CATEGORY_UNI_NOT_LINEBREAK:\r
- return !SRE_UNI_IS_LINEBREAK(ch);\r
-#else\r
- case SRE_CATEGORY_UNI_DIGIT:\r
- return SRE_IS_DIGIT(ch);\r
- case SRE_CATEGORY_UNI_NOT_DIGIT:\r
- return !SRE_IS_DIGIT(ch);\r
- case SRE_CATEGORY_UNI_SPACE:\r
- return SRE_IS_SPACE(ch);\r
- case SRE_CATEGORY_UNI_NOT_SPACE:\r
- return !SRE_IS_SPACE(ch);\r
- case SRE_CATEGORY_UNI_WORD:\r
- return SRE_LOC_IS_WORD(ch);\r
- case SRE_CATEGORY_UNI_NOT_WORD:\r
- return !SRE_LOC_IS_WORD(ch);\r
- case SRE_CATEGORY_UNI_LINEBREAK:\r
- return SRE_IS_LINEBREAK(ch);\r
- case SRE_CATEGORY_UNI_NOT_LINEBREAK:\r
- return !SRE_IS_LINEBREAK(ch);\r
-#endif\r
- }\r
- return 0;\r
-}\r
-\r
-/* helpers */\r
-\r
-static void\r
-data_stack_dealloc(SRE_STATE* state)\r
-{\r
- if (state->data_stack) {\r
- PyMem_FREE(state->data_stack);\r
- state->data_stack = NULL;\r
- }\r
- state->data_stack_size = state->data_stack_base = 0;\r
-}\r
-\r
-static int\r
-data_stack_grow(SRE_STATE* state, Py_ssize_t size)\r
-{\r
- Py_ssize_t minsize, cursize;\r
- minsize = state->data_stack_base+size;\r
- cursize = state->data_stack_size;\r
- if (cursize < minsize) {\r
- void* stack;\r
- cursize = minsize+minsize/4+1024;\r
- TRACE(("allocate/grow stack %d\n", cursize));\r
- stack = PyMem_REALLOC(state->data_stack, cursize);\r
- if (!stack) {\r
- data_stack_dealloc(state);\r
- return SRE_ERROR_MEMORY;\r
- }\r
- state->data_stack = (char *)stack;\r
- state->data_stack_size = cursize;\r
- }\r
- return 0;\r
-}\r
-\r
-/* generate 8-bit version */\r
-\r
-#define SRE_CHAR unsigned char\r
-#define SRE_AT sre_at\r
-#define SRE_COUNT sre_count\r
-#define SRE_CHARSET sre_charset\r
-#define SRE_INFO sre_info\r
-#define SRE_MATCH sre_match\r
-#define SRE_MATCH_CONTEXT sre_match_context\r
-#define SRE_SEARCH sre_search\r
-#define SRE_LITERAL_TEMPLATE sre_literal_template\r
-\r
-#if defined(HAVE_UNICODE)\r
-\r
-#define SRE_RECURSIVE\r
-#include "_sre.c"\r
-#undef SRE_RECURSIVE\r
-\r
-#undef SRE_LITERAL_TEMPLATE\r
-#undef SRE_SEARCH\r
-#undef SRE_MATCH\r
-#undef SRE_MATCH_CONTEXT\r
-#undef SRE_INFO\r
-#undef SRE_CHARSET\r
-#undef SRE_COUNT\r
-#undef SRE_AT\r
-#undef SRE_CHAR\r
-\r
-/* generate 16-bit unicode version */\r
-\r
-#define SRE_CHAR Py_UNICODE\r
-#define SRE_AT sre_uat\r
-#define SRE_COUNT sre_ucount\r
-#define SRE_CHARSET sre_ucharset\r
-#define SRE_INFO sre_uinfo\r
-#define SRE_MATCH sre_umatch\r
-#define SRE_MATCH_CONTEXT sre_umatch_context\r
-#define SRE_SEARCH sre_usearch\r
-#define SRE_LITERAL_TEMPLATE sre_uliteral_template\r
-#endif\r
-\r
-#endif /* SRE_RECURSIVE */\r
-\r
-/* -------------------------------------------------------------------- */\r
-/* String matching engine */\r
-\r
-/* the following section is compiled twice, with different character\r
- settings */\r
-\r
-LOCAL(int)\r
-SRE_AT(SRE_STATE* state, SRE_CHAR* ptr, SRE_CODE at)\r
-{\r
- /* check if pointer is at given position */\r
-\r
- Py_ssize_t thisp, thatp;\r
-\r
- switch (at) {\r
-\r
- case SRE_AT_BEGINNING:\r
- case SRE_AT_BEGINNING_STRING:\r
- return ((void*) ptr == state->beginning);\r
-\r
- case SRE_AT_BEGINNING_LINE:\r
- return ((void*) ptr == state->beginning ||\r
- SRE_IS_LINEBREAK((int) ptr[-1]));\r
-\r
- case SRE_AT_END:\r
- return (((void*) (ptr+1) == state->end &&\r
- SRE_IS_LINEBREAK((int) ptr[0])) ||\r
- ((void*) ptr == state->end));\r
-\r
- case SRE_AT_END_LINE:\r
- return ((void*) ptr == state->end ||\r
- SRE_IS_LINEBREAK((int) ptr[0]));\r
-\r
- case SRE_AT_END_STRING:\r
- return ((void*) ptr == state->end);\r
-\r
- case SRE_AT_BOUNDARY:\r
- if (state->beginning == state->end)\r
- return 0;\r
- thatp = ((void*) ptr > state->beginning) ?\r
- SRE_IS_WORD((int) ptr[-1]) : 0;\r
- thisp = ((void*) ptr < state->end) ?\r
- SRE_IS_WORD((int) ptr[0]) : 0;\r
- return thisp != thatp;\r
-\r
- case SRE_AT_NON_BOUNDARY:\r
- if (state->beginning == state->end)\r
- return 0;\r
- thatp = ((void*) ptr > state->beginning) ?\r
- SRE_IS_WORD((int) ptr[-1]) : 0;\r
- thisp = ((void*) ptr < state->end) ?\r
- SRE_IS_WORD((int) ptr[0]) : 0;\r
- return thisp == thatp;\r
-\r
- case SRE_AT_LOC_BOUNDARY:\r
- if (state->beginning == state->end)\r
- return 0;\r
- thatp = ((void*) ptr > state->beginning) ?\r
- SRE_LOC_IS_WORD((int) ptr[-1]) : 0;\r
- thisp = ((void*) ptr < state->end) ?\r
- SRE_LOC_IS_WORD((int) ptr[0]) : 0;\r
- return thisp != thatp;\r
-\r
- case SRE_AT_LOC_NON_BOUNDARY:\r
- if (state->beginning == state->end)\r
- return 0;\r
- thatp = ((void*) ptr > state->beginning) ?\r
- SRE_LOC_IS_WORD((int) ptr[-1]) : 0;\r
- thisp = ((void*) ptr < state->end) ?\r
- SRE_LOC_IS_WORD((int) ptr[0]) : 0;\r
- return thisp == thatp;\r
-\r
-#if defined(HAVE_UNICODE)\r
- case SRE_AT_UNI_BOUNDARY:\r
- if (state->beginning == state->end)\r
- return 0;\r
- thatp = ((void*) ptr > state->beginning) ?\r
- SRE_UNI_IS_WORD((int) ptr[-1]) : 0;\r
- thisp = ((void*) ptr < state->end) ?\r
- SRE_UNI_IS_WORD((int) ptr[0]) : 0;\r
- return thisp != thatp;\r
-\r
- case SRE_AT_UNI_NON_BOUNDARY:\r
- if (state->beginning == state->end)\r
- return 0;\r
- thatp = ((void*) ptr > state->beginning) ?\r
- SRE_UNI_IS_WORD((int) ptr[-1]) : 0;\r
- thisp = ((void*) ptr < state->end) ?\r
- SRE_UNI_IS_WORD((int) ptr[0]) : 0;\r
- return thisp == thatp;\r
-#endif\r
-\r
- }\r
-\r
- return 0;\r
-}\r
-\r
-LOCAL(int)\r
-SRE_CHARSET(SRE_CODE* set, SRE_CODE ch)\r
-{\r
- /* check if character is a member of the given set */\r
-\r
- int ok = 1;\r
-\r
- for (;;) {\r
- switch (*set++) {\r
-\r
- case SRE_OP_FAILURE:\r
- return !ok;\r
-\r
- case SRE_OP_LITERAL:\r
- /* <LITERAL> <code> */\r
- if (ch == set[0])\r
- return ok;\r
- set++;\r
- break;\r
-\r
- case SRE_OP_CATEGORY:\r
- /* <CATEGORY> <code> */\r
- if (sre_category(set[0], (int) ch))\r
- return ok;\r
- set += 1;\r
- break;\r
-\r
- case SRE_OP_CHARSET:\r
- if (sizeof(SRE_CODE) == 2) {\r
- /* <CHARSET> <bitmap> (16 bits per code word) */\r
- if (ch < 256 && (set[ch >> 4] & (1 << (ch & 15))))\r
- return ok;\r
- set += 16;\r
- }\r
- else {\r
- /* <CHARSET> <bitmap> (32 bits per code word) */\r
- if (ch < 256 && (set[ch >> 5] & (1 << (ch & 31))))\r
- return ok;\r
- set += 8;\r
- }\r
- break;\r
-\r
- case SRE_OP_RANGE:\r
- /* <RANGE> <lower> <upper> */\r
- if (set[0] <= ch && ch <= set[1])\r
- return ok;\r
- set += 2;\r
- break;\r
-\r
- case SRE_OP_NEGATE:\r
- ok = !ok;\r
- break;\r
-\r
- case SRE_OP_BIGCHARSET:\r
- /* <BIGCHARSET> <blockcount> <256 blockindices> <blocks> */\r
- {\r
- Py_ssize_t count, block;\r
- count = *(set++);\r
-\r
- if (sizeof(SRE_CODE) == 2) {\r
- block = ((unsigned char*)set)[ch >> 8];\r
- set += 128;\r
- if (set[block*16 + ((ch & 255)>>4)] & (1 << (ch & 15)))\r
- return ok;\r
- set += count*16;\r
- }\r
- else {\r
- /* !(c & ~N) == (c < N+1) for any unsigned c, this avoids\r
- * warnings when c's type supports only numbers < N+1 */\r
- if (!(ch & ~65535))\r
- block = ((unsigned char*)set)[ch >> 8];\r
- else\r
- block = -1;\r
- set += 64;\r
- if (block >=0 &&\r
- (set[block*8 + ((ch & 255)>>5)] & (1 << (ch & 31))))\r
- return ok;\r
- set += count*8;\r
- }\r
- break;\r
- }\r
-\r
- default:\r
- /* internal error -- there's not much we can do about it\r
- here, so let's just pretend it didn't match... */\r
- return 0;\r
- }\r
- }\r
-}\r
-\r
-LOCAL(Py_ssize_t) SRE_MATCH(SRE_STATE* state, SRE_CODE* pattern);\r
-\r
-LOCAL(Py_ssize_t)\r
-SRE_COUNT(SRE_STATE* state, SRE_CODE* pattern, Py_ssize_t maxcount)\r
-{\r
- SRE_CODE chr;\r
- SRE_CHAR* ptr = (SRE_CHAR *)state->ptr;\r
- SRE_CHAR* end = (SRE_CHAR *)state->end;\r
- Py_ssize_t i;\r
-\r
- /* adjust end */\r
- if (maxcount < end - ptr && maxcount != 65535)\r
- end = ptr + maxcount;\r
-\r
- switch (pattern[0]) {\r
-\r
- case SRE_OP_IN:\r
- /* repeated set */\r
- TRACE(("|%p|%p|COUNT IN\n", pattern, ptr));\r
- while (ptr < end && SRE_CHARSET(pattern + 2, *ptr))\r
- ptr++;\r
- break;\r
-\r
- case SRE_OP_ANY:\r
- /* repeated dot wildcard. */\r
- TRACE(("|%p|%p|COUNT ANY\n", pattern, ptr));\r
- while (ptr < end && !SRE_IS_LINEBREAK(*ptr))\r
- ptr++;\r
- break;\r
-\r
- case SRE_OP_ANY_ALL:\r
- /* repeated dot wildcard. skip to the end of the target\r
- string, and backtrack from there */\r
- TRACE(("|%p|%p|COUNT ANY_ALL\n", pattern, ptr));\r
- ptr = end;\r
- break;\r
-\r
- case SRE_OP_LITERAL:\r
- /* repeated literal */\r
- chr = pattern[1];\r
- TRACE(("|%p|%p|COUNT LITERAL %d\n", pattern, ptr, chr));\r
- while (ptr < end && (SRE_CODE) *ptr == chr)\r
- ptr++;\r
- break;\r
-\r
- case SRE_OP_LITERAL_IGNORE:\r
- /* repeated literal */\r
- chr = pattern[1];\r
- TRACE(("|%p|%p|COUNT LITERAL_IGNORE %d\n", pattern, ptr, chr));\r
- while (ptr < end && (SRE_CODE) state->lower(*ptr) == chr)\r
- ptr++;\r
- break;\r
-\r
- case SRE_OP_NOT_LITERAL:\r
- /* repeated non-literal */\r
- chr = pattern[1];\r
- TRACE(("|%p|%p|COUNT NOT_LITERAL %d\n", pattern, ptr, chr));\r
- while (ptr < end && (SRE_CODE) *ptr != chr)\r
- ptr++;\r
- break;\r
-\r
- case SRE_OP_NOT_LITERAL_IGNORE:\r
- /* repeated non-literal */\r
- chr = pattern[1];\r
- TRACE(("|%p|%p|COUNT NOT_LITERAL_IGNORE %d\n", pattern, ptr, chr));\r
- while (ptr < end && (SRE_CODE) state->lower(*ptr) != chr)\r
- ptr++;\r
- break;\r
-\r
- default:\r
- /* repeated single character pattern */\r
- TRACE(("|%p|%p|COUNT SUBPATTERN\n", pattern, ptr));\r
- while ((SRE_CHAR*) state->ptr < end) {\r
- i = SRE_MATCH(state, pattern);\r
- if (i < 0)\r
- return i;\r
- if (!i)\r
- break;\r
- }\r
- TRACE(("|%p|%p|COUNT %d\n", pattern, ptr,\r
- (SRE_CHAR*) state->ptr - ptr));\r
- return (SRE_CHAR*) state->ptr - ptr;\r
- }\r
-\r
- TRACE(("|%p|%p|COUNT %d\n", pattern, ptr, ptr - (SRE_CHAR*) state->ptr));\r
- return ptr - (SRE_CHAR*) state->ptr;\r
-}\r
-\r
-#if 0 /* not used in this release */\r
-LOCAL(int)\r
-SRE_INFO(SRE_STATE* state, SRE_CODE* pattern)\r
-{\r
- /* check if an SRE_OP_INFO block matches at the current position.\r
- returns the number of SRE_CODE objects to skip if successful, 0\r
- if no match */\r
-\r
- SRE_CHAR* end = state->end;\r
- SRE_CHAR* ptr = state->ptr;\r
- Py_ssize_t i;\r
-\r
- /* check minimal length */\r
- if (pattern[3] && (end - ptr) < pattern[3])\r
- return 0;\r
-\r
- /* check known prefix */\r
- if (pattern[2] & SRE_INFO_PREFIX && pattern[5] > 1) {\r
- /* <length> <skip> <prefix data> <overlap data> */\r
- for (i = 0; i < pattern[5]; i++)\r
- if ((SRE_CODE) ptr[i] != pattern[7 + i])\r
- return 0;\r
- return pattern[0] + 2 * pattern[6];\r
- }\r
- return pattern[0];\r
-}\r
-#endif\r
-\r
-/* The macros below should be used to protect recursive SRE_MATCH()\r
- * calls that *failed* and do *not* return immediately (IOW, those\r
- * that will backtrack). Explaining:\r
- *\r
- * - Recursive SRE_MATCH() returned true: that's usually a success\r
- * (besides atypical cases like ASSERT_NOT), therefore there's no\r
- * reason to restore lastmark;\r
- *\r
- * - Recursive SRE_MATCH() returned false but the current SRE_MATCH()\r
- * is returning to the caller: If the current SRE_MATCH() is the\r
- * top function of the recursion, returning false will be a matching\r
- * failure, and it doesn't matter where lastmark is pointing to.\r
- * If it's *not* the top function, it will be a recursive SRE_MATCH()\r
- * failure by itself, and the calling SRE_MATCH() will have to deal\r
- * with the failure by the same rules explained here (it will restore\r
- * lastmark by itself if necessary);\r
- *\r
- * - Recursive SRE_MATCH() returned false, and will continue the\r
- * outside 'for' loop: must be protected when breaking, since the next\r
- * OP could potentially depend on lastmark;\r
- *\r
- * - Recursive SRE_MATCH() returned false, and will be called again\r
- * inside a local for/while loop: must be protected between each\r
- * loop iteration, since the recursive SRE_MATCH() could do anything,\r
- * and could potentially depend on lastmark.\r
- *\r
- * For more information, check the discussion at SF patch #712900.\r
- */\r
-#define LASTMARK_SAVE() \\r
- do { \\r
- ctx->lastmark = state->lastmark; \\r
- ctx->lastindex = state->lastindex; \\r
- } while (0)\r
-#define LASTMARK_RESTORE() \\r
- do { \\r
- state->lastmark = ctx->lastmark; \\r
- state->lastindex = ctx->lastindex; \\r
- } while (0)\r
-\r
-#define RETURN_ERROR(i) do { return i; } while(0)\r
-#define RETURN_FAILURE do { ret = 0; goto exit; } while(0)\r
-#define RETURN_SUCCESS do { ret = 1; goto exit; } while(0)\r
-\r
-#define RETURN_ON_ERROR(i) \\r
- do { if (i < 0) RETURN_ERROR(i); } while (0)\r
-#define RETURN_ON_SUCCESS(i) \\r
- do { RETURN_ON_ERROR(i); if (i > 0) RETURN_SUCCESS; } while (0)\r
-#define RETURN_ON_FAILURE(i) \\r
- do { RETURN_ON_ERROR(i); if (i == 0) RETURN_FAILURE; } while (0)\r
-\r
-#define SFY(x) #x\r
-\r
-#define DATA_STACK_ALLOC(state, type, ptr) \\r
-do { \\r
- alloc_pos = state->data_stack_base; \\r
- TRACE(("allocating %s in %d (%d)\n", \\r
- SFY(type), alloc_pos, sizeof(type))); \\r
- if (state->data_stack_size < alloc_pos+sizeof(type)) { \\r
- int j = data_stack_grow(state, sizeof(type)); \\r
- if (j < 0) return j; \\r
- if (ctx_pos != -1) \\r
- DATA_STACK_LOOKUP_AT(state, SRE_MATCH_CONTEXT, ctx, ctx_pos); \\r
- } \\r
- ptr = (type*)(state->data_stack+alloc_pos); \\r
- state->data_stack_base += sizeof(type); \\r
-} while (0)\r
-\r
-#define DATA_STACK_LOOKUP_AT(state, type, ptr, pos) \\r
-do { \\r
- TRACE(("looking up %s at %d\n", SFY(type), pos)); \\r
- ptr = (type*)(state->data_stack+pos); \\r
-} while (0)\r
-\r
-#define DATA_STACK_PUSH(state, data, size) \\r
-do { \\r
- TRACE(("copy data in %p to %d (%d)\n", \\r
- data, state->data_stack_base, size)); \\r
- if (state->data_stack_size < state->data_stack_base+size) { \\r
- int j = data_stack_grow(state, size); \\r
- if (j < 0) return j; \\r
- if (ctx_pos != -1) \\r
- DATA_STACK_LOOKUP_AT(state, SRE_MATCH_CONTEXT, ctx, ctx_pos); \\r
- } \\r
- memcpy(state->data_stack+state->data_stack_base, data, size); \\r
- state->data_stack_base += size; \\r
-} while (0)\r
-\r
-#define DATA_STACK_POP(state, data, size, discard) \\r
-do { \\r
- TRACE(("copy data to %p from %d (%d)\n", \\r
- data, state->data_stack_base-size, size)); \\r
- memcpy(data, state->data_stack+state->data_stack_base-size, size); \\r
- if (discard) \\r
- state->data_stack_base -= size; \\r
-} while (0)\r
-\r
-#define DATA_STACK_POP_DISCARD(state, size) \\r
-do { \\r
- TRACE(("discard data from %d (%d)\n", \\r
- state->data_stack_base-size, size)); \\r
- state->data_stack_base -= size; \\r
-} while(0)\r
-\r
-#define DATA_PUSH(x) \\r
- DATA_STACK_PUSH(state, (x), sizeof(*(x)))\r
-#define DATA_POP(x) \\r
- DATA_STACK_POP(state, (x), sizeof(*(x)), 1)\r
-#define DATA_POP_DISCARD(x) \\r
- DATA_STACK_POP_DISCARD(state, sizeof(*(x)))\r
-#define DATA_ALLOC(t,p) \\r
- DATA_STACK_ALLOC(state, t, p)\r
-#define DATA_LOOKUP_AT(t,p,pos) \\r
- DATA_STACK_LOOKUP_AT(state,t,p,pos)\r
-\r
-#define MARK_PUSH(lastmark) \\r
- do if (lastmark > 0) { \\r
- i = lastmark; /* ctx->lastmark may change if reallocated */ \\r
- DATA_STACK_PUSH(state, state->mark, (i+1)*sizeof(void*)); \\r
- } while (0)\r
-#define MARK_POP(lastmark) \\r
- do if (lastmark > 0) { \\r
- DATA_STACK_POP(state, state->mark, (lastmark+1)*sizeof(void*), 1); \\r
- } while (0)\r
-#define MARK_POP_KEEP(lastmark) \\r
- do if (lastmark > 0) { \\r
- DATA_STACK_POP(state, state->mark, (lastmark+1)*sizeof(void*), 0); \\r
- } while (0)\r
-#define MARK_POP_DISCARD(lastmark) \\r
- do if (lastmark > 0) { \\r
- DATA_STACK_POP_DISCARD(state, (lastmark+1)*sizeof(void*)); \\r
- } while (0)\r
-\r
-#define JUMP_NONE 0\r
-#define JUMP_MAX_UNTIL_1 1\r
-#define JUMP_MAX_UNTIL_2 2\r
-#define JUMP_MAX_UNTIL_3 3\r
-#define JUMP_MIN_UNTIL_1 4\r
-#define JUMP_MIN_UNTIL_2 5\r
-#define JUMP_MIN_UNTIL_3 6\r
-#define JUMP_REPEAT 7\r
-#define JUMP_REPEAT_ONE_1 8\r
-#define JUMP_REPEAT_ONE_2 9\r
-#define JUMP_MIN_REPEAT_ONE 10\r
-#define JUMP_BRANCH 11\r
-#define JUMP_ASSERT 12\r
-#define JUMP_ASSERT_NOT 13\r
-\r
-#define DO_JUMP(jumpvalue, jumplabel, nextpattern) \\r
- DATA_ALLOC(SRE_MATCH_CONTEXT, nextctx); \\r
- nextctx->last_ctx_pos = ctx_pos; \\r
- nextctx->jump = jumpvalue; \\r
- nextctx->pattern = nextpattern; \\r
- ctx_pos = alloc_pos; \\r
- ctx = nextctx; \\r
- goto entrance; \\r
- jumplabel: \\r
- while (0) /* gcc doesn't like labels at end of scopes */ \\r
-\r
-typedef struct {\r
- Py_ssize_t last_ctx_pos;\r
- Py_ssize_t jump;\r
- SRE_CHAR* ptr;\r
- SRE_CODE* pattern;\r
- Py_ssize_t count;\r
- Py_ssize_t lastmark;\r
- Py_ssize_t lastindex;\r
- union {\r
- SRE_CODE chr;\r
- SRE_REPEAT* rep;\r
- } u;\r
-} SRE_MATCH_CONTEXT;\r
-\r
-/* check if string matches the given pattern. returns <0 for\r
- error, 0 for failure, and 1 for success */\r
-LOCAL(Py_ssize_t)\r
-SRE_MATCH(SRE_STATE* state, SRE_CODE* pattern)\r
-{\r
- SRE_CHAR* end = (SRE_CHAR *)state->end;\r
- Py_ssize_t alloc_pos, ctx_pos = -1;\r
- Py_ssize_t i, ret = 0;\r
- Py_ssize_t jump;\r
- unsigned int sigcount=0;\r
-\r
- SRE_MATCH_CONTEXT* ctx;\r
- SRE_MATCH_CONTEXT* nextctx;\r
-\r
- TRACE(("|%p|%p|ENTER\n", pattern, state->ptr));\r
-\r
- DATA_ALLOC(SRE_MATCH_CONTEXT, ctx);\r
- ctx->last_ctx_pos = -1;\r
- ctx->jump = JUMP_NONE;\r
- ctx->pattern = pattern;\r
- ctx_pos = alloc_pos;\r
-\r
-entrance:\r
-\r
- ctx->ptr = (SRE_CHAR *)state->ptr;\r
-\r
- if (ctx->pattern[0] == SRE_OP_INFO) {\r
- /* optimization info block */\r
- /* <INFO> <1=skip> <2=flags> <3=min> ... */\r
- if (ctx->pattern[3] && (end - ctx->ptr) < ctx->pattern[3]) {\r
- TRACE(("reject (got %d chars, need %d)\n",\r
- (end - ctx->ptr), ctx->pattern[3]));\r
- RETURN_FAILURE;\r
- }\r
- ctx->pattern += ctx->pattern[1] + 1;\r
- }\r
-\r
- for (;;) {\r
- ++sigcount;\r
- if ((0 == (sigcount & 0xfff)) && PyErr_CheckSignals())\r
- RETURN_ERROR(SRE_ERROR_INTERRUPTED);\r
-\r
- switch (*ctx->pattern++) {\r
-\r
- case SRE_OP_MARK:\r
- /* set mark */\r
- /* <MARK> <gid> */\r
- TRACE(("|%p|%p|MARK %d\n", ctx->pattern,\r
- ctx->ptr, ctx->pattern[0]));\r
- i = ctx->pattern[0];\r
- if (i & 1)\r
- state->lastindex = i/2 + 1;\r
- if (i > state->lastmark) {\r
- /* state->lastmark is the highest valid index in the\r
- state->mark array. If it is increased by more than 1,\r
- the intervening marks must be set to NULL to signal\r
- that these marks have not been encountered. */\r
- Py_ssize_t j = state->lastmark + 1;\r
- while (j < i)\r
- state->mark[j++] = NULL;\r
- state->lastmark = i;\r
- }\r
- state->mark[i] = ctx->ptr;\r
- ctx->pattern++;\r
- break;\r
-\r
- case SRE_OP_LITERAL:\r
- /* match literal string */\r
- /* <LITERAL> <code> */\r
- TRACE(("|%p|%p|LITERAL %d\n", ctx->pattern,\r
- ctx->ptr, *ctx->pattern));\r
- if (ctx->ptr >= end || (SRE_CODE) ctx->ptr[0] != ctx->pattern[0])\r
- RETURN_FAILURE;\r
- ctx->pattern++;\r
- ctx->ptr++;\r
- break;\r
-\r
- case SRE_OP_NOT_LITERAL:\r
- /* match anything that is not literal character */\r
- /* <NOT_LITERAL> <code> */\r
- TRACE(("|%p|%p|NOT_LITERAL %d\n", ctx->pattern,\r
- ctx->ptr, *ctx->pattern));\r
- if (ctx->ptr >= end || (SRE_CODE) ctx->ptr[0] == ctx->pattern[0])\r
- RETURN_FAILURE;\r
- ctx->pattern++;\r
- ctx->ptr++;\r
- break;\r
-\r
- case SRE_OP_SUCCESS:\r
- /* end of pattern */\r
- TRACE(("|%p|%p|SUCCESS\n", ctx->pattern, ctx->ptr));\r
- state->ptr = ctx->ptr;\r
- RETURN_SUCCESS;\r
-\r
- case SRE_OP_AT:\r
- /* match at given position */\r
- /* <AT> <code> */\r
- TRACE(("|%p|%p|AT %d\n", ctx->pattern, ctx->ptr, *ctx->pattern));\r
- if (!SRE_AT(state, ctx->ptr, *ctx->pattern))\r
- RETURN_FAILURE;\r
- ctx->pattern++;\r
- break;\r
-\r
- case SRE_OP_CATEGORY:\r
- /* match at given category */\r
- /* <CATEGORY> <code> */\r
- TRACE(("|%p|%p|CATEGORY %d\n", ctx->pattern,\r
- ctx->ptr, *ctx->pattern));\r
- if (ctx->ptr >= end || !sre_category(ctx->pattern[0], ctx->ptr[0]))\r
- RETURN_FAILURE;\r
- ctx->pattern++;\r
- ctx->ptr++;\r
- break;\r
-\r
- case SRE_OP_ANY:\r
- /* match anything (except a newline) */\r
- /* <ANY> */\r
- TRACE(("|%p|%p|ANY\n", ctx->pattern, ctx->ptr));\r
- if (ctx->ptr >= end || SRE_IS_LINEBREAK(ctx->ptr[0]))\r
- RETURN_FAILURE;\r
- ctx->ptr++;\r
- break;\r
-\r
- case SRE_OP_ANY_ALL:\r
- /* match anything */\r
- /* <ANY_ALL> */\r
- TRACE(("|%p|%p|ANY_ALL\n", ctx->pattern, ctx->ptr));\r
- if (ctx->ptr >= end)\r
- RETURN_FAILURE;\r
- ctx->ptr++;\r
- break;\r
-\r
- case SRE_OP_IN:\r
- /* match set member (or non_member) */\r
- /* <IN> <skip> <set> */\r
- TRACE(("|%p|%p|IN\n", ctx->pattern, ctx->ptr));\r
- if (ctx->ptr >= end || !SRE_CHARSET(ctx->pattern + 1, *ctx->ptr))\r
- RETURN_FAILURE;\r
- ctx->pattern += ctx->pattern[0];\r
- ctx->ptr++;\r
- break;\r
-\r
- case SRE_OP_LITERAL_IGNORE:\r
- TRACE(("|%p|%p|LITERAL_IGNORE %d\n",\r
- ctx->pattern, ctx->ptr, ctx->pattern[0]));\r
- if (ctx->ptr >= end ||\r
- state->lower(*ctx->ptr) != state->lower(*ctx->pattern))\r
- RETURN_FAILURE;\r
- ctx->pattern++;\r
- ctx->ptr++;\r
- break;\r
-\r
- case SRE_OP_NOT_LITERAL_IGNORE:\r
- TRACE(("|%p|%p|NOT_LITERAL_IGNORE %d\n",\r
- ctx->pattern, ctx->ptr, *ctx->pattern));\r
- if (ctx->ptr >= end ||\r
- state->lower(*ctx->ptr) == state->lower(*ctx->pattern))\r
- RETURN_FAILURE;\r
- ctx->pattern++;\r
- ctx->ptr++;\r
- break;\r
-\r
- case SRE_OP_IN_IGNORE:\r
- TRACE(("|%p|%p|IN_IGNORE\n", ctx->pattern, ctx->ptr));\r
- if (ctx->ptr >= end\r
- || !SRE_CHARSET(ctx->pattern+1,\r
- (SRE_CODE)state->lower(*ctx->ptr)))\r
- RETURN_FAILURE;\r
- ctx->pattern += ctx->pattern[0];\r
- ctx->ptr++;\r
- break;\r
-\r
- case SRE_OP_JUMP:\r
- case SRE_OP_INFO:\r
- /* jump forward */\r
- /* <JUMP> <offset> */\r
- TRACE(("|%p|%p|JUMP %d\n", ctx->pattern,\r
- ctx->ptr, ctx->pattern[0]));\r
- ctx->pattern += ctx->pattern[0];\r
- break;\r
-\r
- case SRE_OP_BRANCH:\r
- /* alternation */\r
- /* <BRANCH> <0=skip> code <JUMP> ... <NULL> */\r
- TRACE(("|%p|%p|BRANCH\n", ctx->pattern, ctx->ptr));\r
- LASTMARK_SAVE();\r
- ctx->u.rep = state->repeat;\r
- if (ctx->u.rep)\r
- MARK_PUSH(ctx->lastmark);\r
- for (; ctx->pattern[0]; ctx->pattern += ctx->pattern[0]) {\r
- if (ctx->pattern[1] == SRE_OP_LITERAL &&\r
- (ctx->ptr >= end ||\r
- (SRE_CODE) *ctx->ptr != ctx->pattern[2]))\r
- continue;\r
- if (ctx->pattern[1] == SRE_OP_IN &&\r
- (ctx->ptr >= end ||\r
- !SRE_CHARSET(ctx->pattern + 3, (SRE_CODE) *ctx->ptr)))\r
- continue;\r
- state->ptr = ctx->ptr;\r
- DO_JUMP(JUMP_BRANCH, jump_branch, ctx->pattern+1);\r
- if (ret) {\r
- if (ctx->u.rep)\r
- MARK_POP_DISCARD(ctx->lastmark);\r
- RETURN_ON_ERROR(ret);\r
- RETURN_SUCCESS;\r
- }\r
- if (ctx->u.rep)\r
- MARK_POP_KEEP(ctx->lastmark);\r
- LASTMARK_RESTORE();\r
- }\r
- if (ctx->u.rep)\r
- MARK_POP_DISCARD(ctx->lastmark);\r
- RETURN_FAILURE;\r
-\r
- case SRE_OP_REPEAT_ONE:\r
- /* match repeated sequence (maximizing regexp) */\r
-\r
- /* this operator only works if the repeated item is\r
- exactly one character wide, and we're not already\r
- collecting backtracking points. for other cases,\r
- use the MAX_REPEAT operator */\r
-\r
- /* <REPEAT_ONE> <skip> <1=min> <2=max> item <SUCCESS> tail */\r
-\r
- TRACE(("|%p|%p|REPEAT_ONE %d %d\n", ctx->pattern, ctx->ptr,\r
- ctx->pattern[1], ctx->pattern[2]));\r
-\r
- if (ctx->ptr + ctx->pattern[1] > end)\r
- RETURN_FAILURE; /* cannot match */\r
-\r
- state->ptr = ctx->ptr;\r
-\r
- ret = SRE_COUNT(state, ctx->pattern+3, ctx->pattern[2]);\r
- RETURN_ON_ERROR(ret);\r
- DATA_LOOKUP_AT(SRE_MATCH_CONTEXT, ctx, ctx_pos);\r
- ctx->count = ret;\r
- ctx->ptr += ctx->count;\r
-\r
- /* when we arrive here, count contains the number of\r
- matches, and ctx->ptr points to the tail of the target\r
- string. check if the rest of the pattern matches,\r
- and backtrack if not. */\r
-\r
- if (ctx->count < (Py_ssize_t) ctx->pattern[1])\r
- RETURN_FAILURE;\r
-\r
- if (ctx->pattern[ctx->pattern[0]] == SRE_OP_SUCCESS) {\r
- /* tail is empty. we're finished */\r
- state->ptr = ctx->ptr;\r
- RETURN_SUCCESS;\r
- }\r
-\r
- LASTMARK_SAVE();\r
-\r
- if (ctx->pattern[ctx->pattern[0]] == SRE_OP_LITERAL) {\r
- /* tail starts with a literal. skip positions where\r
- the rest of the pattern cannot possibly match */\r
- ctx->u.chr = ctx->pattern[ctx->pattern[0]+1];\r
- for (;;) {\r
- while (ctx->count >= (Py_ssize_t) ctx->pattern[1] &&\r
- (ctx->ptr >= end || *ctx->ptr != ctx->u.chr)) {\r
- ctx->ptr--;\r
- ctx->count--;\r
- }\r
- if (ctx->count < (Py_ssize_t) ctx->pattern[1])\r
- break;\r
- state->ptr = ctx->ptr;\r
- DO_JUMP(JUMP_REPEAT_ONE_1, jump_repeat_one_1,\r
- ctx->pattern+ctx->pattern[0]);\r
- if (ret) {\r
- RETURN_ON_ERROR(ret);\r
- RETURN_SUCCESS;\r
- }\r
-\r
- LASTMARK_RESTORE();\r
-\r
- ctx->ptr--;\r
- ctx->count--;\r
- }\r
-\r
- } else {\r
- /* general case */\r
- while (ctx->count >= (Py_ssize_t) ctx->pattern[1]) {\r
- state->ptr = ctx->ptr;\r
- DO_JUMP(JUMP_REPEAT_ONE_2, jump_repeat_one_2,\r
- ctx->pattern+ctx->pattern[0]);\r
- if (ret) {\r
- RETURN_ON_ERROR(ret);\r
- RETURN_SUCCESS;\r
- }\r
- ctx->ptr--;\r
- ctx->count--;\r
- LASTMARK_RESTORE();\r
- }\r
- }\r
- RETURN_FAILURE;\r
-\r
- case SRE_OP_MIN_REPEAT_ONE:\r
- /* match repeated sequence (minimizing regexp) */\r
-\r
- /* this operator only works if the repeated item is\r
- exactly one character wide, and we're not already\r
- collecting backtracking points. for other cases,\r
- use the MIN_REPEAT operator */\r
-\r
- /* <MIN_REPEAT_ONE> <skip> <1=min> <2=max> item <SUCCESS> tail */\r
-\r
- TRACE(("|%p|%p|MIN_REPEAT_ONE %d %d\n", ctx->pattern, ctx->ptr,\r
- ctx->pattern[1], ctx->pattern[2]));\r
-\r
- if (ctx->ptr + ctx->pattern[1] > end)\r
- RETURN_FAILURE; /* cannot match */\r
-\r
- state->ptr = ctx->ptr;\r
-\r
- if (ctx->pattern[1] == 0)\r
- ctx->count = 0;\r
- else {\r
- /* count using pattern min as the maximum */\r
- ret = SRE_COUNT(state, ctx->pattern+3, ctx->pattern[1]);\r
- RETURN_ON_ERROR(ret);\r
- DATA_LOOKUP_AT(SRE_MATCH_CONTEXT, ctx, ctx_pos);\r
- if (ret < (Py_ssize_t) ctx->pattern[1])\r
- /* didn't match minimum number of times */\r
- RETURN_FAILURE;\r
- /* advance past minimum matches of repeat */\r
- ctx->count = ret;\r
- ctx->ptr += ctx->count;\r
- }\r
-\r
- if (ctx->pattern[ctx->pattern[0]] == SRE_OP_SUCCESS) {\r
- /* tail is empty. we're finished */\r
- state->ptr = ctx->ptr;\r
- RETURN_SUCCESS;\r
-\r
- } else {\r
- /* general case */\r
- LASTMARK_SAVE();\r
- while ((Py_ssize_t)ctx->pattern[2] == 65535\r
- || ctx->count <= (Py_ssize_t)ctx->pattern[2]) {\r
- state->ptr = ctx->ptr;\r
- DO_JUMP(JUMP_MIN_REPEAT_ONE,jump_min_repeat_one,\r
- ctx->pattern+ctx->pattern[0]);\r
- if (ret) {\r
- RETURN_ON_ERROR(ret);\r
- RETURN_SUCCESS;\r
- }\r
- state->ptr = ctx->ptr;\r
- ret = SRE_COUNT(state, ctx->pattern+3, 1);\r
- RETURN_ON_ERROR(ret);\r
- DATA_LOOKUP_AT(SRE_MATCH_CONTEXT, ctx, ctx_pos);\r
- if (ret == 0)\r
- break;\r
- assert(ret == 1);\r
- ctx->ptr++;\r
- ctx->count++;\r
- LASTMARK_RESTORE();\r
- }\r
- }\r
- RETURN_FAILURE;\r
-\r
- case SRE_OP_REPEAT:\r
- /* create repeat context. all the hard work is done\r
- by the UNTIL operator (MAX_UNTIL, MIN_UNTIL) */\r
- /* <REPEAT> <skip> <1=min> <2=max> item <UNTIL> tail */\r
- TRACE(("|%p|%p|REPEAT %d %d\n", ctx->pattern, ctx->ptr,\r
- ctx->pattern[1], ctx->pattern[2]));\r
-\r
- /* install new repeat context */\r
- ctx->u.rep = (SRE_REPEAT*) PyObject_MALLOC(sizeof(*ctx->u.rep));\r
- if (!ctx->u.rep) {\r
- PyErr_NoMemory();\r
- RETURN_FAILURE;\r
- }\r
- ctx->u.rep->count = -1;\r
- ctx->u.rep->pattern = ctx->pattern;\r
- ctx->u.rep->prev = state->repeat;\r
- ctx->u.rep->last_ptr = NULL;\r
- state->repeat = ctx->u.rep;\r
-\r
- state->ptr = ctx->ptr;\r
- DO_JUMP(JUMP_REPEAT, jump_repeat, ctx->pattern+ctx->pattern[0]);\r
- state->repeat = ctx->u.rep->prev;\r
- PyObject_FREE(ctx->u.rep);\r
-\r
- if (ret) {\r
- RETURN_ON_ERROR(ret);\r
- RETURN_SUCCESS;\r
- }\r
- RETURN_FAILURE;\r
-\r
- case SRE_OP_MAX_UNTIL:\r
- /* maximizing repeat */\r
- /* <REPEAT> <skip> <1=min> <2=max> item <MAX_UNTIL> tail */\r
-\r
- /* FIXME: we probably need to deal with zero-width\r
- matches in here... */\r
-\r
- ctx->u.rep = state->repeat;\r
- if (!ctx->u.rep)\r
- RETURN_ERROR(SRE_ERROR_STATE);\r
-\r
- state->ptr = ctx->ptr;\r
-\r
- ctx->count = ctx->u.rep->count+1;\r
-\r
- TRACE(("|%p|%p|MAX_UNTIL %d\n", ctx->pattern,\r
- ctx->ptr, ctx->count));\r
-\r
- if (ctx->count < ctx->u.rep->pattern[1]) {\r
- /* not enough matches */\r
- ctx->u.rep->count = ctx->count;\r
- DO_JUMP(JUMP_MAX_UNTIL_1, jump_max_until_1,\r
- ctx->u.rep->pattern+3);\r
- if (ret) {\r
- RETURN_ON_ERROR(ret);\r
- RETURN_SUCCESS;\r
- }\r
- ctx->u.rep->count = ctx->count-1;\r
- state->ptr = ctx->ptr;\r
- RETURN_FAILURE;\r
- }\r
-\r
- if ((ctx->count < ctx->u.rep->pattern[2] ||\r
- ctx->u.rep->pattern[2] == 65535) &&\r
- state->ptr != ctx->u.rep->last_ptr) {\r
- /* we may have enough matches, but if we can\r
- match another item, do so */\r
- ctx->u.rep->count = ctx->count;\r
- LASTMARK_SAVE();\r
- MARK_PUSH(ctx->lastmark);\r
- /* zero-width match protection */\r
- DATA_PUSH(&ctx->u.rep->last_ptr);\r
- ctx->u.rep->last_ptr = state->ptr;\r
- DO_JUMP(JUMP_MAX_UNTIL_2, jump_max_until_2,\r
- ctx->u.rep->pattern+3);\r
- DATA_POP(&ctx->u.rep->last_ptr);\r
- if (ret) {\r
- MARK_POP_DISCARD(ctx->lastmark);\r
- RETURN_ON_ERROR(ret);\r
- RETURN_SUCCESS;\r
- }\r
- MARK_POP(ctx->lastmark);\r
- LASTMARK_RESTORE();\r
- ctx->u.rep->count = ctx->count-1;\r
- state->ptr = ctx->ptr;\r
- }\r
-\r
- /* cannot match more repeated items here. make sure the\r
- tail matches */\r
- state->repeat = ctx->u.rep->prev;\r
- DO_JUMP(JUMP_MAX_UNTIL_3, jump_max_until_3, ctx->pattern);\r
- RETURN_ON_SUCCESS(ret);\r
- state->repeat = ctx->u.rep;\r
- state->ptr = ctx->ptr;\r
- RETURN_FAILURE;\r
-\r
- case SRE_OP_MIN_UNTIL:\r
- /* minimizing repeat */\r
- /* <REPEAT> <skip> <1=min> <2=max> item <MIN_UNTIL> tail */\r
-\r
- ctx->u.rep = state->repeat;\r
- if (!ctx->u.rep)\r
- RETURN_ERROR(SRE_ERROR_STATE);\r
-\r
- state->ptr = ctx->ptr;\r
-\r
- ctx->count = ctx->u.rep->count+1;\r
-\r
- TRACE(("|%p|%p|MIN_UNTIL %d %p\n", ctx->pattern,\r
- ctx->ptr, ctx->count, ctx->u.rep->pattern));\r
-\r
- if (ctx->count < ctx->u.rep->pattern[1]) {\r
- /* not enough matches */\r
- ctx->u.rep->count = ctx->count;\r
- DO_JUMP(JUMP_MIN_UNTIL_1, jump_min_until_1,\r
- ctx->u.rep->pattern+3);\r
- if (ret) {\r
- RETURN_ON_ERROR(ret);\r
- RETURN_SUCCESS;\r
- }\r
- ctx->u.rep->count = ctx->count-1;\r
- state->ptr = ctx->ptr;\r
- RETURN_FAILURE;\r
- }\r
-\r
- LASTMARK_SAVE();\r
-\r
- /* see if the tail matches */\r
- state->repeat = ctx->u.rep->prev;\r
- DO_JUMP(JUMP_MIN_UNTIL_2, jump_min_until_2, ctx->pattern);\r
- if (ret) {\r
- RETURN_ON_ERROR(ret);\r
- RETURN_SUCCESS;\r
- }\r
-\r
- state->repeat = ctx->u.rep;\r
- state->ptr = ctx->ptr;\r
-\r
- LASTMARK_RESTORE();\r
-\r
- if (ctx->count >= ctx->u.rep->pattern[2]\r
- && ctx->u.rep->pattern[2] != 65535)\r
- RETURN_FAILURE;\r
-\r
- ctx->u.rep->count = ctx->count;\r
- DO_JUMP(JUMP_MIN_UNTIL_3,jump_min_until_3,\r
- ctx->u.rep->pattern+3);\r
- if (ret) {\r
- RETURN_ON_ERROR(ret);\r
- RETURN_SUCCESS;\r
- }\r
- ctx->u.rep->count = ctx->count-1;\r
- state->ptr = ctx->ptr;\r
- RETURN_FAILURE;\r
-\r
- case SRE_OP_GROUPREF:\r
- /* match backreference */\r
- TRACE(("|%p|%p|GROUPREF %d\n", ctx->pattern,\r
- ctx->ptr, ctx->pattern[0]));\r
- i = ctx->pattern[0];\r
- {\r
- Py_ssize_t groupref = i+i;\r
- if (groupref >= state->lastmark) {\r
- RETURN_FAILURE;\r
- } else {\r
- SRE_CHAR* p = (SRE_CHAR*) state->mark[groupref];\r
- SRE_CHAR* e = (SRE_CHAR*) state->mark[groupref+1];\r
- if (!p || !e || e < p)\r
- RETURN_FAILURE;\r
- while (p < e) {\r
- if (ctx->ptr >= end || *ctx->ptr != *p)\r
- RETURN_FAILURE;\r
- p++; ctx->ptr++;\r
- }\r
- }\r
- }\r
- ctx->pattern++;\r
- break;\r
-\r
- case SRE_OP_GROUPREF_IGNORE:\r
- /* match backreference */\r
- TRACE(("|%p|%p|GROUPREF_IGNORE %d\n", ctx->pattern,\r
- ctx->ptr, ctx->pattern[0]));\r
- i = ctx->pattern[0];\r
- {\r
- Py_ssize_t groupref = i+i;\r
- if (groupref >= state->lastmark) {\r
- RETURN_FAILURE;\r
- } else {\r
- SRE_CHAR* p = (SRE_CHAR*) state->mark[groupref];\r
- SRE_CHAR* e = (SRE_CHAR*) state->mark[groupref+1];\r
- if (!p || !e || e < p)\r
- RETURN_FAILURE;\r
- while (p < e) {\r
- if (ctx->ptr >= end ||\r
- state->lower(*ctx->ptr) != state->lower(*p))\r
- RETURN_FAILURE;\r
- p++; ctx->ptr++;\r
- }\r
- }\r
- }\r
- ctx->pattern++;\r
- break;\r
-\r
- case SRE_OP_GROUPREF_EXISTS:\r
- TRACE(("|%p|%p|GROUPREF_EXISTS %d\n", ctx->pattern,\r
- ctx->ptr, ctx->pattern[0]));\r
- /* <GROUPREF_EXISTS> <group> <skip> codeyes <JUMP> codeno ... */\r
- i = ctx->pattern[0];\r
- {\r
- Py_ssize_t groupref = i+i;\r
- if (groupref >= state->lastmark) {\r
- ctx->pattern += ctx->pattern[1];\r
- break;\r
- } else {\r
- SRE_CHAR* p = (SRE_CHAR*) state->mark[groupref];\r
- SRE_CHAR* e = (SRE_CHAR*) state->mark[groupref+1];\r
- if (!p || !e || e < p) {\r
- ctx->pattern += ctx->pattern[1];\r
- break;\r
- }\r
- }\r
- }\r
- ctx->pattern += 2;\r
- break;\r
-\r
- case SRE_OP_ASSERT:\r
- /* assert subpattern */\r
- /* <ASSERT> <skip> <back> <pattern> */\r
- TRACE(("|%p|%p|ASSERT %d\n", ctx->pattern,\r
- ctx->ptr, ctx->pattern[1]));\r
- state->ptr = ctx->ptr - ctx->pattern[1];\r
- if (state->ptr < state->beginning)\r
- RETURN_FAILURE;\r
- DO_JUMP(JUMP_ASSERT, jump_assert, ctx->pattern+2);\r
- RETURN_ON_FAILURE(ret);\r
- ctx->pattern += ctx->pattern[0];\r
- break;\r
-\r
- case SRE_OP_ASSERT_NOT:\r
- /* assert not subpattern */\r
- /* <ASSERT_NOT> <skip> <back> <pattern> */\r
- TRACE(("|%p|%p|ASSERT_NOT %d\n", ctx->pattern,\r
- ctx->ptr, ctx->pattern[1]));\r
- state->ptr = ctx->ptr - ctx->pattern[1];\r
- if (state->ptr >= state->beginning) {\r
- DO_JUMP(JUMP_ASSERT_NOT, jump_assert_not, ctx->pattern+2);\r
- if (ret) {\r
- RETURN_ON_ERROR(ret);\r
- RETURN_FAILURE;\r
- }\r
- }\r
- ctx->pattern += ctx->pattern[0];\r
- break;\r
-\r
- case SRE_OP_FAILURE:\r
- /* immediate failure */\r
- TRACE(("|%p|%p|FAILURE\n", ctx->pattern, ctx->ptr));\r
- RETURN_FAILURE;\r
-\r
- default:\r
- TRACE(("|%p|%p|UNKNOWN %d\n", ctx->pattern, ctx->ptr,\r
- ctx->pattern[-1]));\r
- RETURN_ERROR(SRE_ERROR_ILLEGAL);\r
- }\r
- }\r
-\r
-exit:\r
- ctx_pos = ctx->last_ctx_pos;\r
- jump = ctx->jump;\r
- DATA_POP_DISCARD(ctx);\r
- if (ctx_pos == -1)\r
- return ret;\r
- DATA_LOOKUP_AT(SRE_MATCH_CONTEXT, ctx, ctx_pos);\r
-\r
- switch (jump) {\r
- case JUMP_MAX_UNTIL_2:\r
- TRACE(("|%p|%p|JUMP_MAX_UNTIL_2\n", ctx->pattern, ctx->ptr));\r
- goto jump_max_until_2;\r
- case JUMP_MAX_UNTIL_3:\r
- TRACE(("|%p|%p|JUMP_MAX_UNTIL_3\n", ctx->pattern, ctx->ptr));\r
- goto jump_max_until_3;\r
- case JUMP_MIN_UNTIL_2:\r
- TRACE(("|%p|%p|JUMP_MIN_UNTIL_2\n", ctx->pattern, ctx->ptr));\r
- goto jump_min_until_2;\r
- case JUMP_MIN_UNTIL_3:\r
- TRACE(("|%p|%p|JUMP_MIN_UNTIL_3\n", ctx->pattern, ctx->ptr));\r
- goto jump_min_until_3;\r
- case JUMP_BRANCH:\r
- TRACE(("|%p|%p|JUMP_BRANCH\n", ctx->pattern, ctx->ptr));\r
- goto jump_branch;\r
- case JUMP_MAX_UNTIL_1:\r
- TRACE(("|%p|%p|JUMP_MAX_UNTIL_1\n", ctx->pattern, ctx->ptr));\r
- goto jump_max_until_1;\r
- case JUMP_MIN_UNTIL_1:\r
- TRACE(("|%p|%p|JUMP_MIN_UNTIL_1\n", ctx->pattern, ctx->ptr));\r
- goto jump_min_until_1;\r
- case JUMP_REPEAT:\r
- TRACE(("|%p|%p|JUMP_REPEAT\n", ctx->pattern, ctx->ptr));\r
- goto jump_repeat;\r
- case JUMP_REPEAT_ONE_1:\r
- TRACE(("|%p|%p|JUMP_REPEAT_ONE_1\n", ctx->pattern, ctx->ptr));\r
- goto jump_repeat_one_1;\r
- case JUMP_REPEAT_ONE_2:\r
- TRACE(("|%p|%p|JUMP_REPEAT_ONE_2\n", ctx->pattern, ctx->ptr));\r
- goto jump_repeat_one_2;\r
- case JUMP_MIN_REPEAT_ONE:\r
- TRACE(("|%p|%p|JUMP_MIN_REPEAT_ONE\n", ctx->pattern, ctx->ptr));\r
- goto jump_min_repeat_one;\r
- case JUMP_ASSERT:\r
- TRACE(("|%p|%p|JUMP_ASSERT\n", ctx->pattern, ctx->ptr));\r
- goto jump_assert;\r
- case JUMP_ASSERT_NOT:\r
- TRACE(("|%p|%p|JUMP_ASSERT_NOT\n", ctx->pattern, ctx->ptr));\r
- goto jump_assert_not;\r
- case JUMP_NONE:\r
- TRACE(("|%p|%p|RETURN %d\n", ctx->pattern, ctx->ptr, ret));\r
- break;\r
- }\r
-\r
- return ret; /* should never get here */\r
-}\r
-\r
-LOCAL(Py_ssize_t)\r
-SRE_SEARCH(SRE_STATE* state, SRE_CODE* pattern)\r
-{\r
- SRE_CHAR* ptr = (SRE_CHAR *)state->start;\r
- SRE_CHAR* end = (SRE_CHAR *)state->end;\r
- Py_ssize_t status = 0;\r
- Py_ssize_t prefix_len = 0;\r
- Py_ssize_t prefix_skip = 0;\r
- SRE_CODE* prefix = NULL;\r
- SRE_CODE* charset = NULL;\r
- SRE_CODE* overlap = NULL;\r
- int flags = 0;\r
-\r
- if (pattern[0] == SRE_OP_INFO) {\r
- /* optimization info block */\r
- /* <INFO> <1=skip> <2=flags> <3=min> <4=max> <5=prefix info> */\r
-\r
- flags = pattern[2];\r
-\r
- if (pattern[3] > 1) {\r
- /* adjust end point (but make sure we leave at least one\r
- character in there, so literal search will work) */\r
- end -= pattern[3]-1;\r
- if (end <= ptr)\r
- end = ptr+1;\r
- }\r
-\r
- if (flags & SRE_INFO_PREFIX) {\r
- /* pattern starts with a known prefix */\r
- /* <length> <skip> <prefix data> <overlap data> */\r
- prefix_len = pattern[5];\r
- prefix_skip = pattern[6];\r
- prefix = pattern + 7;\r
- overlap = prefix + prefix_len - 1;\r
- } else if (flags & SRE_INFO_CHARSET)\r
- /* pattern starts with a character from a known set */\r
- /* <charset> */\r
- charset = pattern + 5;\r
-\r
- pattern += 1 + pattern[1];\r
- }\r
-\r
- TRACE(("prefix = %p %d %d\n", prefix, prefix_len, prefix_skip));\r
- TRACE(("charset = %p\n", charset));\r
-\r
-#if defined(USE_FAST_SEARCH)\r
- if (prefix_len > 1) {\r
- /* pattern starts with a known prefix. use the overlap\r
- table to skip forward as fast as we possibly can */\r
- Py_ssize_t i = 0;\r
- end = (SRE_CHAR *)state->end;\r
- while (ptr < end) {\r
- for (;;) {\r
- if ((SRE_CODE) ptr[0] != prefix[i]) {\r
- if (!i)\r
- break;\r
- else\r
- i = overlap[i];\r
- } else {\r
- if (++i == prefix_len) {\r
- /* found a potential match */\r
- TRACE(("|%p|%p|SEARCH SCAN\n", pattern, ptr));\r
- state->start = ptr + 1 - prefix_len;\r
- state->ptr = ptr + 1 - prefix_len + prefix_skip;\r
- if (flags & SRE_INFO_LITERAL)\r
- return 1; /* we got all of it */\r
- status = SRE_MATCH(state, pattern + 2*prefix_skip);\r
- if (status != 0)\r
- return status;\r
- /* close but no cigar -- try again */\r
- i = overlap[i];\r
- }\r
- break;\r
- }\r
- }\r
- ptr++;\r
- }\r
- return 0;\r
- }\r
-#endif\r
-\r
- if (pattern[0] == SRE_OP_LITERAL) {\r
- /* pattern starts with a literal character. this is used\r
- for short prefixes, and if fast search is disabled */\r
- SRE_CODE chr = pattern[1];\r
- end = (SRE_CHAR *)state->end;\r
- for (;;) {\r
- while (ptr < end && (SRE_CODE) ptr[0] != chr)\r
- ptr++;\r
- if (ptr >= end)\r
- return 0;\r
- TRACE(("|%p|%p|SEARCH LITERAL\n", pattern, ptr));\r
- state->start = ptr;\r
- state->ptr = ++ptr;\r
- if (flags & SRE_INFO_LITERAL)\r
- return 1; /* we got all of it */\r
- status = SRE_MATCH(state, pattern + 2);\r
- if (status != 0)\r
- break;\r
- }\r
- } else if (charset) {\r
- /* pattern starts with a character from a known set */\r
- end = (SRE_CHAR *)state->end;\r
- for (;;) {\r
- while (ptr < end && !SRE_CHARSET(charset, ptr[0]))\r
- ptr++;\r
- if (ptr >= end)\r
- return 0;\r
- TRACE(("|%p|%p|SEARCH CHARSET\n", pattern, ptr));\r
- state->start = ptr;\r
- state->ptr = ptr;\r
- status = SRE_MATCH(state, pattern);\r
- if (status != 0)\r
- break;\r
- ptr++;\r
- }\r
- } else\r
- /* general case */\r
- while (ptr <= end) {\r
- TRACE(("|%p|%p|SEARCH\n", pattern, ptr));\r
- state->start = state->ptr = ptr++;\r
- status = SRE_MATCH(state, pattern);\r
- if (status != 0)\r
- break;\r
- }\r
-\r
- return status;\r
-}\r
-\r
-LOCAL(int)\r
-SRE_LITERAL_TEMPLATE(SRE_CHAR* ptr, Py_ssize_t len)\r
-{\r
- /* check if given string is a literal template (i.e. no escapes) */\r
- while (len-- > 0)\r
- if (*ptr++ == '\\')\r
- return 0;\r
- return 1;\r
-}\r
-\r
-#if !defined(SRE_RECURSIVE)\r
-\r
-/* -------------------------------------------------------------------- */\r
-/* factories and destructors */\r
-\r
-/* see sre.h for object declarations */\r
-static PyObject*pattern_new_match(PatternObject*, SRE_STATE*, int);\r
-static PyObject*pattern_scanner(PatternObject*, PyObject*);\r
-\r
-static PyObject *\r
-sre_codesize(PyObject* self, PyObject *unused)\r
-{\r
- return Py_BuildValue("l", sizeof(SRE_CODE));\r
-}\r
-\r
-static PyObject *\r
-sre_getlower(PyObject* self, PyObject* args)\r
-{\r
- int character, flags;\r
- if (!PyArg_ParseTuple(args, "ii", &character, &flags))\r
- return NULL;\r
- if (flags & SRE_FLAG_LOCALE)\r
- return Py_BuildValue("i", sre_lower_locale(character));\r
- if (flags & SRE_FLAG_UNICODE)\r
-#if defined(HAVE_UNICODE)\r
- return Py_BuildValue("i", sre_lower_unicode(character));\r
-#else\r
- return Py_BuildValue("i", sre_lower_locale(character));\r
-#endif\r
- return Py_BuildValue("i", sre_lower(character));\r
-}\r
-\r
-LOCAL(void)\r
-state_reset(SRE_STATE* state)\r
-{\r
- /* FIXME: dynamic! */\r
- /*memset(state->mark, 0, sizeof(*state->mark) * SRE_MARK_SIZE);*/\r
-\r
- state->lastmark = -1;\r
- state->lastindex = -1;\r
-\r
- state->repeat = NULL;\r
-\r
- data_stack_dealloc(state);\r
-}\r
-\r
-static void*\r
-getstring(PyObject* string, Py_ssize_t* p_length, int* p_charsize)\r
-{\r
- /* given a python object, return a data pointer, a length (in\r
- characters), and a character size. return NULL if the object\r
- is not a string (or not compatible) */\r
-\r
- PyBufferProcs *buffer;\r
- Py_ssize_t size, bytes;\r
- int charsize;\r
- void* ptr;\r
-\r
-#if defined(HAVE_UNICODE)\r
- if (PyUnicode_Check(string)) {\r
- /* unicode strings doesn't always support the buffer interface */\r
- ptr = (void*) PyUnicode_AS_DATA(string);\r
- /* bytes = PyUnicode_GET_DATA_SIZE(string); */\r
- size = PyUnicode_GET_SIZE(string);\r
- charsize = sizeof(Py_UNICODE);\r
-\r
- } else {\r
-#endif\r
-\r
- /* get pointer to string buffer */\r
- buffer = Py_TYPE(string)->tp_as_buffer;\r
- if (!buffer || !buffer->bf_getreadbuffer || !buffer->bf_getsegcount ||\r
- buffer->bf_getsegcount(string, NULL) != 1) {\r
- PyErr_SetString(PyExc_TypeError, "expected string or buffer");\r
- return NULL;\r
- }\r
-\r
- /* determine buffer size */\r
- bytes = buffer->bf_getreadbuffer(string, 0, &ptr);\r
- if (bytes < 0) {\r
- PyErr_SetString(PyExc_TypeError, "buffer has negative size");\r
- return NULL;\r
- }\r
-\r
- /* determine character size */\r
-#if PY_VERSION_HEX >= 0x01060000\r
- size = PyObject_Size(string);\r
-#else\r
- size = PyObject_Length(string);\r
-#endif\r
-\r
- if (PyString_Check(string) || bytes == size)\r
- charsize = 1;\r
-#if defined(HAVE_UNICODE)\r
- else if (bytes == (Py_ssize_t) (size * sizeof(Py_UNICODE)))\r
- charsize = sizeof(Py_UNICODE);\r
-#endif\r
- else {\r
- PyErr_SetString(PyExc_TypeError, "buffer size mismatch");\r
- return NULL;\r
- }\r
-\r
-#if defined(HAVE_UNICODE)\r
- }\r
-#endif\r
-\r
- *p_length = size;\r
- *p_charsize = charsize;\r
-\r
- return ptr;\r
-}\r
-\r
-LOCAL(PyObject*)\r
-state_init(SRE_STATE* state, PatternObject* pattern, PyObject* string,\r
- Py_ssize_t start, Py_ssize_t end)\r
-{\r
- /* prepare state object */\r
-\r
- Py_ssize_t length;\r
- int charsize;\r
- void* ptr;\r
-\r
- memset(state, 0, sizeof(SRE_STATE));\r
-\r
- state->lastmark = -1;\r
- state->lastindex = -1;\r
-\r
- ptr = getstring(string, &length, &charsize);\r
- if (!ptr)\r
- return NULL;\r
-\r
- /* adjust boundaries */\r
- if (start < 0)\r
- start = 0;\r
- else if (start > length)\r
- start = length;\r
-\r
- if (end < 0)\r
- end = 0;\r
- else if (end > length)\r
- end = length;\r
-\r
- state->charsize = charsize;\r
-\r
- state->beginning = ptr;\r
-\r
- state->start = (void*) ((char*) ptr + start * state->charsize);\r
- state->end = (void*) ((char*) ptr + end * state->charsize);\r
-\r
- Py_INCREF(string);\r
- state->string = string;\r
- state->pos = start;\r
- state->endpos = end;\r
-\r
- if (pattern->flags & SRE_FLAG_LOCALE)\r
- state->lower = sre_lower_locale;\r
- else if (pattern->flags & SRE_FLAG_UNICODE)\r
-#if defined(HAVE_UNICODE)\r
- state->lower = sre_lower_unicode;\r
-#else\r
- state->lower = sre_lower_locale;\r
-#endif\r
- else\r
- state->lower = sre_lower;\r
-\r
- return string;\r
-}\r
-\r
-LOCAL(void)\r
-state_fini(SRE_STATE* state)\r
-{\r
- Py_XDECREF(state->string);\r
- data_stack_dealloc(state);\r
-}\r
-\r
-/* calculate offset from start of string */\r
-#define STATE_OFFSET(state, member)\\r
- (((char*)(member) - (char*)(state)->beginning) / (state)->charsize)\r
-\r
-LOCAL(PyObject*)\r
-state_getslice(SRE_STATE* state, Py_ssize_t index, PyObject* string, int empty)\r
-{\r
- Py_ssize_t i, j;\r
-\r
- index = (index - 1) * 2;\r
-\r
- if (string == Py_None || index >= state->lastmark || !state->mark[index] || !state->mark[index+1]) {\r
- if (empty)\r
- /* want empty string */\r
- i = j = 0;\r
- else {\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
- } else {\r
- i = STATE_OFFSET(state, state->mark[index]);\r
- j = STATE_OFFSET(state, state->mark[index+1]);\r
- }\r
-\r
- return PySequence_GetSlice(string, i, j);\r
-}\r
-\r
-static void\r
-pattern_error(int status)\r
-{\r
- switch (status) {\r
- case SRE_ERROR_RECURSION_LIMIT:\r
- PyErr_SetString(\r
- PyExc_RuntimeError,\r
- "maximum recursion limit exceeded"\r
- );\r
- break;\r
- case SRE_ERROR_MEMORY:\r
- PyErr_NoMemory();\r
- break;\r
- case SRE_ERROR_INTERRUPTED:\r
- /* An exception has already been raised, so let it fly */\r
- break;\r
- default:\r
- /* other error codes indicate compiler/engine bugs */\r
- PyErr_SetString(\r
- PyExc_RuntimeError,\r
- "internal error in regular expression engine"\r
- );\r
- }\r
-}\r
-\r
-static void\r
-pattern_dealloc(PatternObject* self)\r
-{\r
- if (self->weakreflist != NULL)\r
- PyObject_ClearWeakRefs((PyObject *) self);\r
- Py_XDECREF(self->pattern);\r
- Py_XDECREF(self->groupindex);\r
- Py_XDECREF(self->indexgroup);\r
- PyObject_DEL(self);\r
-}\r
-\r
-static PyObject*\r
-pattern_match(PatternObject* self, PyObject* args, PyObject* kw)\r
-{\r
- SRE_STATE state;\r
- int status;\r
-\r
- PyObject* string;\r
- Py_ssize_t start = 0;\r
- Py_ssize_t end = PY_SSIZE_T_MAX;\r
- static char* kwlist[] = { "pattern", "pos", "endpos", NULL };\r
- if (!PyArg_ParseTupleAndKeywords(args, kw, "O|nn:match", kwlist,\r
- &string, &start, &end))\r
- return NULL;\r
-\r
- string = state_init(&state, self, string, start, end);\r
- if (!string)\r
- return NULL;\r
-\r
- state.ptr = state.start;\r
-\r
- TRACE(("|%p|%p|MATCH\n", PatternObject_GetCode(self), state.ptr));\r
-\r
- if (state.charsize == 1) {\r
- status = sre_match(&state, PatternObject_GetCode(self));\r
- } else {\r
-#if defined(HAVE_UNICODE)\r
- status = sre_umatch(&state, PatternObject_GetCode(self));\r
-#endif\r
- }\r
-\r
- TRACE(("|%p|%p|END\n", PatternObject_GetCode(self), state.ptr));\r
- if (PyErr_Occurred())\r
- return NULL;\r
-\r
- state_fini(&state);\r
-\r
- return pattern_new_match(self, &state, status);\r
-}\r
-\r
-static PyObject*\r
-pattern_search(PatternObject* self, PyObject* args, PyObject* kw)\r
-{\r
- SRE_STATE state;\r
- int status;\r
-\r
- PyObject* string;\r
- Py_ssize_t start = 0;\r
- Py_ssize_t end = PY_SSIZE_T_MAX;\r
- static char* kwlist[] = { "pattern", "pos", "endpos", NULL };\r
- if (!PyArg_ParseTupleAndKeywords(args, kw, "O|nn:search", kwlist,\r
- &string, &start, &end))\r
- return NULL;\r
-\r
- string = state_init(&state, self, string, start, end);\r
- if (!string)\r
- return NULL;\r
-\r
- TRACE(("|%p|%p|SEARCH\n", PatternObject_GetCode(self), state.ptr));\r
-\r
- if (state.charsize == 1) {\r
- status = sre_search(&state, PatternObject_GetCode(self));\r
- } else {\r
-#if defined(HAVE_UNICODE)\r
- status = sre_usearch(&state, PatternObject_GetCode(self));\r
-#endif\r
- }\r
-\r
- TRACE(("|%p|%p|END\n", PatternObject_GetCode(self), state.ptr));\r
-\r
- state_fini(&state);\r
-\r
- if (PyErr_Occurred())\r
- return NULL;\r
-\r
- return pattern_new_match(self, &state, status);\r
-}\r
-\r
-static PyObject*\r
-call(char* module, char* function, PyObject* args)\r
-{\r
- PyObject* name;\r
- PyObject* mod;\r
- PyObject* func;\r
- PyObject* result;\r
-\r
- if (!args)\r
- return NULL;\r
- name = PyString_FromString(module);\r
- if (!name)\r
- return NULL;\r
- mod = PyImport_Import(name);\r
- Py_DECREF(name);\r
- if (!mod)\r
- return NULL;\r
- func = PyObject_GetAttrString(mod, function);\r
- Py_DECREF(mod);\r
- if (!func)\r
- return NULL;\r
- result = PyObject_CallObject(func, args);\r
- Py_DECREF(func);\r
- Py_DECREF(args);\r
- return result;\r
-}\r
-\r
-#ifdef USE_BUILTIN_COPY\r
-static int\r
-deepcopy(PyObject** object, PyObject* memo)\r
-{\r
- PyObject* copy;\r
-\r
- copy = call(\r
- "copy", "deepcopy",\r
- PyTuple_Pack(2, *object, memo)\r
- );\r
- if (!copy)\r
- return 0;\r
-\r
- Py_DECREF(*object);\r
- *object = copy;\r
-\r
- return 1; /* success */\r
-}\r
-#endif\r
-\r
-static PyObject*\r
-join_list(PyObject* list, PyObject* string)\r
-{\r
- /* join list elements */\r
-\r
- PyObject* joiner;\r
-#if PY_VERSION_HEX >= 0x01060000\r
- PyObject* function;\r
- PyObject* args;\r
-#endif\r
- PyObject* result;\r
-\r
- joiner = PySequence_GetSlice(string, 0, 0);\r
- if (!joiner)\r
- return NULL;\r
-\r
- if (PyList_GET_SIZE(list) == 0) {\r
- Py_DECREF(list);\r
- return joiner;\r
- }\r
-\r
-#if PY_VERSION_HEX >= 0x01060000\r
- function = PyObject_GetAttrString(joiner, "join");\r
- if (!function) {\r
- Py_DECREF(joiner);\r
- return NULL;\r
- }\r
- args = PyTuple_New(1);\r
- if (!args) {\r
- Py_DECREF(function);\r
- Py_DECREF(joiner);\r
- return NULL;\r
- }\r
- PyTuple_SET_ITEM(args, 0, list);\r
- result = PyObject_CallObject(function, args);\r
- Py_DECREF(args); /* also removes list */\r
- Py_DECREF(function);\r
-#else\r
- result = call(\r
- "string", "join",\r
- PyTuple_Pack(2, list, joiner)\r
- );\r
-#endif\r
- Py_DECREF(joiner);\r
-\r
- return result;\r
-}\r
-\r
-static PyObject*\r
-pattern_findall(PatternObject* self, PyObject* args, PyObject* kw)\r
-{\r
- SRE_STATE state;\r
- PyObject* list;\r
- int status;\r
- Py_ssize_t i, b, e;\r
-\r
- PyObject* string;\r
- Py_ssize_t start = 0;\r
- Py_ssize_t end = PY_SSIZE_T_MAX;\r
- static char* kwlist[] = { "source", "pos", "endpos", NULL };\r
- if (!PyArg_ParseTupleAndKeywords(args, kw, "O|nn:findall", kwlist,\r
- &string, &start, &end))\r
- return NULL;\r
-\r
- string = state_init(&state, self, string, start, end);\r
- if (!string)\r
- return NULL;\r
-\r
- list = PyList_New(0);\r
- if (!list) {\r
- state_fini(&state);\r
- return NULL;\r
- }\r
-\r
- while (state.start <= state.end) {\r
-\r
- PyObject* item;\r
-\r
- state_reset(&state);\r
-\r
- state.ptr = state.start;\r
-\r
- if (state.charsize == 1) {\r
- status = sre_search(&state, PatternObject_GetCode(self));\r
- } else {\r
-#if defined(HAVE_UNICODE)\r
- status = sre_usearch(&state, PatternObject_GetCode(self));\r
-#endif\r
- }\r
-\r
- if (PyErr_Occurred())\r
- goto error;\r
-\r
- if (status <= 0) {\r
- if (status == 0)\r
- break;\r
- pattern_error(status);\r
- goto error;\r
- }\r
-\r
- /* don't bother to build a match object */\r
- switch (self->groups) {\r
- case 0:\r
- b = STATE_OFFSET(&state, state.start);\r
- e = STATE_OFFSET(&state, state.ptr);\r
- item = PySequence_GetSlice(string, b, e);\r
- if (!item)\r
- goto error;\r
- break;\r
- case 1:\r
- item = state_getslice(&state, 1, string, 1);\r
- if (!item)\r
- goto error;\r
- break;\r
- default:\r
- item = PyTuple_New(self->groups);\r
- if (!item)\r
- goto error;\r
- for (i = 0; i < self->groups; i++) {\r
- PyObject* o = state_getslice(&state, i+1, string, 1);\r
- if (!o) {\r
- Py_DECREF(item);\r
- goto error;\r
- }\r
- PyTuple_SET_ITEM(item, i, o);\r
- }\r
- break;\r
- }\r
-\r
- status = PyList_Append(list, item);\r
- Py_DECREF(item);\r
- if (status < 0)\r
- goto error;\r
-\r
- if (state.ptr == state.start)\r
- state.start = (void*) ((char*) state.ptr + state.charsize);\r
- else\r
- state.start = state.ptr;\r
-\r
- }\r
-\r
- state_fini(&state);\r
- return list;\r
-\r
-error:\r
- Py_DECREF(list);\r
- state_fini(&state);\r
- return NULL;\r
-\r
-}\r
-\r
-#if PY_VERSION_HEX >= 0x02020000\r
-static PyObject*\r
-pattern_finditer(PatternObject* pattern, PyObject* args)\r
-{\r
- PyObject* scanner;\r
- PyObject* search;\r
- PyObject* iterator;\r
-\r
- scanner = pattern_scanner(pattern, args);\r
- if (!scanner)\r
- return NULL;\r
-\r
- search = PyObject_GetAttrString(scanner, "search");\r
- Py_DECREF(scanner);\r
- if (!search)\r
- return NULL;\r
-\r
- iterator = PyCallIter_New(search, Py_None);\r
- Py_DECREF(search);\r
-\r
- return iterator;\r
-}\r
-#endif\r
-\r
-static PyObject*\r
-pattern_split(PatternObject* self, PyObject* args, PyObject* kw)\r
-{\r
- SRE_STATE state;\r
- PyObject* list;\r
- PyObject* item;\r
- int status;\r
- Py_ssize_t n;\r
- Py_ssize_t i;\r
- void* last;\r
-\r
- PyObject* string;\r
- Py_ssize_t maxsplit = 0;\r
- static char* kwlist[] = { "source", "maxsplit", NULL };\r
- if (!PyArg_ParseTupleAndKeywords(args, kw, "O|n:split", kwlist,\r
- &string, &maxsplit))\r
- return NULL;\r
-\r
- string = state_init(&state, self, string, 0, PY_SSIZE_T_MAX);\r
- if (!string)\r
- return NULL;\r
-\r
- list = PyList_New(0);\r
- if (!list) {\r
- state_fini(&state);\r
- return NULL;\r
- }\r
-\r
- n = 0;\r
- last = state.start;\r
-\r
- while (!maxsplit || n < maxsplit) {\r
-\r
- state_reset(&state);\r
-\r
- state.ptr = state.start;\r
-\r
- if (state.charsize == 1) {\r
- status = sre_search(&state, PatternObject_GetCode(self));\r
- } else {\r
-#if defined(HAVE_UNICODE)\r
- status = sre_usearch(&state, PatternObject_GetCode(self));\r
-#endif\r
- }\r
-\r
- if (PyErr_Occurred())\r
- goto error;\r
-\r
- if (status <= 0) {\r
- if (status == 0)\r
- break;\r
- pattern_error(status);\r
- goto error;\r
- }\r
-\r
- if (state.start == state.ptr) {\r
- if (last == state.end)\r
- break;\r
- /* skip one character */\r
- state.start = (void*) ((char*) state.ptr + state.charsize);\r
- continue;\r
- }\r
-\r
- /* get segment before this match */\r
- item = PySequence_GetSlice(\r
- string, STATE_OFFSET(&state, last),\r
- STATE_OFFSET(&state, state.start)\r
- );\r
- if (!item)\r
- goto error;\r
- status = PyList_Append(list, item);\r
- Py_DECREF(item);\r
- if (status < 0)\r
- goto error;\r
-\r
- /* add groups (if any) */\r
- for (i = 0; i < self->groups; i++) {\r
- item = state_getslice(&state, i+1, string, 0);\r
- if (!item)\r
- goto error;\r
- status = PyList_Append(list, item);\r
- Py_DECREF(item);\r
- if (status < 0)\r
- goto error;\r
- }\r
-\r
- n = n + 1;\r
-\r
- last = state.start = state.ptr;\r
-\r
- }\r
-\r
- /* get segment following last match (even if empty) */\r
- item = PySequence_GetSlice(\r
- string, STATE_OFFSET(&state, last), state.endpos\r
- );\r
- if (!item)\r
- goto error;\r
- status = PyList_Append(list, item);\r
- Py_DECREF(item);\r
- if (status < 0)\r
- goto error;\r
-\r
- state_fini(&state);\r
- return list;\r
-\r
-error:\r
- Py_DECREF(list);\r
- state_fini(&state);\r
- return NULL;\r
-\r
-}\r
-\r
-static PyObject*\r
-pattern_subx(PatternObject* self, PyObject* ptemplate, PyObject* string,\r
- Py_ssize_t count, Py_ssize_t subn)\r
-{\r
- SRE_STATE state;\r
- PyObject* list;\r
- PyObject* item;\r
- PyObject* filter;\r
- PyObject* args;\r
- PyObject* match;\r
- void* ptr;\r
- int status;\r
- Py_ssize_t n;\r
- Py_ssize_t i, b, e;\r
- int bint;\r
- int filter_is_callable;\r
-\r
- if (PyCallable_Check(ptemplate)) {\r
- /* sub/subn takes either a function or a template */\r
- filter = ptemplate;\r
- Py_INCREF(filter);\r
- filter_is_callable = 1;\r
- } else {\r
- /* if not callable, check if it's a literal string */\r
- int literal;\r
- ptr = getstring(ptemplate, &n, &bint);\r
- b = bint;\r
- if (ptr) {\r
- if (b == 1) {\r
- literal = sre_literal_template((unsigned char *)ptr, n);\r
- } else {\r
-#if defined(HAVE_UNICODE)\r
- literal = sre_uliteral_template((Py_UNICODE *)ptr, n);\r
-#endif\r
- }\r
- } else {\r
- PyErr_Clear();\r
- literal = 0;\r
- }\r
- if (literal) {\r
- filter = ptemplate;\r
- Py_INCREF(filter);\r
- filter_is_callable = 0;\r
- } else {\r
- /* not a literal; hand it over to the template compiler */\r
- filter = call(\r
- SRE_PY_MODULE, "_subx",\r
- PyTuple_Pack(2, self, ptemplate)\r
- );\r
- if (!filter)\r
- return NULL;\r
- filter_is_callable = PyCallable_Check(filter);\r
- }\r
- }\r
-\r
- string = state_init(&state, self, string, 0, PY_SSIZE_T_MAX);\r
- if (!string) {\r
- Py_DECREF(filter);\r
- return NULL;\r
- }\r
-\r
- list = PyList_New(0);\r
- if (!list) {\r
- Py_DECREF(filter);\r
- state_fini(&state);\r
- return NULL;\r
- }\r
-\r
- n = i = 0;\r
-\r
- while (!count || n < count) {\r
-\r
- state_reset(&state);\r
-\r
- state.ptr = state.start;\r
-\r
- if (state.charsize == 1) {\r
- status = sre_search(&state, PatternObject_GetCode(self));\r
- } else {\r
-#if defined(HAVE_UNICODE)\r
- status = sre_usearch(&state, PatternObject_GetCode(self));\r
-#endif\r
- }\r
-\r
- if (PyErr_Occurred())\r
- goto error;\r
-\r
- if (status <= 0) {\r
- if (status == 0)\r
- break;\r
- pattern_error(status);\r
- goto error;\r
- }\r
-\r
- b = STATE_OFFSET(&state, state.start);\r
- e = STATE_OFFSET(&state, state.ptr);\r
-\r
- if (i < b) {\r
- /* get segment before this match */\r
- item = PySequence_GetSlice(string, i, b);\r
- if (!item)\r
- goto error;\r
- status = PyList_Append(list, item);\r
- Py_DECREF(item);\r
- if (status < 0)\r
- goto error;\r
-\r
- } else if (i == b && i == e && n > 0)\r
- /* ignore empty match on latest position */\r
- goto next;\r
-\r
- if (filter_is_callable) {\r
- /* pass match object through filter */\r
- match = pattern_new_match(self, &state, 1);\r
- if (!match)\r
- goto error;\r
- args = PyTuple_Pack(1, match);\r
- if (!args) {\r
- Py_DECREF(match);\r
- goto error;\r
- }\r
- item = PyObject_CallObject(filter, args);\r
- Py_DECREF(args);\r
- Py_DECREF(match);\r
- if (!item)\r
- goto error;\r
- } else {\r
- /* filter is literal string */\r
- item = filter;\r
- Py_INCREF(item);\r
- }\r
-\r
- /* add to list */\r
- if (item != Py_None) {\r
- status = PyList_Append(list, item);\r
- Py_DECREF(item);\r
- if (status < 0)\r
- goto error;\r
- }\r
-\r
- i = e;\r
- n = n + 1;\r
-\r
-next:\r
- /* move on */\r
- if (state.ptr == state.start)\r
- state.start = (void*) ((char*) state.ptr + state.charsize);\r
- else\r
- state.start = state.ptr;\r
-\r
- }\r
-\r
- /* get segment following last match */\r
- if (i < state.endpos) {\r
- item = PySequence_GetSlice(string, i, state.endpos);\r
- if (!item)\r
- goto error;\r
- status = PyList_Append(list, item);\r
- Py_DECREF(item);\r
- if (status < 0)\r
- goto error;\r
- }\r
-\r
- state_fini(&state);\r
-\r
- Py_DECREF(filter);\r
-\r
- /* convert list to single string (also removes list) */\r
- item = join_list(list, string);\r
-\r
- if (!item)\r
- return NULL;\r
-\r
- if (subn)\r
- return Py_BuildValue("Ni", item, n);\r
-\r
- return item;\r
-\r
-error:\r
- Py_DECREF(list);\r
- state_fini(&state);\r
- Py_DECREF(filter);\r
- return NULL;\r
-\r
-}\r
-\r
-static PyObject*\r
-pattern_sub(PatternObject* self, PyObject* args, PyObject* kw)\r
-{\r
- PyObject* ptemplate;\r
- PyObject* string;\r
- Py_ssize_t count = 0;\r
- static char* kwlist[] = { "repl", "string", "count", NULL };\r
- if (!PyArg_ParseTupleAndKeywords(args, kw, "OO|n:sub", kwlist,\r
- &ptemplate, &string, &count))\r
- return NULL;\r
-\r
- return pattern_subx(self, ptemplate, string, count, 0);\r
-}\r
-\r
-static PyObject*\r
-pattern_subn(PatternObject* self, PyObject* args, PyObject* kw)\r
-{\r
- PyObject* ptemplate;\r
- PyObject* string;\r
- Py_ssize_t count = 0;\r
- static char* kwlist[] = { "repl", "string", "count", NULL };\r
- if (!PyArg_ParseTupleAndKeywords(args, kw, "OO|n:subn", kwlist,\r
- &ptemplate, &string, &count))\r
- return NULL;\r
-\r
- return pattern_subx(self, ptemplate, string, count, 1);\r
-}\r
-\r
-static PyObject*\r
-pattern_copy(PatternObject* self, PyObject *unused)\r
-{\r
-#ifdef USE_BUILTIN_COPY\r
- PatternObject* copy;\r
- int offset;\r
-\r
- copy = PyObject_NEW_VAR(PatternObject, &Pattern_Type, self->codesize);\r
- if (!copy)\r
- return NULL;\r
-\r
- offset = offsetof(PatternObject, groups);\r
-\r
- Py_XINCREF(self->groupindex);\r
- Py_XINCREF(self->indexgroup);\r
- Py_XINCREF(self->pattern);\r
-\r
- memcpy((char*) copy + offset, (char*) self + offset,\r
- sizeof(PatternObject) + self->codesize * sizeof(SRE_CODE) - offset);\r
- copy->weakreflist = NULL;\r
-\r
- return (PyObject*) copy;\r
-#else\r
- PyErr_SetString(PyExc_TypeError, "cannot copy this pattern object");\r
- return NULL;\r
-#endif\r
-}\r
-\r
-static PyObject*\r
-pattern_deepcopy(PatternObject* self, PyObject* memo)\r
-{\r
-#ifdef USE_BUILTIN_COPY\r
- PatternObject* copy;\r
-\r
- copy = (PatternObject*) pattern_copy(self);\r
- if (!copy)\r
- return NULL;\r
-\r
- if (!deepcopy(©->groupindex, memo) ||\r
- !deepcopy(©->indexgroup, memo) ||\r
- !deepcopy(©->pattern, memo)) {\r
- Py_DECREF(copy);\r
- return NULL;\r
- }\r
-\r
-#else\r
- PyErr_SetString(PyExc_TypeError, "cannot deepcopy this pattern object");\r
- return NULL;\r
-#endif\r
-}\r
-\r
-PyDoc_STRVAR(pattern_match_doc,\r
-"match(string[, pos[, endpos]]) --> match object or None.\n\\r
- Matches zero or more characters at the beginning of the string");\r
-\r
-PyDoc_STRVAR(pattern_search_doc,\r
-"search(string[, pos[, endpos]]) --> match object or None.\n\\r
- Scan through string looking for a match, and return a corresponding\n\\r
- MatchObject instance. Return None if no position in the string matches.");\r
-\r
-PyDoc_STRVAR(pattern_split_doc,\r
-"split(string[, maxsplit = 0]) --> list.\n\\r
- Split string by the occurrences of pattern.");\r
-\r
-PyDoc_STRVAR(pattern_findall_doc,\r
-"findall(string[, pos[, endpos]]) --> list.\n\\r
- Return a list of all non-overlapping matches of pattern in string.");\r
-\r
-PyDoc_STRVAR(pattern_finditer_doc,\r
-"finditer(string[, pos[, endpos]]) --> iterator.\n\\r
- Return an iterator over all non-overlapping matches for the \n\\r
- RE pattern in string. For each match, the iterator returns a\n\\r
- match object.");\r
-\r
-PyDoc_STRVAR(pattern_sub_doc,\r
-"sub(repl, string[, count = 0]) --> newstring\n\\r
- Return the string obtained by replacing the leftmost non-overlapping\n\\r
- occurrences of pattern in string by the replacement repl.");\r
-\r
-PyDoc_STRVAR(pattern_subn_doc,\r
-"subn(repl, string[, count = 0]) --> (newstring, number of subs)\n\\r
- Return the tuple (new_string, number_of_subs_made) found by replacing\n\\r
- the leftmost non-overlapping occurrences of pattern with the\n\\r
- replacement repl.");\r
-\r
-PyDoc_STRVAR(pattern_doc, "Compiled regular expression objects");\r
-\r
-static PyMethodDef pattern_methods[] = {\r
- {"match", (PyCFunction) pattern_match, METH_VARARGS|METH_KEYWORDS,\r
- pattern_match_doc},\r
- {"search", (PyCFunction) pattern_search, METH_VARARGS|METH_KEYWORDS,\r
- pattern_search_doc},\r
- {"sub", (PyCFunction) pattern_sub, METH_VARARGS|METH_KEYWORDS,\r
- pattern_sub_doc},\r
- {"subn", (PyCFunction) pattern_subn, METH_VARARGS|METH_KEYWORDS,\r
- pattern_subn_doc},\r
- {"split", (PyCFunction) pattern_split, METH_VARARGS|METH_KEYWORDS,\r
- pattern_split_doc},\r
- {"findall", (PyCFunction) pattern_findall, METH_VARARGS|METH_KEYWORDS,\r
- pattern_findall_doc},\r
-#if PY_VERSION_HEX >= 0x02020000\r
- {"finditer", (PyCFunction) pattern_finditer, METH_VARARGS,\r
- pattern_finditer_doc},\r
-#endif\r
- {"scanner", (PyCFunction) pattern_scanner, METH_VARARGS},\r
- {"__copy__", (PyCFunction) pattern_copy, METH_NOARGS},\r
- {"__deepcopy__", (PyCFunction) pattern_deepcopy, METH_O},\r
- {NULL, NULL}\r
-};\r
-\r
-static PyObject*\r
-pattern_getattr(PatternObject* self, char* name)\r
-{\r
- PyObject* res;\r
-\r
- res = Py_FindMethod(pattern_methods, (PyObject*) self, name);\r
-\r
- if (res)\r
- return res;\r
-\r
- PyErr_Clear();\r
-\r
- /* attributes */\r
- if (!strcmp(name, "pattern")) {\r
- Py_INCREF(self->pattern);\r
- return self->pattern;\r
- }\r
-\r
- if (!strcmp(name, "flags"))\r
- return Py_BuildValue("i", self->flags);\r
-\r
- if (!strcmp(name, "groups"))\r
- return Py_BuildValue("i", self->groups);\r
-\r
- if (!strcmp(name, "groupindex") && self->groupindex) {\r
- Py_INCREF(self->groupindex);\r
- return self->groupindex;\r
- }\r
-\r
- PyErr_SetString(PyExc_AttributeError, name);\r
- return NULL;\r
-}\r
-\r
-statichere PyTypeObject Pattern_Type = {\r
- PyObject_HEAD_INIT(NULL)\r
- 0, "_" SRE_MODULE ".SRE_Pattern",\r
- sizeof(PatternObject), sizeof(SRE_CODE),\r
- (destructor)pattern_dealloc, /*tp_dealloc*/\r
- 0, /*tp_print*/\r
- (getattrfunc)pattern_getattr, /*tp_getattr*/\r
- 0, /* tp_setattr */\r
- 0, /* tp_compare */\r
- 0, /* tp_repr */\r
- 0, /* tp_as_number */\r
- 0, /* tp_as_sequence */\r
- 0, /* tp_as_mapping */\r
- 0, /* tp_hash */\r
- 0, /* tp_call */\r
- 0, /* tp_str */\r
- 0, /* tp_getattro */\r
- 0, /* tp_setattro */\r
- 0, /* tp_as_buffer */\r
- Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */\r
- pattern_doc, /* tp_doc */\r
- 0, /* tp_traverse */\r
- 0, /* tp_clear */\r
- 0, /* tp_richcompare */\r
- offsetof(PatternObject, weakreflist), /* tp_weaklistoffset */\r
-};\r
-\r
-static int _validate(PatternObject *self); /* Forward */\r
-\r
-static PyObject *\r
-_compile(PyObject* self_, PyObject* args)\r
-{\r
- /* "compile" pattern descriptor to pattern object */\r
-\r
- PatternObject* self;\r
- Py_ssize_t i, n;\r
-\r
- PyObject* pattern;\r
- int flags = 0;\r
- PyObject* code;\r
- Py_ssize_t groups = 0;\r
- PyObject* groupindex = NULL;\r
- PyObject* indexgroup = NULL;\r
- if (!PyArg_ParseTuple(args, "OiO!|nOO", &pattern, &flags,\r
- &PyList_Type, &code, &groups,\r
- &groupindex, &indexgroup))\r
- return NULL;\r
-\r
- n = PyList_GET_SIZE(code);\r
- /* coverity[ampersand_in_size] */\r
- self = PyObject_NEW_VAR(PatternObject, &Pattern_Type, n);\r
- if (!self)\r
- return NULL;\r
- self->weakreflist = NULL;\r
- self->pattern = NULL;\r
- self->groupindex = NULL;\r
- self->indexgroup = NULL;\r
-\r
- self->codesize = n;\r
-\r
- for (i = 0; i < n; i++) {\r
- PyObject *o = PyList_GET_ITEM(code, i);\r
- unsigned long value = PyInt_Check(o) ? (unsigned long)PyInt_AsLong(o)\r
- : PyLong_AsUnsignedLong(o);\r
- self->code[i] = (SRE_CODE) value;\r
- if ((unsigned long) self->code[i] != value) {\r
- PyErr_SetString(PyExc_OverflowError,\r
- "regular expression code size limit exceeded");\r
- break;\r
- }\r
- }\r
-\r
- if (PyErr_Occurred()) {\r
- Py_DECREF(self);\r
- return NULL;\r
- }\r
-\r
- Py_INCREF(pattern);\r
- self->pattern = pattern;\r
-\r
- self->flags = flags;\r
-\r
- self->groups = groups;\r
-\r
- Py_XINCREF(groupindex);\r
- self->groupindex = groupindex;\r
-\r
- Py_XINCREF(indexgroup);\r
- self->indexgroup = indexgroup;\r
-\r
- self->weakreflist = NULL;\r
-\r
- if (!_validate(self)) {\r
- Py_DECREF(self);\r
- return NULL;\r
- }\r
-\r
- return (PyObject*) self;\r
-}\r
-\r
-/* -------------------------------------------------------------------- */\r
-/* Code validation */\r
-\r
-/* To learn more about this code, have a look at the _compile() function in\r
- Lib/sre_compile.py. The validation functions below checks the code array\r
- for conformance with the code patterns generated there.\r
-\r
- The nice thing about the generated code is that it is position-independent:\r
- all jumps are relative jumps forward. Also, jumps don't cross each other:\r
- the target of a later jump is always earlier than the target of an earlier\r
- jump. IOW, this is okay:\r
-\r
- J---------J-------T--------T\r
- \ \_____/ /\r
- \______________________/\r
-\r
- but this is not:\r
-\r
- J---------J-------T--------T\r
- \_________\_____/ /\r
- \____________/\r
-\r
- It also helps that SRE_CODE is always an unsigned type, either 2 bytes or 4\r
- bytes wide (the latter if Python is compiled for "wide" unicode support).\r
-*/\r
-\r
-/* Defining this one enables tracing of the validator */\r
-#undef VVERBOSE\r
-\r
-/* Trace macro for the validator */\r
-#if defined(VVERBOSE)\r
-#define VTRACE(v) printf v\r
-#else\r
-#define VTRACE(v)\r
-#endif\r
-\r
-/* Report failure */\r
-#define FAIL do { VTRACE(("FAIL: %d\n", __LINE__)); return 0; } while (0)\r
-\r
-/* Extract opcode, argument, or skip count from code array */\r
-#define GET_OP \\r
- do { \\r
- VTRACE(("%p: ", code)); \\r
- if (code >= end) FAIL; \\r
- op = *code++; \\r
- VTRACE(("%lu (op)\n", (unsigned long)op)); \\r
- } while (0)\r
-#define GET_ARG \\r
- do { \\r
- VTRACE(("%p= ", code)); \\r
- if (code >= end) FAIL; \\r
- arg = *code++; \\r
- VTRACE(("%lu (arg)\n", (unsigned long)arg)); \\r
- } while (0)\r
-#define GET_SKIP_ADJ(adj) \\r
- do { \\r
- VTRACE(("%p= ", code)); \\r
- if (code >= end) FAIL; \\r
- skip = *code; \\r
- VTRACE(("%lu (skip to %p)\n", \\r
- (unsigned long)skip, code+skip)); \\r
- if (code+skip-adj < code || code+skip-adj > end)\\r
- FAIL; \\r
- code++; \\r
- } while (0)\r
-#define GET_SKIP GET_SKIP_ADJ(0)\r
-\r
-static int\r
-_validate_charset(SRE_CODE *code, SRE_CODE *end)\r
-{\r
- /* Some variables are manipulated by the macros above */\r
- SRE_CODE op;\r
- SRE_CODE arg;\r
- SRE_CODE offset;\r
- int i;\r
-\r
- while (code < end) {\r
- GET_OP;\r
- switch (op) {\r
-\r
- case SRE_OP_NEGATE:\r
- break;\r
-\r
- case SRE_OP_LITERAL:\r
- GET_ARG;\r
- break;\r
-\r
- case SRE_OP_RANGE:\r
- GET_ARG;\r
- GET_ARG;\r
- break;\r
-\r
- case SRE_OP_CHARSET:\r
- offset = 32/sizeof(SRE_CODE); /* 32-byte bitmap */\r
- if (code+offset < code || code+offset > end)\r
- FAIL;\r
- code += offset;\r
- break;\r
-\r
- case SRE_OP_BIGCHARSET:\r
- GET_ARG; /* Number of blocks */\r
- offset = 256/sizeof(SRE_CODE); /* 256-byte table */\r
- if (code+offset < code || code+offset > end)\r
- FAIL;\r
- /* Make sure that each byte points to a valid block */\r
- for (i = 0; i < 256; i++) {\r
- if (((unsigned char *)code)[i] >= arg)\r
- FAIL;\r
- }\r
- code += offset;\r
- offset = arg * 32/sizeof(SRE_CODE); /* 32-byte bitmap times arg */\r
- if (code+offset < code || code+offset > end)\r
- FAIL;\r
- code += offset;\r
- break;\r
-\r
- case SRE_OP_CATEGORY:\r
- GET_ARG;\r
- switch (arg) {\r
- case SRE_CATEGORY_DIGIT:\r
- case SRE_CATEGORY_NOT_DIGIT:\r
- case SRE_CATEGORY_SPACE:\r
- case SRE_CATEGORY_NOT_SPACE:\r
- case SRE_CATEGORY_WORD:\r
- case SRE_CATEGORY_NOT_WORD:\r
- case SRE_CATEGORY_LINEBREAK:\r
- case SRE_CATEGORY_NOT_LINEBREAK:\r
- case SRE_CATEGORY_LOC_WORD:\r
- case SRE_CATEGORY_LOC_NOT_WORD:\r
- case SRE_CATEGORY_UNI_DIGIT:\r
- case SRE_CATEGORY_UNI_NOT_DIGIT:\r
- case SRE_CATEGORY_UNI_SPACE:\r
- case SRE_CATEGORY_UNI_NOT_SPACE:\r
- case SRE_CATEGORY_UNI_WORD:\r
- case SRE_CATEGORY_UNI_NOT_WORD:\r
- case SRE_CATEGORY_UNI_LINEBREAK:\r
- case SRE_CATEGORY_UNI_NOT_LINEBREAK:\r
- break;\r
- default:\r
- FAIL;\r
- }\r
- break;\r
-\r
- default:\r
- FAIL;\r
-\r
- }\r
- }\r
-\r
- return 1;\r
-}\r
-\r
-static int\r
-_validate_inner(SRE_CODE *code, SRE_CODE *end, Py_ssize_t groups)\r
-{\r
- /* Some variables are manipulated by the macros above */\r
- SRE_CODE op;\r
- SRE_CODE arg;\r
- SRE_CODE skip;\r
-\r
- VTRACE(("code=%p, end=%p\n", code, end));\r
-\r
- if (code > end)\r
- FAIL;\r
-\r
- while (code < end) {\r
- GET_OP;\r
- switch (op) {\r
-\r
- case SRE_OP_MARK:\r
- /* We don't check whether marks are properly nested; the\r
- sre_match() code is robust even if they don't, and the worst\r
- you can get is nonsensical match results. */\r
- GET_ARG;\r
- if (arg > 2*groups+1) {\r
- VTRACE(("arg=%d, groups=%d\n", (int)arg, (int)groups));\r
- FAIL;\r
- }\r
- break;\r
-\r
- case SRE_OP_LITERAL:\r
- case SRE_OP_NOT_LITERAL:\r
- case SRE_OP_LITERAL_IGNORE:\r
- case SRE_OP_NOT_LITERAL_IGNORE:\r
- GET_ARG;\r
- /* The arg is just a character, nothing to check */\r
- break;\r
-\r
- case SRE_OP_SUCCESS:\r
- case SRE_OP_FAILURE:\r
- /* Nothing to check; these normally end the matching process */\r
- break;\r
-\r
- case SRE_OP_AT:\r
- GET_ARG;\r
- switch (arg) {\r
- case SRE_AT_BEGINNING:\r
- case SRE_AT_BEGINNING_STRING:\r
- case SRE_AT_BEGINNING_LINE:\r
- case SRE_AT_END:\r
- case SRE_AT_END_LINE:\r
- case SRE_AT_END_STRING:\r
- case SRE_AT_BOUNDARY:\r
- case SRE_AT_NON_BOUNDARY:\r
- case SRE_AT_LOC_BOUNDARY:\r
- case SRE_AT_LOC_NON_BOUNDARY:\r
- case SRE_AT_UNI_BOUNDARY:\r
- case SRE_AT_UNI_NON_BOUNDARY:\r
- break;\r
- default:\r
- FAIL;\r
- }\r
- break;\r
-\r
- case SRE_OP_ANY:\r
- case SRE_OP_ANY_ALL:\r
- /* These have no operands */\r
- break;\r
-\r
- case SRE_OP_IN:\r
- case SRE_OP_IN_IGNORE:\r
- GET_SKIP;\r
- /* Stop 1 before the end; we check the FAILURE below */\r
- if (!_validate_charset(code, code+skip-2))\r
- FAIL;\r
- if (code[skip-2] != SRE_OP_FAILURE)\r
- FAIL;\r
- code += skip-1;\r
- break;\r
-\r
- case SRE_OP_INFO:\r
- {\r
- /* A minimal info field is\r
- <INFO> <1=skip> <2=flags> <3=min> <4=max>;\r
- If SRE_INFO_PREFIX or SRE_INFO_CHARSET is in the flags,\r
- more follows. */\r
- SRE_CODE flags, i;\r
- SRE_CODE *newcode;\r
- GET_SKIP;\r
- newcode = code+skip-1;\r
- GET_ARG; flags = arg;\r
- GET_ARG; /* min */\r
- GET_ARG; /* max */\r
- /* Check that only valid flags are present */\r
- if ((flags & ~(SRE_INFO_PREFIX |\r
- SRE_INFO_LITERAL |\r
- SRE_INFO_CHARSET)) != 0)\r
- FAIL;\r
- /* PREFIX and CHARSET are mutually exclusive */\r
- if ((flags & SRE_INFO_PREFIX) &&\r
- (flags & SRE_INFO_CHARSET))\r
- FAIL;\r
- /* LITERAL implies PREFIX */\r
- if ((flags & SRE_INFO_LITERAL) &&\r
- !(flags & SRE_INFO_PREFIX))\r
- FAIL;\r
- /* Validate the prefix */\r
- if (flags & SRE_INFO_PREFIX) {\r
- SRE_CODE prefix_len;\r
- GET_ARG; prefix_len = arg;\r
- GET_ARG; /* prefix skip */\r
- /* Here comes the prefix string */\r
- if (code+prefix_len < code || code+prefix_len > newcode)\r
- FAIL;\r
- code += prefix_len;\r
- /* And here comes the overlap table */\r
- if (code+prefix_len < code || code+prefix_len > newcode)\r
- FAIL;\r
- /* Each overlap value should be < prefix_len */\r
- for (i = 0; i < prefix_len; i++) {\r
- if (code[i] >= prefix_len)\r
- FAIL;\r
- }\r
- code += prefix_len;\r
- }\r
- /* Validate the charset */\r
- if (flags & SRE_INFO_CHARSET) {\r
- if (!_validate_charset(code, newcode-1))\r
- FAIL;\r
- if (newcode[-1] != SRE_OP_FAILURE)\r
- FAIL;\r
- code = newcode;\r
- }\r
- else if (code != newcode) {\r
- VTRACE(("code=%p, newcode=%p\n", code, newcode));\r
- FAIL;\r
- }\r
- }\r
- break;\r
-\r
- case SRE_OP_BRANCH:\r
- {\r
- SRE_CODE *target = NULL;\r
- for (;;) {\r
- GET_SKIP;\r
- if (skip == 0)\r
- break;\r
- /* Stop 2 before the end; we check the JUMP below */\r
- if (!_validate_inner(code, code+skip-3, groups))\r
- FAIL;\r
- code += skip-3;\r
- /* Check that it ends with a JUMP, and that each JUMP\r
- has the same target */\r
- GET_OP;\r
- if (op != SRE_OP_JUMP)\r
- FAIL;\r
- GET_SKIP;\r
- if (target == NULL)\r
- target = code+skip-1;\r
- else if (code+skip-1 != target)\r
- FAIL;\r
- }\r
- }\r
- break;\r
-\r
- case SRE_OP_REPEAT_ONE:\r
- case SRE_OP_MIN_REPEAT_ONE:\r
- {\r
- SRE_CODE min, max;\r
- GET_SKIP;\r
- GET_ARG; min = arg;\r
- GET_ARG; max = arg;\r
- if (min > max)\r
- FAIL;\r
-#ifdef Py_UNICODE_WIDE\r
- if (max > 65535)\r
- FAIL;\r
-#endif\r
- if (!_validate_inner(code, code+skip-4, groups))\r
- FAIL;\r
- code += skip-4;\r
- GET_OP;\r
- if (op != SRE_OP_SUCCESS)\r
- FAIL;\r
- }\r
- break;\r
-\r
- case SRE_OP_REPEAT:\r
- {\r
- SRE_CODE min, max;\r
- GET_SKIP;\r
- GET_ARG; min = arg;\r
- GET_ARG; max = arg;\r
- if (min > max)\r
- FAIL;\r
-#ifdef Py_UNICODE_WIDE\r
- if (max > 65535)\r
- FAIL;\r
-#endif\r
- if (!_validate_inner(code, code+skip-3, groups))\r
- FAIL;\r
- code += skip-3;\r
- GET_OP;\r
- if (op != SRE_OP_MAX_UNTIL && op != SRE_OP_MIN_UNTIL)\r
- FAIL;\r
- }\r
- break;\r
-\r
- case SRE_OP_GROUPREF:\r
- case SRE_OP_GROUPREF_IGNORE:\r
- GET_ARG;\r
- if (arg >= groups)\r
- FAIL;\r
- break;\r
-\r
- case SRE_OP_GROUPREF_EXISTS:\r
- /* The regex syntax for this is: '(?(group)then|else)', where\r
- 'group' is either an integer group number or a group name,\r
- 'then' and 'else' are sub-regexes, and 'else' is optional. */\r
- GET_ARG;\r
- if (arg >= groups)\r
- FAIL;\r
- GET_SKIP_ADJ(1);\r
- code--; /* The skip is relative to the first arg! */\r
- /* There are two possibilities here: if there is both a 'then'\r
- part and an 'else' part, the generated code looks like:\r
-\r
- GROUPREF_EXISTS\r
- <group>\r
- <skipyes>\r
- ...then part...\r
- JUMP\r
- <skipno>\r
- (<skipyes> jumps here)\r
- ...else part...\r
- (<skipno> jumps here)\r
-\r
- If there is only a 'then' part, it looks like:\r
-\r
- GROUPREF_EXISTS\r
- <group>\r
- <skip>\r
- ...then part...\r
- (<skip> jumps here)\r
-\r
- There is no direct way to decide which it is, and we don't want\r
- to allow arbitrary jumps anywhere in the code; so we just look\r
- for a JUMP opcode preceding our skip target.\r
- */\r
- if (skip >= 3 && code+skip-3 >= code &&\r
- code[skip-3] == SRE_OP_JUMP)\r
- {\r
- VTRACE(("both then and else parts present\n"));\r
- if (!_validate_inner(code+1, code+skip-3, groups))\r
- FAIL;\r
- code += skip-2; /* Position after JUMP, at <skipno> */\r
- GET_SKIP;\r
- if (!_validate_inner(code, code+skip-1, groups))\r
- FAIL;\r
- code += skip-1;\r
- }\r
- else {\r
- VTRACE(("only a then part present\n"));\r
- if (!_validate_inner(code+1, code+skip-1, groups))\r
- FAIL;\r
- code += skip-1;\r
- }\r
- break;\r
-\r
- case SRE_OP_ASSERT:\r
- case SRE_OP_ASSERT_NOT:\r
- GET_SKIP;\r
- GET_ARG; /* 0 for lookahead, width for lookbehind */\r
- code--; /* Back up over arg to simplify math below */\r
- if (arg & 0x80000000)\r
- FAIL; /* Width too large */\r
- /* Stop 1 before the end; we check the SUCCESS below */\r
- if (!_validate_inner(code+1, code+skip-2, groups))\r
- FAIL;\r
- code += skip-2;\r
- GET_OP;\r
- if (op != SRE_OP_SUCCESS)\r
- FAIL;\r
- break;\r
-\r
- default:\r
- FAIL;\r
-\r
- }\r
- }\r
-\r
- VTRACE(("okay\n"));\r
- return 1;\r
-}\r
-\r
-static int\r
-_validate_outer(SRE_CODE *code, SRE_CODE *end, Py_ssize_t groups)\r
-{\r
- if (groups < 0 || groups > 100 || code >= end || end[-1] != SRE_OP_SUCCESS)\r
- FAIL;\r
- if (groups == 0) /* fix for simplejson */\r
- groups = 100; /* 100 groups should always be safe */\r
- return _validate_inner(code, end-1, groups);\r
-}\r
-\r
-static int\r
-_validate(PatternObject *self)\r
-{\r
- if (!_validate_outer(self->code, self->code+self->codesize, self->groups))\r
- {\r
- PyErr_SetString(PyExc_RuntimeError, "invalid SRE code");\r
- return 0;\r
- }\r
- else\r
- VTRACE(("Success!\n"));\r
- return 1;\r
-}\r
-\r
-/* -------------------------------------------------------------------- */\r
-/* match methods */\r
-\r
-static void\r
-match_dealloc(MatchObject* self)\r
-{\r
- Py_XDECREF(self->regs);\r
- Py_XDECREF(self->string);\r
- Py_DECREF(self->pattern);\r
- PyObject_DEL(self);\r
-}\r
-\r
-static PyObject*\r
-match_getslice_by_index(MatchObject* self, Py_ssize_t index, PyObject* def)\r
-{\r
- if (index < 0 || index >= self->groups) {\r
- /* raise IndexError if we were given a bad group number */\r
- PyErr_SetString(\r
- PyExc_IndexError,\r
- "no such group"\r
- );\r
- return NULL;\r
- }\r
-\r
- index *= 2;\r
-\r
- if (self->string == Py_None || self->mark[index] < 0) {\r
- /* return default value if the string or group is undefined */\r
- Py_INCREF(def);\r
- return def;\r
- }\r
-\r
- return PySequence_GetSlice(\r
- self->string, self->mark[index], self->mark[index+1]\r
- );\r
-}\r
-\r
-static Py_ssize_t\r
-match_getindex(MatchObject* self, PyObject* index)\r
-{\r
- Py_ssize_t i;\r
-\r
- if (PyInt_Check(index))\r
- return PyInt_AsSsize_t(index);\r
-\r
- i = -1;\r
-\r
- if (self->pattern->groupindex) {\r
- index = PyObject_GetItem(self->pattern->groupindex, index);\r
- if (index) {\r
- if (PyInt_Check(index) || PyLong_Check(index))\r
- i = PyInt_AsSsize_t(index);\r
- Py_DECREF(index);\r
- } else\r
- PyErr_Clear();\r
- }\r
-\r
- return i;\r
-}\r
-\r
-static PyObject*\r
-match_getslice(MatchObject* self, PyObject* index, PyObject* def)\r
-{\r
- return match_getslice_by_index(self, match_getindex(self, index), def);\r
-}\r
-\r
-static PyObject*\r
-match_expand(MatchObject* self, PyObject* ptemplate)\r
-{\r
- /* delegate to Python code */\r
- return call(\r
- SRE_PY_MODULE, "_expand",\r
- PyTuple_Pack(3, self->pattern, self, ptemplate)\r
- );\r
-}\r
-\r
-static PyObject*\r
-match_group(MatchObject* self, PyObject* args)\r
-{\r
- PyObject* result;\r
- Py_ssize_t i, size;\r
-\r
- size = PyTuple_GET_SIZE(args);\r
-\r
- switch (size) {\r
- case 0:\r
- result = match_getslice(self, Py_False, Py_None);\r
- break;\r
- case 1:\r
- result = match_getslice(self, PyTuple_GET_ITEM(args, 0), Py_None);\r
- break;\r
- default:\r
- /* fetch multiple items */\r
- result = PyTuple_New(size);\r
- if (!result)\r
- return NULL;\r
- for (i = 0; i < size; i++) {\r
- PyObject* item = match_getslice(\r
- self, PyTuple_GET_ITEM(args, i), Py_None\r
- );\r
- if (!item) {\r
- Py_DECREF(result);\r
- return NULL;\r
- }\r
- PyTuple_SET_ITEM(result, i, item);\r
- }\r
- break;\r
- }\r
- return result;\r
-}\r
-\r
-static PyObject*\r
-match_groups(MatchObject* self, PyObject* args, PyObject* kw)\r
-{\r
- PyObject* result;\r
- Py_ssize_t index;\r
-\r
- PyObject* def = Py_None;\r
- static char* kwlist[] = { "default", NULL };\r
- if (!PyArg_ParseTupleAndKeywords(args, kw, "|O:groups", kwlist, &def))\r
- return NULL;\r
-\r
- result = PyTuple_New(self->groups-1);\r
- if (!result)\r
- return NULL;\r
-\r
- for (index = 1; index < self->groups; index++) {\r
- PyObject* item;\r
- item = match_getslice_by_index(self, index, def);\r
- if (!item) {\r
- Py_DECREF(result);\r
- return NULL;\r
- }\r
- PyTuple_SET_ITEM(result, index-1, item);\r
- }\r
-\r
- return result;\r
-}\r
-\r
-static PyObject*\r
-match_groupdict(MatchObject* self, PyObject* args, PyObject* kw)\r
-{\r
- PyObject* result;\r
- PyObject* keys;\r
- Py_ssize_t index;\r
-\r
- PyObject* def = Py_None;\r
- static char* kwlist[] = { "default", NULL };\r
- if (!PyArg_ParseTupleAndKeywords(args, kw, "|O:groupdict", kwlist, &def))\r
- return NULL;\r
-\r
- result = PyDict_New();\r
- if (!result || !self->pattern->groupindex)\r
- return result;\r
-\r
- keys = PyMapping_Keys(self->pattern->groupindex);\r
- if (!keys)\r
- goto failed;\r
-\r
- for (index = 0; index < PyList_GET_SIZE(keys); index++) {\r
- int status;\r
- PyObject* key;\r
- PyObject* value;\r
- key = PyList_GET_ITEM(keys, index);\r
- if (!key)\r
- goto failed;\r
- value = match_getslice(self, key, def);\r
- if (!value) {\r
- Py_DECREF(key);\r
- goto failed;\r
- }\r
- status = PyDict_SetItem(result, key, value);\r
- Py_DECREF(value);\r
- if (status < 0)\r
- goto failed;\r
- }\r
-\r
- Py_DECREF(keys);\r
-\r
- return result;\r
-\r
-failed:\r
- Py_XDECREF(keys);\r
- Py_DECREF(result);\r
- return NULL;\r
-}\r
-\r
-static PyObject*\r
-match_start(MatchObject* self, PyObject* args)\r
-{\r
- Py_ssize_t index;\r
-\r
- PyObject* index_ = Py_False; /* zero */\r
- if (!PyArg_UnpackTuple(args, "start", 0, 1, &index_))\r
- return NULL;\r
-\r
- index = match_getindex(self, index_);\r
-\r
- if (index < 0 || index >= self->groups) {\r
- PyErr_SetString(\r
- PyExc_IndexError,\r
- "no such group"\r
- );\r
- return NULL;\r
- }\r
-\r
- /* mark is -1 if group is undefined */\r
- return Py_BuildValue("i", self->mark[index*2]);\r
-}\r
-\r
-static PyObject*\r
-match_end(MatchObject* self, PyObject* args)\r
-{\r
- Py_ssize_t index;\r
-\r
- PyObject* index_ = Py_False; /* zero */\r
- if (!PyArg_UnpackTuple(args, "end", 0, 1, &index_))\r
- return NULL;\r
-\r
- index = match_getindex(self, index_);\r
-\r
- if (index < 0 || index >= self->groups) {\r
- PyErr_SetString(\r
- PyExc_IndexError,\r
- "no such group"\r
- );\r
- return NULL;\r
- }\r
-\r
- /* mark is -1 if group is undefined */\r
- return Py_BuildValue("i", self->mark[index*2+1]);\r
-}\r
-\r
-LOCAL(PyObject*)\r
-_pair(Py_ssize_t i1, Py_ssize_t i2)\r
-{\r
- PyObject* pair;\r
- PyObject* item;\r
-\r
- pair = PyTuple_New(2);\r
- if (!pair)\r
- return NULL;\r
-\r
- item = PyInt_FromSsize_t(i1);\r
- if (!item)\r
- goto error;\r
- PyTuple_SET_ITEM(pair, 0, item);\r
-\r
- item = PyInt_FromSsize_t(i2);\r
- if (!item)\r
- goto error;\r
- PyTuple_SET_ITEM(pair, 1, item);\r
-\r
- return pair;\r
-\r
- error:\r
- Py_DECREF(pair);\r
- return NULL;\r
-}\r
-\r
-static PyObject*\r
-match_span(MatchObject* self, PyObject* args)\r
-{\r
- Py_ssize_t index;\r
-\r
- PyObject* index_ = Py_False; /* zero */\r
- if (!PyArg_UnpackTuple(args, "span", 0, 1, &index_))\r
- return NULL;\r
-\r
- index = match_getindex(self, index_);\r
-\r
- if (index < 0 || index >= self->groups) {\r
- PyErr_SetString(\r
- PyExc_IndexError,\r
- "no such group"\r
- );\r
- return NULL;\r
- }\r
-\r
- /* marks are -1 if group is undefined */\r
- return _pair(self->mark[index*2], self->mark[index*2+1]);\r
-}\r
-\r
-static PyObject*\r
-match_regs(MatchObject* self)\r
-{\r
- PyObject* regs;\r
- PyObject* item;\r
- Py_ssize_t index;\r
-\r
- regs = PyTuple_New(self->groups);\r
- if (!regs)\r
- return NULL;\r
-\r
- for (index = 0; index < self->groups; index++) {\r
- item = _pair(self->mark[index*2], self->mark[index*2+1]);\r
- if (!item) {\r
- Py_DECREF(regs);\r
- return NULL;\r
- }\r
- PyTuple_SET_ITEM(regs, index, item);\r
- }\r
-\r
- Py_INCREF(regs);\r
- self->regs = regs;\r
-\r
- return regs;\r
-}\r
-\r
-static PyObject*\r
-match_copy(MatchObject* self, PyObject *unused)\r
-{\r
-#ifdef USE_BUILTIN_COPY\r
- MatchObject* copy;\r
- Py_ssize_t slots, offset;\r
-\r
- slots = 2 * (self->pattern->groups+1);\r
-\r
- copy = PyObject_NEW_VAR(MatchObject, &Match_Type, slots);\r
- if (!copy)\r
- return NULL;\r
-\r
- /* this value a constant, but any compiler should be able to\r
- figure that out all by itself */\r
- offset = offsetof(MatchObject, string);\r
-\r
- Py_XINCREF(self->pattern);\r
- Py_XINCREF(self->string);\r
- Py_XINCREF(self->regs);\r
-\r
- memcpy((char*) copy + offset, (char*) self + offset,\r
- sizeof(MatchObject) + slots * sizeof(Py_ssize_t) - offset);\r
-\r
- return (PyObject*) copy;\r
-#else\r
- PyErr_SetString(PyExc_TypeError, "cannot copy this match object");\r
- return NULL;\r
-#endif\r
-}\r
-\r
-static PyObject*\r
-match_deepcopy(MatchObject* self, PyObject* memo)\r
-{\r
-#ifdef USE_BUILTIN_COPY\r
- MatchObject* copy;\r
-\r
- copy = (MatchObject*) match_copy(self);\r
- if (!copy)\r
- return NULL;\r
-\r
- if (!deepcopy((PyObject**) ©->pattern, memo) ||\r
- !deepcopy(©->string, memo) ||\r
- !deepcopy(©->regs, memo)) {\r
- Py_DECREF(copy);\r
- return NULL;\r
- }\r
-\r
-#else\r
- PyErr_SetString(PyExc_TypeError, "cannot deepcopy this match object");\r
- return NULL;\r
-#endif\r
-}\r
-\r
-static PyMethodDef match_methods[] = {\r
- {"group", (PyCFunction) match_group, METH_VARARGS},\r
- {"start", (PyCFunction) match_start, METH_VARARGS},\r
- {"end", (PyCFunction) match_end, METH_VARARGS},\r
- {"span", (PyCFunction) match_span, METH_VARARGS},\r
- {"groups", (PyCFunction) match_groups, METH_VARARGS|METH_KEYWORDS},\r
- {"groupdict", (PyCFunction) match_groupdict, METH_VARARGS|METH_KEYWORDS},\r
- {"expand", (PyCFunction) match_expand, METH_O},\r
- {"__copy__", (PyCFunction) match_copy, METH_NOARGS},\r
- {"__deepcopy__", (PyCFunction) match_deepcopy, METH_O},\r
- {NULL, NULL}\r
-};\r
-\r
-static PyObject*\r
-match_getattr(MatchObject* self, char* name)\r
-{\r
- PyObject* res;\r
-\r
- res = Py_FindMethod(match_methods, (PyObject*) self, name);\r
- if (res)\r
- return res;\r
-\r
- PyErr_Clear();\r
-\r
- if (!strcmp(name, "lastindex")) {\r
- if (self->lastindex >= 0)\r
- return Py_BuildValue("i", self->lastindex);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
-\r
- if (!strcmp(name, "lastgroup")) {\r
- if (self->pattern->indexgroup && self->lastindex >= 0) {\r
- PyObject* result = PySequence_GetItem(\r
- self->pattern->indexgroup, self->lastindex\r
- );\r
- if (result)\r
- return result;\r
- PyErr_Clear();\r
- }\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
-\r
- if (!strcmp(name, "string")) {\r
- if (self->string) {\r
- Py_INCREF(self->string);\r
- return self->string;\r
- } else {\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
- }\r
-\r
- if (!strcmp(name, "regs")) {\r
- if (self->regs) {\r
- Py_INCREF(self->regs);\r
- return self->regs;\r
- } else\r
- return match_regs(self);\r
- }\r
-\r
- if (!strcmp(name, "re")) {\r
- Py_INCREF(self->pattern);\r
- return (PyObject*) self->pattern;\r
- }\r
-\r
- if (!strcmp(name, "pos"))\r
- return Py_BuildValue("i", self->pos);\r
-\r
- if (!strcmp(name, "endpos"))\r
- return Py_BuildValue("i", self->endpos);\r
-\r
- PyErr_SetString(PyExc_AttributeError, name);\r
- return NULL;\r
-}\r
-\r
-/* FIXME: implement setattr("string", None) as a special case (to\r
- detach the associated string, if any */\r
-\r
-statichere PyTypeObject Match_Type = {\r
- PyObject_HEAD_INIT(NULL)\r
- 0, "_" SRE_MODULE ".SRE_Match",\r
- sizeof(MatchObject), sizeof(Py_ssize_t),\r
- (destructor)match_dealloc, /*tp_dealloc*/\r
- 0, /*tp_print*/\r
- (getattrfunc)match_getattr /*tp_getattr*/\r
-};\r
-\r
-static PyObject*\r
-pattern_new_match(PatternObject* pattern, SRE_STATE* state, int status)\r
-{\r
- /* create match object (from state object) */\r
-\r
- MatchObject* match;\r
- Py_ssize_t i, j;\r
- char* base;\r
- int n;\r
-\r
- if (status > 0) {\r
-\r
- /* create match object (with room for extra group marks) */\r
- /* coverity[ampersand_in_size] */\r
- match = PyObject_NEW_VAR(MatchObject, &Match_Type,\r
- 2*(pattern->groups+1));\r
- if (!match)\r
- return NULL;\r
-\r
- Py_INCREF(pattern);\r
- match->pattern = pattern;\r
-\r
- Py_INCREF(state->string);\r
- match->string = state->string;\r
-\r
- match->regs = NULL;\r
- match->groups = pattern->groups+1;\r
-\r
- /* fill in group slices */\r
-\r
- base = (char*) state->beginning;\r
- n = state->charsize;\r
-\r
- match->mark[0] = ((char*) state->start - base) / n;\r
- match->mark[1] = ((char*) state->ptr - base) / n;\r
-\r
- for (i = j = 0; i < pattern->groups; i++, j+=2)\r
- if (j+1 <= state->lastmark && state->mark[j] && state->mark[j+1]) {\r
- match->mark[j+2] = ((char*) state->mark[j] - base) / n;\r
- match->mark[j+3] = ((char*) state->mark[j+1] - base) / n;\r
- } else\r
- match->mark[j+2] = match->mark[j+3] = -1; /* undefined */\r
-\r
- match->pos = state->pos;\r
- match->endpos = state->endpos;\r
-\r
- match->lastindex = state->lastindex;\r
-\r
- return (PyObject*) match;\r
-\r
- } else if (status == 0) {\r
-\r
- /* no match */\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-\r
- }\r
-\r
- /* internal error */\r
- pattern_error(status);\r
- return NULL;\r
-}\r
-\r
-\r
-/* -------------------------------------------------------------------- */\r
-/* scanner methods (experimental) */\r
-\r
-static void\r
-scanner_dealloc(ScannerObject* self)\r
-{\r
- state_fini(&self->state);\r
- Py_XDECREF(self->pattern);\r
- PyObject_DEL(self);\r
-}\r
-\r
-static PyObject*\r
-scanner_match(ScannerObject* self, PyObject *unused)\r
-{\r
- SRE_STATE* state = &self->state;\r
- PyObject* match;\r
- int status;\r
-\r
- state_reset(state);\r
-\r
- state->ptr = state->start;\r
-\r
- if (state->charsize == 1) {\r
- status = sre_match(state, PatternObject_GetCode(self->pattern));\r
- } else {\r
-#if defined(HAVE_UNICODE)\r
- status = sre_umatch(state, PatternObject_GetCode(self->pattern));\r
-#endif\r
- }\r
- if (PyErr_Occurred())\r
- return NULL;\r
-\r
- match = pattern_new_match((PatternObject*) self->pattern,\r
- state, status);\r
-\r
- if (status == 0 || state->ptr == state->start)\r
- state->start = (void*) ((char*) state->ptr + state->charsize);\r
- else\r
- state->start = state->ptr;\r
-\r
- return match;\r
-}\r
-\r
-\r
-static PyObject*\r
-scanner_search(ScannerObject* self, PyObject *unused)\r
-{\r
- SRE_STATE* state = &self->state;\r
- PyObject* match;\r
- int status;\r
-\r
- state_reset(state);\r
-\r
- state->ptr = state->start;\r
-\r
- if (state->charsize == 1) {\r
- status = sre_search(state, PatternObject_GetCode(self->pattern));\r
- } else {\r
-#if defined(HAVE_UNICODE)\r
- status = sre_usearch(state, PatternObject_GetCode(self->pattern));\r
-#endif\r
- }\r
- if (PyErr_Occurred())\r
- return NULL;\r
-\r
- match = pattern_new_match((PatternObject*) self->pattern,\r
- state, status);\r
-\r
- if (status == 0 || state->ptr == state->start)\r
- state->start = (void*) ((char*) state->ptr + state->charsize);\r
- else\r
- state->start = state->ptr;\r
-\r
- return match;\r
-}\r
-\r
-static PyMethodDef scanner_methods[] = {\r
- {"match", (PyCFunction) scanner_match, METH_NOARGS},\r
- {"search", (PyCFunction) scanner_search, METH_NOARGS},\r
- {NULL, NULL}\r
-};\r
-\r
-static PyObject*\r
-scanner_getattr(ScannerObject* self, char* name)\r
-{\r
- PyObject* res;\r
-\r
- res = Py_FindMethod(scanner_methods, (PyObject*) self, name);\r
- if (res)\r
- return res;\r
-\r
- PyErr_Clear();\r
-\r
- /* attributes */\r
- if (!strcmp(name, "pattern")) {\r
- Py_INCREF(self->pattern);\r
- return self->pattern;\r
- }\r
-\r
- PyErr_SetString(PyExc_AttributeError, name);\r
- return NULL;\r
-}\r
-\r
-statichere PyTypeObject Scanner_Type = {\r
- PyObject_HEAD_INIT(NULL)\r
- 0, "_" SRE_MODULE ".SRE_Scanner",\r
- sizeof(ScannerObject), 0,\r
- (destructor)scanner_dealloc, /*tp_dealloc*/\r
- 0, /*tp_print*/\r
- (getattrfunc)scanner_getattr, /*tp_getattr*/\r
-};\r
-\r
-static PyObject*\r
-pattern_scanner(PatternObject* pattern, PyObject* args)\r
-{\r
- /* create search state object */\r
-\r
- ScannerObject* self;\r
-\r
- PyObject* string;\r
- Py_ssize_t start = 0;\r
- Py_ssize_t end = PY_SSIZE_T_MAX;\r
- if (!PyArg_ParseTuple(args, "O|nn:scanner", &string, &start, &end))\r
- return NULL;\r
-\r
- /* create scanner object */\r
- self = PyObject_NEW(ScannerObject, &Scanner_Type);\r
- if (!self)\r
- return NULL;\r
- self->pattern = NULL;\r
-\r
- string = state_init(&self->state, pattern, string, start, end);\r
- if (!string) {\r
- Py_DECREF(self);\r
- return NULL;\r
- }\r
-\r
- Py_INCREF(pattern);\r
- self->pattern = (PyObject*) pattern;\r
-\r
- return (PyObject*) self;\r
-}\r
-\r
-static PyMethodDef _functions[] = {\r
- {"compile", _compile, METH_VARARGS},\r
- {"getcodesize", sre_codesize, METH_NOARGS},\r
- {"getlower", sre_getlower, METH_VARARGS},\r
- {NULL, NULL}\r
-};\r
-\r
-#if PY_VERSION_HEX < 0x02030000\r
-DL_EXPORT(void) init_sre(void)\r
-#else\r
-PyMODINIT_FUNC init_sre(void)\r
-#endif\r
-{\r
- PyObject* m;\r
- PyObject* d;\r
- PyObject* x;\r
-\r
- /* Patch object types */\r
- if (PyType_Ready(&Pattern_Type) || PyType_Ready(&Match_Type) ||\r
- PyType_Ready(&Scanner_Type))\r
- return;\r
-\r
- m = Py_InitModule("_" SRE_MODULE, _functions);\r
- if (m == NULL)\r
- return;\r
- d = PyModule_GetDict(m);\r
-\r
- x = PyInt_FromLong(SRE_MAGIC);\r
- if (x) {\r
- PyDict_SetItemString(d, "MAGIC", x);\r
- Py_DECREF(x);\r
- }\r
-\r
- x = PyInt_FromLong(sizeof(SRE_CODE));\r
- if (x) {\r
- PyDict_SetItemString(d, "CODESIZE", x);\r
- Py_DECREF(x);\r
- }\r
-\r
- x = PyString_FromString(copyright);\r
- if (x) {\r
- PyDict_SetItemString(d, "copyright", x);\r
- Py_DECREF(x);\r
- }\r
-}\r
-\r
-#endif /* !defined(SRE_RECURSIVE) */\r
-\r
-/* vim:ts=4:sw=4:et\r
-*/\r
+++ /dev/null
-/* zutil.h -- internal interface and configuration of the compression library\r
- * Copyright (C) 1995-2005 Jean-loup Gailly.\r
- * For conditions of distribution and use, see copyright notice in zlib.h\r
- */\r
-\r
-/* WARNING: this file should *not* be used by applications. It is\r
- part of the implementation of the compression library and is\r
- subject to change. Applications should only use zlib.h.\r
- */\r
-\r
-/* @(#) $Id$ */\r
-\r
-#ifndef ZUTIL_H\r
-#define ZUTIL_H\r
-\r
-#define ZLIB_INTERNAL\r
-#include "zlib.h"\r
-\r
-#ifdef STDC\r
-# ifndef _WIN32_WCE\r
-# include <stddef.h>\r
-# endif\r
-# include <string.h>\r
-# include <stdlib.h>\r
-#endif\r
-#ifdef NO_ERRNO_H\r
-# ifdef _WIN32_WCE\r
- /* The Microsoft C Run-Time Library for Windows CE doesn't have\r
- * errno. We define it as a global variable to simplify porting.\r
- * Its value is always 0 and should not be used. We rename it to\r
- * avoid conflict with other libraries that use the same workaround.\r
- */\r
-# define errno z_errno\r
-# endif\r
- extern int errno;\r
-#else\r
-# ifndef _WIN32_WCE\r
-# include <errno.h>\r
-# endif\r
-#endif\r
-\r
-#ifndef local\r
-# define local static\r
-#endif\r
-/* compile with -Dlocal if your debugger can't find static symbols */\r
-\r
-typedef unsigned char uch;\r
-typedef uch FAR uchf;\r
-typedef unsigned short ush;\r
-typedef ush FAR ushf;\r
-typedef unsigned long ulg;\r
-\r
-extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */\r
-/* (size given to avoid silly warnings with Visual C++) */\r
-\r
-#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]\r
-\r
-#define ERR_RETURN(strm,err) \\r
- return (strm->msg = (char*)ERR_MSG(err), (err))\r
-/* To be used only when the state is known to be valid */\r
-\r
- /* common constants */\r
-\r
-#ifndef DEF_WBITS\r
-# define DEF_WBITS MAX_WBITS\r
-#endif\r
-/* default windowBits for decompression. MAX_WBITS is for compression only */\r
-\r
-#if MAX_MEM_LEVEL >= 8\r
-# define DEF_MEM_LEVEL 8\r
-#else\r
-# define DEF_MEM_LEVEL MAX_MEM_LEVEL\r
-#endif\r
-/* default memLevel */\r
-\r
-#define STORED_BLOCK 0\r
-#define STATIC_TREES 1\r
-#define DYN_TREES 2\r
-/* The three kinds of block type */\r
-\r
-#define MIN_MATCH 3\r
-#define MAX_MATCH 258\r
-/* The minimum and maximum match lengths */\r
-\r
-#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */\r
-\r
- /* target dependencies */\r
-\r
-#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))\r
-# define OS_CODE 0x00\r
-# if defined(__TURBOC__) || defined(__BORLANDC__)\r
-# if(__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))\r
- /* Allow compilation with ANSI keywords only enabled */\r
- void _Cdecl farfree( void *block );\r
- void *_Cdecl farmalloc( unsigned long nbytes );\r
-# else\r
-# include <alloc.h>\r
-# endif\r
-# else /* MSC or DJGPP */\r
-# include <malloc.h>\r
-# endif\r
-#endif\r
-\r
-#ifdef AMIGA\r
-# define OS_CODE 0x01\r
-#endif\r
-\r
-#if defined(VAXC) || defined(VMS)\r
-# define OS_CODE 0x02\r
-# define F_OPEN(name, mode) \\r
- fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")\r
-#endif\r
-\r
-#if defined(ATARI) || defined(atarist)\r
-# define OS_CODE 0x05\r
-#endif\r
-\r
-#ifdef OS2\r
-# define OS_CODE 0x06\r
-# ifdef M_I86\r
- #include <malloc.h>\r
-# endif\r
-#endif\r
-\r
-#if defined(MACOS) || defined(TARGET_OS_MAC)\r
-# define OS_CODE 0x07\r
-# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os\r
-# include <unix.h> /* for fdopen */\r
-# else\r
-# ifndef fdopen\r
-# define fdopen(fd,mode) NULL /* No fdopen() */\r
-# endif\r
-# endif\r
-#endif\r
-\r
-#ifdef TOPS20\r
-# define OS_CODE 0x0a\r
-#endif\r
-\r
-#ifdef WIN32\r
-# ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */\r
-# define OS_CODE 0x0b\r
-# endif\r
-#endif\r
-\r
-#ifdef __50SERIES /* Prime/PRIMOS */\r
-# define OS_CODE 0x0f\r
-#endif\r
-\r
-#if defined(_BEOS_) || defined(RISCOS)\r
-# define fdopen(fd,mode) NULL /* No fdopen() */\r
-#endif\r
-\r
-#if (defined(_MSC_VER) && (_MSC_VER > 600))\r
-# if defined(_WIN32_WCE) || defined(_EFI_STDLIB)\r
-# define fdopen(fd,mode) NULL /* No fdopen() */\r
-# ifndef _PTRDIFF_T_DEFINED\r
- typedef int ptrdiff_t;\r
-# define _PTRDIFF_T_DEFINED\r
-# endif\r
-# else\r
-# define fdopen(fd,type) _fdopen(fd,type)\r
-# endif\r
-#endif\r
-\r
- /* common defaults */\r
-\r
-#ifndef OS_CODE\r
-# define OS_CODE 0x03 /* assume Unix */\r
-#endif\r
-\r
-#ifndef F_OPEN\r
-# define F_OPEN(name, mode) fopen((name), (mode))\r
-#endif\r
-\r
- /* functions */\r
-\r
-#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)\r
-# ifndef HAVE_VSNPRINTF\r
-# define HAVE_VSNPRINTF\r
-# endif\r
-#endif\r
-#if defined(__CYGWIN__)\r
-# ifndef HAVE_VSNPRINTF\r
-# define HAVE_VSNPRINTF\r
-# endif\r
-#endif\r
-#ifndef HAVE_VSNPRINTF\r
-# ifdef MSDOS\r
- /* vsnprintf may exist on some MS-DOS compilers (DJGPP?),\r
- but for now we just assume it doesn't. */\r
-# define NO_vsnprintf\r
-# endif\r
-# ifdef __TURBOC__\r
-# define NO_vsnprintf\r
-# endif\r
-# ifdef WIN32\r
- /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */\r
-# if !defined(vsnprintf) && !defined(NO_vsnprintf)\r
-# define vsnprintf _vsnprintf\r
-# endif\r
-# endif\r
-# ifdef __SASC\r
-# define NO_vsnprintf\r
-# endif\r
-#endif\r
-#ifdef VMS\r
-# define NO_vsnprintf\r
-#endif\r
-\r
-#if defined(pyr)\r
-# define NO_MEMCPY\r
-#endif\r
-#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)\r
- /* Use our own functions for small and medium model with MSC <= 5.0.\r
- * You may have to use the same strategy for Borland C (untested).\r
- * The __SC__ check is for Symantec.\r
- */\r
-# define NO_MEMCPY\r
-#endif\r
-#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)\r
-# define HAVE_MEMCPY\r
-#endif\r
-#ifdef HAVE_MEMCPY\r
-# ifdef SMALL_MEDIUM /* MSDOS small or medium model */\r
-# define zmemcpy _fmemcpy\r
-# define zmemcmp _fmemcmp\r
-# define zmemzero(dest, len) _fmemset(dest, 0, len)\r
-# else\r
-# define zmemcpy memcpy\r
-# define zmemcmp memcmp\r
-# define zmemzero(dest, len) memset(dest, 0, len)\r
-# endif\r
-#else\r
- extern void zmemcpy OF((Bytef* dest, const Bytef* source, uInt len));\r
- extern int zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len));\r
- extern void zmemzero OF((Bytef* dest, uInt len));\r
-#endif\r
-\r
-/* Diagnostic functions */\r
-#ifdef DEBUG\r
-# include <stdio.h>\r
- extern int z_verbose;\r
- extern void z_error OF((char *m));\r
-# define Assert(cond,msg) {if(!(cond)) z_error(msg);}\r
-# define Trace(x) {if (z_verbose>=0) fprintf x ;}\r
-# define Tracev(x) {if (z_verbose>0) fprintf x ;}\r
-# define Tracevv(x) {if (z_verbose>1) fprintf x ;}\r
-# define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}\r
-# define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}\r
-#else\r
-# define Assert(cond,msg)\r
-# define Trace(x)\r
-# define Tracev(x)\r
-# define Tracevv(x)\r
-# define Tracec(c,x)\r
-# define Tracecv(c,x)\r
-#endif\r
-\r
-\r
-voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size));\r
-void zcfree OF((voidpf opaque, voidpf ptr));\r
-\r
-#define ZALLOC(strm, items, size) \\r
- (*((strm)->zalloc))((strm)->opaque, (items), (size))\r
-#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))\r
-#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}\r
-\r
-#endif /* ZUTIL_H */\r
+++ /dev/null
-/* stringlib: locale related helpers implementation */\r
-\r
-#ifndef STRINGLIB_LOCALEUTIL_H\r
-#define STRINGLIB_LOCALEUTIL_H\r
-\r
-#include <locale.h>\r
-\r
-// Prevent conflicts with EFI\r
-#undef MAX\r
-#undef MIN\r
-\r
-#define MAX(x, y) ((x) < (y) ? (y) : (x))\r
-#define MIN(x, y) ((x) < (y) ? (x) : (y))\r
-\r
-typedef struct {\r
- const char *grouping;\r
- char previous;\r
- Py_ssize_t i; /* Where we're currently pointing in grouping. */\r
-} GroupGenerator;\r
-\r
-static void\r
-_GroupGenerator_init(GroupGenerator *self, const char *grouping)\r
-{\r
- self->grouping = grouping;\r
- self->i = 0;\r
- self->previous = 0;\r
-}\r
-\r
-/* Returns the next grouping, or 0 to signify end. */\r
-static Py_ssize_t\r
-_GroupGenerator_next(GroupGenerator *self)\r
-{\r
- /* Note that we don't really do much error checking here. If a\r
- grouping string contains just CHAR_MAX, for example, then just\r
- terminate the generator. That shouldn't happen, but at least we\r
- fail gracefully. */\r
- switch (self->grouping[self->i]) {\r
- case 0:\r
- return self->previous;\r
- case CHAR_MAX:\r
- /* Stop the generator. */\r
- return 0;\r
- default: {\r
- char ch = self->grouping[self->i];\r
- self->previous = ch;\r
- self->i++;\r
- return (Py_ssize_t)ch;\r
- }\r
- }\r
-}\r
-\r
-/* Fill in some digits, leading zeros, and thousands separator. All\r
- are optional, depending on when we're called. */\r
-static void\r
-fill(STRINGLIB_CHAR **digits_end, STRINGLIB_CHAR **buffer_end,\r
- Py_ssize_t n_chars, Py_ssize_t n_zeros, const char* thousands_sep,\r
- Py_ssize_t thousands_sep_len)\r
-{\r
-#if STRINGLIB_IS_UNICODE\r
- Py_ssize_t i;\r
-#endif\r
-\r
- if (thousands_sep) {\r
- *buffer_end -= thousands_sep_len;\r
-\r
- /* Copy the thousands_sep chars into the buffer. */\r
-#if STRINGLIB_IS_UNICODE\r
- /* Convert from the char's of the thousands_sep from\r
- the locale into unicode. */\r
- for (i = 0; i < thousands_sep_len; ++i)\r
- (*buffer_end)[i] = thousands_sep[i];\r
-#else\r
- /* No conversion, just memcpy the thousands_sep. */\r
- memcpy(*buffer_end, thousands_sep, thousands_sep_len);\r
-#endif\r
- }\r
-\r
- *buffer_end -= n_chars;\r
- *digits_end -= n_chars;\r
- memcpy(*buffer_end, *digits_end, n_chars * sizeof(STRINGLIB_CHAR));\r
-\r
- *buffer_end -= n_zeros;\r
- STRINGLIB_FILL(*buffer_end, '0', n_zeros);\r
-}\r
-\r
-/**\r
- * _Py_InsertThousandsGrouping:\r
- * @buffer: A pointer to the start of a string.\r
- * @n_buffer: Number of characters in @buffer.\r
- * @digits: A pointer to the digits we're reading from. If count\r
- * is non-NULL, this is unused.\r
- * @n_digits: The number of digits in the string, in which we want\r
- * to put the grouping chars.\r
- * @min_width: The minimum width of the digits in the output string.\r
- * Output will be zero-padded on the left to fill.\r
- * @grouping: see definition in localeconv().\r
- * @thousands_sep: see definition in localeconv().\r
- *\r
- * There are 2 modes: counting and filling. If @buffer is NULL,\r
- * we are in counting mode, else filling mode.\r
- * If counting, the required buffer size is returned.\r
- * If filling, we know the buffer will be large enough, so we don't\r
- * need to pass in the buffer size.\r
- * Inserts thousand grouping characters (as defined by grouping and\r
- * thousands_sep) into the string between buffer and buffer+n_digits.\r
- *\r
- * Return value: 0 on error, else 1. Note that no error can occur if\r
- * count is non-NULL.\r
- *\r
- * This name won't be used, the includer of this file should define\r
- * it to be the actual function name, based on unicode or string.\r
- *\r
- * As closely as possible, this code mimics the logic in decimal.py's\r
- _insert_thousands_sep().\r
- **/\r
-Py_ssize_t\r
-_Py_InsertThousandsGrouping(STRINGLIB_CHAR *buffer,\r
- Py_ssize_t n_buffer,\r
- STRINGLIB_CHAR *digits,\r
- Py_ssize_t n_digits,\r
- Py_ssize_t min_width,\r
- const char *grouping,\r
- const char *thousands_sep)\r
-{\r
- Py_ssize_t count = 0;\r
- Py_ssize_t n_zeros;\r
- int loop_broken = 0;\r
- int use_separator = 0; /* First time through, don't append the\r
- separator. They only go between\r
- groups. */\r
- STRINGLIB_CHAR *buffer_end = NULL;\r
- STRINGLIB_CHAR *digits_end = NULL;\r
- Py_ssize_t l;\r
- Py_ssize_t n_chars;\r
- Py_ssize_t thousands_sep_len = strlen(thousands_sep);\r
- Py_ssize_t remaining = n_digits; /* Number of chars remaining to\r
- be looked at */\r
- /* A generator that returns all of the grouping widths, until it\r
- returns 0. */\r
- GroupGenerator groupgen;\r
- _GroupGenerator_init(&groupgen, grouping);\r
-\r
- if (buffer) {\r
- buffer_end = buffer + n_buffer;\r
- digits_end = digits + n_digits;\r
- }\r
-\r
- while ((l = _GroupGenerator_next(&groupgen)) > 0) {\r
- l = MIN(l, MAX(MAX(remaining, min_width), 1));\r
- n_zeros = MAX(0, l - remaining);\r
- n_chars = MAX(0, MIN(remaining, l));\r
-\r
- /* Use n_zero zero's and n_chars chars */\r
-\r
- /* Count only, don't do anything. */\r
- count += (use_separator ? thousands_sep_len : 0) + n_zeros + n_chars;\r
-\r
- if (buffer) {\r
- /* Copy into the output buffer. */\r
- fill(&digits_end, &buffer_end, n_chars, n_zeros,\r
- use_separator ? thousands_sep : NULL, thousands_sep_len);\r
- }\r
-\r
- /* Use a separator next time. */\r
- use_separator = 1;\r
-\r
- remaining -= n_chars;\r
- min_width -= l;\r
-\r
- if (remaining <= 0 && min_width <= 0) {\r
- loop_broken = 1;\r
- break;\r
- }\r
- min_width -= thousands_sep_len;\r
- }\r
- if (!loop_broken) {\r
- /* We left the loop without using a break statement. */\r
-\r
- l = MAX(MAX(remaining, min_width), 1);\r
- n_zeros = MAX(0, l - remaining);\r
- n_chars = MAX(0, MIN(remaining, l));\r
-\r
- /* Use n_zero zero's and n_chars chars */\r
- count += (use_separator ? thousands_sep_len : 0) + n_zeros + n_chars;\r
- if (buffer) {\r
- /* Copy into the output buffer. */\r
- fill(&digits_end, &buffer_end, n_chars, n_zeros,\r
- use_separator ? thousands_sep : NULL, thousands_sep_len);\r
- }\r
- }\r
- return count;\r
-}\r
-\r
-/**\r
- * _Py_InsertThousandsGroupingLocale:\r
- * @buffer: A pointer to the start of a string.\r
- * @n_digits: The number of digits in the string, in which we want\r
- * to put the grouping chars.\r
- *\r
- * Reads thee current locale and calls _Py_InsertThousandsGrouping().\r
- **/\r
-Py_ssize_t\r
-_Py_InsertThousandsGroupingLocale(STRINGLIB_CHAR *buffer,\r
- Py_ssize_t n_buffer,\r
- STRINGLIB_CHAR *digits,\r
- Py_ssize_t n_digits,\r
- Py_ssize_t min_width)\r
-{\r
- struct lconv *locale_data = localeconv();\r
- const char *grouping = locale_data->grouping;\r
- const char *thousands_sep = locale_data->thousands_sep;\r
-\r
- return _Py_InsertThousandsGrouping(buffer, n_buffer, digits, n_digits,\r
- min_width, grouping, thousands_sep);\r
-}\r
-#endif /* STRINGLIB_LOCALEUTIL_H */\r
--- /dev/null
+/*\r
+ * Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project.\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ * 3. Neither the name of the project nor the names of its contributors\r
+ * may be used to endorse or promote products derived from this software\r
+ * without specific prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND\r
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE\r
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
+ * SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef HAVE_GETADDRINFO\r
+\r
+/*\r
+ * Error return codes from getaddrinfo()\r
+ */\r
+#ifdef EAI_ADDRFAMILY\r
+/* If this is defined, there is a conflicting implementation\r
+ in the C library, which can't be used for some reason.\r
+ Make sure it won't interfere with this emulation. */\r
+\r
+#undef EAI_ADDRFAMILY\r
+#undef EAI_AGAIN\r
+#undef EAI_BADFLAGS\r
+#undef EAI_FAIL\r
+#undef EAI_FAMILY\r
+#undef EAI_MEMORY\r
+#undef EAI_NODATA\r
+#undef EAI_NONAME\r
+#undef EAI_SERVICE\r
+#undef EAI_SOCKTYPE\r
+#undef EAI_SYSTEM\r
+#undef EAI_BADHINTS\r
+#undef EAI_PROTOCOL\r
+#undef EAI_MAX\r
+#undef getaddrinfo\r
+#define getaddrinfo fake_getaddrinfo\r
+#endif /* EAI_ADDRFAMILY */\r
+\r
+#define EAI_ADDRFAMILY 1 /* address family for hostname not supported */\r
+#define EAI_AGAIN 2 /* temporary failure in name resolution */\r
+#define EAI_BADFLAGS 3 /* invalid value for ai_flags */\r
+#define EAI_FAIL 4 /* non-recoverable failure in name resolution */\r
+#define EAI_FAMILY 5 /* ai_family not supported */\r
+#define EAI_MEMORY 6 /* memory allocation failure */\r
+#define EAI_NODATA 7 /* no address associated with hostname */\r
+#define EAI_NONAME 8 /* hostname nor servname provided, or not known */\r
+#define EAI_SERVICE 9 /* servname not supported for ai_socktype */\r
+#define EAI_SOCKTYPE 10 /* ai_socktype not supported */\r
+#define EAI_SYSTEM 11 /* system error returned in errno */\r
+#define EAI_BADHINTS 12\r
+#define EAI_PROTOCOL 13\r
+#define EAI_MAX 14\r
+\r
+/*\r
+ * Flag values for getaddrinfo()\r
+ */\r
+#ifdef AI_PASSIVE\r
+#undef AI_PASSIVE\r
+#undef AI_CANONNAME\r
+#undef AI_NUMERICHOST\r
+#undef AI_MASK\r
+#undef AI_ALL\r
+#undef AI_V4MAPPED_CFG\r
+#undef AI_ADDRCONFIG\r
+#undef AI_V4MAPPED\r
+#undef AI_DEFAULT\r
+#endif /* AI_PASSIVE */\r
+\r
+#define AI_PASSIVE 0x00000001 /* get address to use bind() */\r
+#define AI_CANONNAME 0x00000002 /* fill ai_canonname */\r
+#define AI_NUMERICHOST 0x00000004 /* prevent name resolution */\r
+/* valid flags for addrinfo */\r
+#define AI_MASK (AI_PASSIVE | AI_CANONNAME | AI_NUMERICHOST)\r
+\r
+#define AI_ALL 0x00000100 /* IPv6 and IPv4-mapped (with AI_V4MAPPED) */\r
+#define AI_V4MAPPED_CFG 0x00000200 /* accept IPv4-mapped if kernel supports */\r
+#define AI_ADDRCONFIG 0x00000400 /* only if any address is assigned */\r
+#define AI_V4MAPPED 0x00000800 /* accept IPv4-mapped IPv6 address */\r
+/* special recommended flags for getipnodebyname */\r
+#define AI_DEFAULT (AI_V4MAPPED_CFG | AI_ADDRCONFIG)\r
+\r
+#endif /* !HAVE_GETADDRINFO */\r
+\r
+#ifndef HAVE_GETNAMEINFO\r
+\r
+/*\r
+ * Constants for getnameinfo()\r
+ */\r
+#ifndef NI_MAXHOST\r
+#define NI_MAXHOST 1025\r
+#define NI_MAXSERV 32\r
+#endif /* !NI_MAXHOST */\r
+\r
+/*\r
+ * Flag values for getnameinfo()\r
+ */\r
+#ifndef NI_NOFQDN\r
+#define NI_NOFQDN 0x00000001\r
+#define NI_NUMERICHOST 0x00000002\r
+#define NI_NAMEREQD 0x00000004\r
+#define NI_NUMERICSERV 0x00000008\r
+#define NI_DGRAM 0x00000010\r
+#endif /* !NI_NOFQDN */\r
+\r
+#endif /* !HAVE_GETNAMEINFO */\r
+\r
+#ifndef _SYS_SOCKET_H_\r
+ #ifndef HAVE_ADDRINFO\r
+ struct addrinfo {\r
+ int ai_flags; /* AI_PASSIVE, AI_CANONNAME */\r
+ int ai_family; /* PF_xxx */\r
+ int ai_socktype; /* SOCK_xxx */\r
+ int ai_protocol; /* 0 or IPPROTO_xxx for IPv4 and IPv6 */\r
+ size_t ai_addrlen; /* length of ai_addr */\r
+ char *ai_canonname; /* canonical name for hostname */\r
+ struct sockaddr *ai_addr; /* binary address */\r
+ struct addrinfo *ai_next; /* next structure in linked list */\r
+ };\r
+ #endif /* !HAVE_ADDRINFO */\r
+\r
+ #ifndef HAVE_SOCKADDR_STORAGE\r
+ /*\r
+ * RFC 2553: protocol-independent placeholder for socket addresses\r
+ */\r
+ #define _SS_MAXSIZE 128\r
+ #ifdef HAVE_LONG_LONG\r
+ #define _SS_ALIGNSIZE (sizeof(PY_LONG_LONG))\r
+ #else\r
+ #define _SS_ALIGNSIZE (sizeof(double))\r
+ #endif /* HAVE_LONG_LONG */\r
+ #define _SS_PAD1SIZE (_SS_ALIGNSIZE - sizeof(u_char) * 2)\r
+ #define _SS_PAD2SIZE (_SS_MAXSIZE - sizeof(u_char) * 2 - \\r
+ _SS_PAD1SIZE - _SS_ALIGNSIZE)\r
+\r
+ struct sockaddr_storage {\r
+ #ifdef HAVE_SOCKADDR_SA_LEN\r
+ unsigned char ss_len; /* address length */\r
+ unsigned char ss_family; /* address family */\r
+ #else\r
+ unsigned short ss_family; /* address family */\r
+ #endif /* HAVE_SOCKADDR_SA_LEN */\r
+ char __ss_pad1[_SS_PAD1SIZE];\r
+ #ifdef HAVE_LONG_LONG\r
+ PY_LONG_LONG __ss_align; /* force desired structure storage alignment */\r
+ #else\r
+ double __ss_align; /* force desired structure storage alignment */\r
+ #endif /* HAVE_LONG_LONG */\r
+ char __ss_pad2[_SS_PAD2SIZE];\r
+ };\r
+ #endif /* !HAVE_SOCKADDR_STORAGE */\r
+#endif /* _SYS_SOCKET_H_ */\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+extern void freehostent Py_PROTO((struct hostent *));\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
\r
* Copyright (C) 1995-2005 Jean-loup Gailly.\r
* For conditions of distribution and use, see copyright notice in zlib.h\r
- */\r
+**/\r
\r
/* WARNING: this file should *not* be used by applications. It is\r
part of the implementation of the compression library and is\r
subject to change. Applications should only use zlib.h.\r
*/\r
\r
-/* @(#) $Id$ */\r
-\r
#ifndef ZUTIL_H\r
#define ZUTIL_H\r
\r
#define ZLIB_INTERNAL\r
#include "zlib.h"\r
\r
-#ifdef STDC\r
+#if defined(UEFI_C_SOURCE) || defined(STDC)\r
# ifndef _WIN32_WCE\r
# include <stddef.h>\r
# endif\r
# define fdopen(fd,mode) NULL /* No fdopen() */\r
#endif\r
\r
-#if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined(UEFI_C_SOURCE)\r
+#if !defined(UEFI_C_SOURCE) && (defined(_MSC_VER) && (_MSC_VER > 600))\r
# if defined(_WIN32_WCE)\r
# define fdopen(fd,mode) NULL /* No fdopen() */\r
# ifndef _PTRDIFF_T_DEFINED\r
--- /dev/null
+\r
+/* Module definition and import implementation */\r
+\r
+#include "Python.h"\r
+\r
+#include "Python-ast.h"\r
+#undef Yield /* undefine macro conflicting with winbase.h */\r
+#include "pyarena.h"\r
+#include "pythonrun.h"\r
+#include "errcode.h"\r
+#include "marshal.h"\r
+#include "code.h"\r
+#include "compile.h"\r
+#include "eval.h"\r
+#include "osdefs.h"\r
+#include "importdl.h"\r
+\r
+#ifdef HAVE_FCNTL_H\r
+#include <fcntl.h>\r
+#endif\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+#ifdef MS_WINDOWS\r
+/* for stat.st_mode */\r
+typedef unsigned short mode_t;\r
+#endif\r
+\r
+\r
+/* Magic word to reject .pyc files generated by other Python versions.\r
+ It should change for each incompatible change to the bytecode.\r
+\r
+ The value of CR and LF is incorporated so if you ever read or write\r
+ a .pyc file in text mode the magic number will be wrong; also, the\r
+ Apple MPW compiler swaps their values, botching string constants.\r
+\r
+ The magic numbers must be spaced apart atleast 2 values, as the\r
+ -U interpeter flag will cause MAGIC+1 being used. They have been\r
+ odd numbers for some time now.\r
+\r
+ There were a variety of old schemes for setting the magic number.\r
+ The current working scheme is to increment the previous value by\r
+ 10.\r
+\r
+ Known values:\r
+ Python 1.5: 20121\r
+ Python 1.5.1: 20121\r
+ Python 1.5.2: 20121\r
+ Python 1.6: 50428\r
+ Python 2.0: 50823\r
+ Python 2.0.1: 50823\r
+ Python 2.1: 60202\r
+ Python 2.1.1: 60202\r
+ Python 2.1.2: 60202\r
+ Python 2.2: 60717\r
+ Python 2.3a0: 62011\r
+ Python 2.3a0: 62021\r
+ Python 2.3a0: 62011 (!)\r
+ Python 2.4a0: 62041\r
+ Python 2.4a3: 62051\r
+ Python 2.4b1: 62061\r
+ Python 2.5a0: 62071\r
+ Python 2.5a0: 62081 (ast-branch)\r
+ Python 2.5a0: 62091 (with)\r
+ Python 2.5a0: 62092 (changed WITH_CLEANUP opcode)\r
+ Python 2.5b3: 62101 (fix wrong code: for x, in ...)\r
+ Python 2.5b3: 62111 (fix wrong code: x += yield)\r
+ Python 2.5c1: 62121 (fix wrong lnotab with for loops and\r
+ storing constants that should have been removed)\r
+ Python 2.5c2: 62131 (fix wrong code: for x, in ... in listcomp/genexp)\r
+ Python 2.6a0: 62151 (peephole optimizations and STORE_MAP opcode)\r
+ Python 2.6a1: 62161 (WITH_CLEANUP optimization)\r
+ Python 2.7a0: 62171 (optimize list comprehensions/change LIST_APPEND)\r
+ Python 2.7a0: 62181 (optimize conditional branches:\r
+ introduce POP_JUMP_IF_FALSE and POP_JUMP_IF_TRUE)\r
+ Python 2.7a0 62191 (introduce SETUP_WITH)\r
+ Python 2.7a0 62201 (introduce BUILD_SET)\r
+ Python 2.7a0 62211 (introduce MAP_ADD and SET_ADD)\r
+.\r
+*/\r
+#define MAGIC (62211 | ((long)'\r'<<16) | ((long)'\n'<<24))\r
+\r
+/* Magic word as global; note that _PyImport_Init() can change the\r
+ value of this global to accommodate for alterations of how the\r
+ compiler works which are enabled by command line switches. */\r
+static long pyc_magic = MAGIC;\r
+\r
+/* See _PyImport_FixupExtension() below */\r
+static PyObject *extensions = NULL;\r
+\r
+/* This table is defined in config.c: */\r
+extern struct _inittab _PyImport_Inittab[];\r
+\r
+struct _inittab *PyImport_Inittab = _PyImport_Inittab;\r
+\r
+/* these tables define the module suffixes that Python recognizes */\r
+struct filedescr * _PyImport_Filetab = NULL;\r
+\r
+#ifdef RISCOS\r
+static const struct filedescr _PyImport_StandardFiletab[] = {\r
+ {"/py", "U", PY_SOURCE},\r
+ {"/pyc", "rb", PY_COMPILED},\r
+ {0, 0}\r
+};\r
+#else\r
+static const struct filedescr _PyImport_StandardFiletab[] = {\r
+ {".py", "U", PY_SOURCE},\r
+#ifdef MS_WINDOWS\r
+ {".pyw", "U", PY_SOURCE},\r
+#endif\r
+ {".pyc", "rb", PY_COMPILED},\r
+ {0, 0}\r
+};\r
+#endif\r
+\r
+\r
+/* Initialize things */\r
+\r
+void\r
+_PyImport_Init(void)\r
+{\r
+ const struct filedescr *scan;\r
+ struct filedescr *filetab;\r
+ int countD = 0;\r
+ int countS = 0;\r
+\r
+ /* prepare _PyImport_Filetab: copy entries from\r
+ _PyImport_DynLoadFiletab and _PyImport_StandardFiletab.\r
+ */\r
+#ifdef HAVE_DYNAMIC_LOADING\r
+ for (scan = _PyImport_DynLoadFiletab; scan->suffix != NULL; ++scan)\r
+ ++countD;\r
+#endif\r
+ for (scan = _PyImport_StandardFiletab; scan->suffix != NULL; ++scan)\r
+ ++countS;\r
+ filetab = PyMem_NEW(struct filedescr, countD + countS + 1);\r
+ if (filetab == NULL)\r
+ Py_FatalError("Can't initialize import file table.");\r
+#ifdef HAVE_DYNAMIC_LOADING\r
+ memcpy(filetab, _PyImport_DynLoadFiletab,\r
+ countD * sizeof(struct filedescr));\r
+#endif\r
+ memcpy(filetab + countD, _PyImport_StandardFiletab,\r
+ countS * sizeof(struct filedescr));\r
+ filetab[countD + countS].suffix = NULL;\r
+\r
+ _PyImport_Filetab = filetab;\r
+\r
+ if (Py_OptimizeFlag) {\r
+ /* Replace ".pyc" with ".pyo" in _PyImport_Filetab */\r
+ for (; filetab->suffix != NULL; filetab++) {\r
+#ifndef RISCOS\r
+ if (strcmp(filetab->suffix, ".pyc") == 0)\r
+ filetab->suffix = ".pyo";\r
+#else\r
+ if (strcmp(filetab->suffix, "/pyc") == 0)\r
+ filetab->suffix = "/pyo";\r
+#endif\r
+ }\r
+ }\r
+\r
+ if (Py_UnicodeFlag) {\r
+ /* Fix the pyc_magic so that byte compiled code created\r
+ using the all-Unicode method doesn't interfere with\r
+ code created in normal operation mode. */\r
+ pyc_magic = MAGIC + 1;\r
+ }\r
+}\r
+\r
+void\r
+_PyImportHooks_Init(void)\r
+{\r
+ PyObject *v, *path_hooks = NULL, *zimpimport;\r
+ int err = 0;\r
+\r
+ /* adding sys.path_hooks and sys.path_importer_cache, setting up\r
+ zipimport */\r
+ if (PyType_Ready(&PyNullImporter_Type) < 0)\r
+ goto error;\r
+\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("# installing zipimport hook\n");\r
+\r
+ v = PyList_New(0);\r
+ if (v == NULL)\r
+ goto error;\r
+ err = PySys_SetObject("meta_path", v);\r
+ Py_DECREF(v);\r
+ if (err)\r
+ goto error;\r
+ v = PyDict_New();\r
+ if (v == NULL)\r
+ goto error;\r
+ err = PySys_SetObject("path_importer_cache", v);\r
+ Py_DECREF(v);\r
+ if (err)\r
+ goto error;\r
+ path_hooks = PyList_New(0);\r
+ if (path_hooks == NULL)\r
+ goto error;\r
+ err = PySys_SetObject("path_hooks", path_hooks);\r
+ if (err) {\r
+ error:\r
+ PyErr_Print();\r
+ Py_FatalError("initializing sys.meta_path, sys.path_hooks, "\r
+ "path_importer_cache, or NullImporter failed"\r
+ );\r
+ }\r
+\r
+ zimpimport = PyImport_ImportModule("zipimport");\r
+ if (zimpimport == NULL) {\r
+ PyErr_Clear(); /* No zip import module -- okay */\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("# can't import zipimport\n");\r
+ }\r
+ else {\r
+ PyObject *zipimporter = PyObject_GetAttrString(zimpimport,\r
+ "zipimporter");\r
+ Py_DECREF(zimpimport);\r
+ if (zipimporter == NULL) {\r
+ PyErr_Clear(); /* No zipimporter object -- okay */\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr(\r
+ "# can't import zipimport.zipimporter\n");\r
+ }\r
+ else {\r
+ /* sys.path_hooks.append(zipimporter) */\r
+ err = PyList_Append(path_hooks, zipimporter);\r
+ Py_DECREF(zipimporter);\r
+ if (err)\r
+ goto error;\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr(\r
+ "# installed zipimport hook\n");\r
+ }\r
+ }\r
+ Py_DECREF(path_hooks);\r
+}\r
+\r
+void\r
+_PyImport_Fini(void)\r
+{\r
+ Py_XDECREF(extensions);\r
+ extensions = NULL;\r
+ PyMem_DEL(_PyImport_Filetab);\r
+ _PyImport_Filetab = NULL;\r
+}\r
+\r
+\r
+/* Locking primitives to prevent parallel imports of the same module\r
+ in different threads to return with a partially loaded module.\r
+ These calls are serialized by the global interpreter lock. */\r
+\r
+#ifdef WITH_THREAD\r
+\r
+#include "pythread.h"\r
+\r
+static PyThread_type_lock import_lock = 0;\r
+static long import_lock_thread = -1;\r
+static int import_lock_level = 0;\r
+\r
+void\r
+_PyImport_AcquireLock(void)\r
+{\r
+ long me = PyThread_get_thread_ident();\r
+ if (me == -1)\r
+ return; /* Too bad */\r
+ if (import_lock == NULL) {\r
+ import_lock = PyThread_allocate_lock();\r
+ if (import_lock == NULL)\r
+ return; /* Nothing much we can do. */\r
+ }\r
+ if (import_lock_thread == me) {\r
+ import_lock_level++;\r
+ return;\r
+ }\r
+ if (import_lock_thread != -1 || !PyThread_acquire_lock(import_lock, 0))\r
+ {\r
+ PyThreadState *tstate = PyEval_SaveThread();\r
+ PyThread_acquire_lock(import_lock, 1);\r
+ PyEval_RestoreThread(tstate);\r
+ }\r
+ import_lock_thread = me;\r
+ import_lock_level = 1;\r
+}\r
+\r
+int\r
+_PyImport_ReleaseLock(void)\r
+{\r
+ long me = PyThread_get_thread_ident();\r
+ if (me == -1 || import_lock == NULL)\r
+ return 0; /* Too bad */\r
+ if (import_lock_thread != me)\r
+ return -1;\r
+ import_lock_level--;\r
+ if (import_lock_level == 0) {\r
+ import_lock_thread = -1;\r
+ PyThread_release_lock(import_lock);\r
+ }\r
+ return 1;\r
+}\r
+\r
+/* This function is called from PyOS_AfterFork to ensure that newly\r
+ created child processes do not share locks with the parent.\r
+ We now acquire the import lock around fork() calls but on some platforms\r
+ (Solaris 9 and earlier? see isue7242) that still left us with problems. */\r
+\r
+void\r
+_PyImport_ReInitLock(void)\r
+{\r
+ if (import_lock != NULL)\r
+ import_lock = PyThread_allocate_lock();\r
+ import_lock_thread = -1;\r
+ import_lock_level = 0;\r
+}\r
+\r
+#endif\r
+\r
+static PyObject *\r
+imp_lock_held(PyObject *self, PyObject *noargs)\r
+{\r
+#ifdef WITH_THREAD\r
+ return PyBool_FromLong(import_lock_thread != -1);\r
+#else\r
+ return PyBool_FromLong(0);\r
+#endif\r
+}\r
+\r
+static PyObject *\r
+imp_acquire_lock(PyObject *self, PyObject *noargs)\r
+{\r
+#ifdef WITH_THREAD\r
+ _PyImport_AcquireLock();\r
+#endif\r
+ Py_INCREF(Py_None);\r
+ return Py_None;\r
+}\r
+\r
+static PyObject *\r
+imp_release_lock(PyObject *self, PyObject *noargs)\r
+{\r
+#ifdef WITH_THREAD\r
+ if (_PyImport_ReleaseLock() < 0) {\r
+ PyErr_SetString(PyExc_RuntimeError,\r
+ "not holding the import lock");\r
+ return NULL;\r
+ }\r
+#endif\r
+ Py_INCREF(Py_None);\r
+ return Py_None;\r
+}\r
+\r
+static void\r
+imp_modules_reloading_clear(void)\r
+{\r
+ PyInterpreterState *interp = PyThreadState_Get()->interp;\r
+ if (interp->modules_reloading != NULL)\r
+ PyDict_Clear(interp->modules_reloading);\r
+}\r
+\r
+/* Helper for sys */\r
+\r
+PyObject *\r
+PyImport_GetModuleDict(void)\r
+{\r
+ PyInterpreterState *interp = PyThreadState_GET()->interp;\r
+ if (interp->modules == NULL)\r
+ Py_FatalError("PyImport_GetModuleDict: no module dictionary!");\r
+ return interp->modules;\r
+}\r
+\r
+\r
+/* List of names to clear in sys */\r
+static char* sys_deletes[] = {\r
+ "path", "argv", "ps1", "ps2", "exitfunc",\r
+ "exc_type", "exc_value", "exc_traceback",\r
+ "last_type", "last_value", "last_traceback",\r
+ "path_hooks", "path_importer_cache", "meta_path",\r
+ /* misc stuff */\r
+ "flags", "float_info",\r
+ NULL\r
+};\r
+\r
+static char* sys_files[] = {\r
+ "stdin", "__stdin__",\r
+ "stdout", "__stdout__",\r
+ "stderr", "__stderr__",\r
+ NULL\r
+};\r
+\r
+\r
+/* Un-initialize things, as good as we can */\r
+\r
+void\r
+PyImport_Cleanup(void)\r
+{\r
+ Py_ssize_t pos, ndone;\r
+ char *name;\r
+ PyObject *key, *value, *dict;\r
+ PyInterpreterState *interp = PyThreadState_GET()->interp;\r
+ PyObject *modules = interp->modules;\r
+\r
+ if (modules == NULL)\r
+ return; /* Already done */\r
+\r
+ /* Delete some special variables first. These are common\r
+ places where user values hide and people complain when their\r
+ destructors fail. Since the modules containing them are\r
+ deleted *last* of all, they would come too late in the normal\r
+ destruction order. Sigh. */\r
+\r
+ value = PyDict_GetItemString(modules, "__builtin__");\r
+ if (value != NULL && PyModule_Check(value)) {\r
+ dict = PyModule_GetDict(value);\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("# clear __builtin__._\n");\r
+ PyDict_SetItemString(dict, "_", Py_None);\r
+ }\r
+ value = PyDict_GetItemString(modules, "sys");\r
+ if (value != NULL && PyModule_Check(value)) {\r
+ char **p;\r
+ PyObject *v;\r
+ dict = PyModule_GetDict(value);\r
+ for (p = sys_deletes; *p != NULL; p++) {\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("# clear sys.%s\n", *p);\r
+ PyDict_SetItemString(dict, *p, Py_None);\r
+ }\r
+ for (p = sys_files; *p != NULL; p+=2) {\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("# restore sys.%s\n", *p);\r
+ v = PyDict_GetItemString(dict, *(p+1));\r
+ if (v == NULL)\r
+ v = Py_None;\r
+ PyDict_SetItemString(dict, *p, v);\r
+ }\r
+ }\r
+\r
+ /* First, delete __main__ */\r
+ value = PyDict_GetItemString(modules, "__main__");\r
+ if (value != NULL && PyModule_Check(value)) {\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("# cleanup __main__\n");\r
+ _PyModule_Clear(value);\r
+ PyDict_SetItemString(modules, "__main__", Py_None);\r
+ }\r
+\r
+ /* The special treatment of __builtin__ here is because even\r
+ when it's not referenced as a module, its dictionary is\r
+ referenced by almost every module's __builtins__. Since\r
+ deleting a module clears its dictionary (even if there are\r
+ references left to it), we need to delete the __builtin__\r
+ module last. Likewise, we don't delete sys until the very\r
+ end because it is implicitly referenced (e.g. by print).\r
+\r
+ Also note that we 'delete' modules by replacing their entry\r
+ in the modules dict with None, rather than really deleting\r
+ them; this avoids a rehash of the modules dictionary and\r
+ also marks them as "non existent" so they won't be\r
+ re-imported. */\r
+\r
+ /* Next, repeatedly delete modules with a reference count of\r
+ one (skipping __builtin__ and sys) and delete them */\r
+ do {\r
+ ndone = 0;\r
+ pos = 0;\r
+ while (PyDict_Next(modules, &pos, &key, &value)) {\r
+ if (value->ob_refcnt != 1)\r
+ continue;\r
+ if (PyString_Check(key) && PyModule_Check(value)) {\r
+ name = PyString_AS_STRING(key);\r
+ if (strcmp(name, "__builtin__") == 0)\r
+ continue;\r
+ if (strcmp(name, "sys") == 0)\r
+ continue;\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr(\r
+ "# cleanup[1] %s\n", name);\r
+ _PyModule_Clear(value);\r
+ PyDict_SetItem(modules, key, Py_None);\r
+ ndone++;\r
+ }\r
+ }\r
+ } while (ndone > 0);\r
+\r
+ /* Next, delete all modules (still skipping __builtin__ and sys) */\r
+ pos = 0;\r
+ while (PyDict_Next(modules, &pos, &key, &value)) {\r
+ if (PyString_Check(key) && PyModule_Check(value)) {\r
+ name = PyString_AS_STRING(key);\r
+ if (strcmp(name, "__builtin__") == 0)\r
+ continue;\r
+ if (strcmp(name, "sys") == 0)\r
+ continue;\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("# cleanup[2] %s\n", name);\r
+ _PyModule_Clear(value);\r
+ PyDict_SetItem(modules, key, Py_None);\r
+ }\r
+ }\r
+\r
+ /* Next, delete sys and __builtin__ (in that order) */\r
+ value = PyDict_GetItemString(modules, "sys");\r
+ if (value != NULL && PyModule_Check(value)) {\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("# cleanup sys\n");\r
+ _PyModule_Clear(value);\r
+ PyDict_SetItemString(modules, "sys", Py_None);\r
+ }\r
+ value = PyDict_GetItemString(modules, "__builtin__");\r
+ if (value != NULL && PyModule_Check(value)) {\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("# cleanup __builtin__\n");\r
+ _PyModule_Clear(value);\r
+ PyDict_SetItemString(modules, "__builtin__", Py_None);\r
+ }\r
+\r
+ /* Finally, clear and delete the modules directory */\r
+ PyDict_Clear(modules);\r
+ interp->modules = NULL;\r
+ Py_DECREF(modules);\r
+ Py_CLEAR(interp->modules_reloading);\r
+}\r
+\r
+\r
+/* Helper for pythonrun.c -- return magic number */\r
+\r
+long\r
+PyImport_GetMagicNumber(void)\r
+{\r
+ return pyc_magic;\r
+}\r
+\r
+\r
+/* Magic for extension modules (built-in as well as dynamically\r
+ loaded). To prevent initializing an extension module more than\r
+ once, we keep a static dictionary 'extensions' keyed by module name\r
+ (for built-in modules) or by filename (for dynamically loaded\r
+ modules), containing these modules. A copy of the module's\r
+ dictionary is stored by calling _PyImport_FixupExtension()\r
+ immediately after the module initialization function succeeds. A\r
+ copy can be retrieved from there by calling\r
+ _PyImport_FindExtension(). */\r
+\r
+PyObject *\r
+_PyImport_FixupExtension(char *name, char *filename)\r
+{\r
+ PyObject *modules, *mod, *dict, *copy;\r
+ if (extensions == NULL) {\r
+ extensions = PyDict_New();\r
+ if (extensions == NULL)\r
+ return NULL;\r
+ }\r
+ modules = PyImport_GetModuleDict();\r
+ mod = PyDict_GetItemString(modules, name);\r
+ if (mod == NULL || !PyModule_Check(mod)) {\r
+ PyErr_Format(PyExc_SystemError,\r
+ "_PyImport_FixupExtension: module %.200s not loaded", name);\r
+ return NULL;\r
+ }\r
+ dict = PyModule_GetDict(mod);\r
+ if (dict == NULL)\r
+ return NULL;\r
+ copy = PyDict_Copy(dict);\r
+ if (copy == NULL)\r
+ return NULL;\r
+ PyDict_SetItemString(extensions, filename, copy);\r
+ Py_DECREF(copy);\r
+ return copy;\r
+}\r
+\r
+PyObject *\r
+_PyImport_FindExtension(char *name, char *filename)\r
+{\r
+ PyObject *dict, *mod, *mdict;\r
+ if (extensions == NULL)\r
+ return NULL;\r
+ dict = PyDict_GetItemString(extensions, filename);\r
+ if (dict == NULL)\r
+ return NULL;\r
+ mod = PyImport_AddModule(name);\r
+ if (mod == NULL)\r
+ return NULL;\r
+ mdict = PyModule_GetDict(mod);\r
+ if (mdict == NULL)\r
+ return NULL;\r
+ if (PyDict_Update(mdict, dict))\r
+ return NULL;\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("import %s # previously loaded (%s)\n",\r
+ name, filename);\r
+ return mod;\r
+}\r
+\r
+\r
+/* Get the module object corresponding to a module name.\r
+ First check the modules dictionary if there's one there,\r
+ if not, create a new one and insert it in the modules dictionary.\r
+ Because the former action is most common, THIS DOES NOT RETURN A\r
+ 'NEW' REFERENCE! */\r
+\r
+PyObject *\r
+PyImport_AddModule(const char *name)\r
+{\r
+ PyObject *modules = PyImport_GetModuleDict();\r
+ PyObject *m;\r
+\r
+ if ((m = PyDict_GetItemString(modules, name)) != NULL &&\r
+ PyModule_Check(m))\r
+ return m;\r
+ m = PyModule_New(name);\r
+ if (m == NULL)\r
+ return NULL;\r
+ if (PyDict_SetItemString(modules, name, m) != 0) {\r
+ Py_DECREF(m);\r
+ return NULL;\r
+ }\r
+ Py_DECREF(m); /* Yes, it still exists, in modules! */\r
+\r
+ return m;\r
+}\r
+\r
+/* Remove name from sys.modules, if it's there. */\r
+static void\r
+remove_module(const char *name)\r
+{\r
+ PyObject *modules = PyImport_GetModuleDict();\r
+ if (PyDict_GetItemString(modules, name) == NULL)\r
+ return;\r
+ if (PyDict_DelItemString(modules, name) < 0)\r
+ Py_FatalError("import: deleting existing key in"\r
+ "sys.modules failed");\r
+}\r
+\r
+/* Execute a code object in a module and return the module object\r
+ * WITH INCREMENTED REFERENCE COUNT. If an error occurs, name is\r
+ * removed from sys.modules, to avoid leaving damaged module objects\r
+ * in sys.modules. The caller may wish to restore the original\r
+ * module object (if any) in this case; PyImport_ReloadModule is an\r
+ * example.\r
+ */\r
+PyObject *\r
+PyImport_ExecCodeModule(char *name, PyObject *co)\r
+{\r
+ return PyImport_ExecCodeModuleEx(name, co, (char *)NULL);\r
+}\r
+\r
+PyObject *\r
+PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)\r
+{\r
+ PyObject *modules = PyImport_GetModuleDict();\r
+ PyObject *m, *d, *v;\r
+\r
+ m = PyImport_AddModule(name);\r
+ if (m == NULL)\r
+ return NULL;\r
+ /* If the module is being reloaded, we get the old module back\r
+ and re-use its dict to exec the new code. */\r
+ d = PyModule_GetDict(m);\r
+ if (PyDict_GetItemString(d, "__builtins__") == NULL) {\r
+ if (PyDict_SetItemString(d, "__builtins__",\r
+ PyEval_GetBuiltins()) != 0)\r
+ goto error;\r
+ }\r
+ /* Remember the filename as the __file__ attribute */\r
+ v = NULL;\r
+ if (pathname != NULL) {\r
+ v = PyString_FromString(pathname);\r
+ if (v == NULL)\r
+ PyErr_Clear();\r
+ }\r
+ if (v == NULL) {\r
+ v = ((PyCodeObject *)co)->co_filename;\r
+ Py_INCREF(v);\r
+ }\r
+ if (PyDict_SetItemString(d, "__file__", v) != 0)\r
+ PyErr_Clear(); /* Not important enough to report */\r
+ Py_DECREF(v);\r
+\r
+ v = PyEval_EvalCode((PyCodeObject *)co, d, d);\r
+ if (v == NULL)\r
+ goto error;\r
+ Py_DECREF(v);\r
+\r
+ if ((m = PyDict_GetItemString(modules, name)) == NULL) {\r
+ PyErr_Format(PyExc_ImportError,\r
+ "Loaded module %.200s not found in sys.modules",\r
+ name);\r
+ return NULL;\r
+ }\r
+\r
+ Py_INCREF(m);\r
+\r
+ return m;\r
+\r
+ error:\r
+ remove_module(name);\r
+ return NULL;\r
+}\r
+\r
+\r
+/* Given a pathname for a Python source file, fill a buffer with the\r
+ pathname for the corresponding compiled file. Return the pathname\r
+ for the compiled file, or NULL if there's no space in the buffer.\r
+ Doesn't set an exception. */\r
+\r
+static char *\r
+make_compiled_pathname(char *pathname, char *buf, size_t buflen)\r
+{\r
+ size_t len = strlen(pathname);\r
+ if (len+2 > buflen)\r
+ return NULL;\r
+\r
+#ifdef MS_WINDOWS\r
+ /* Treat .pyw as if it were .py. The case of ".pyw" must match\r
+ that used in _PyImport_StandardFiletab. */\r
+ if (len >= 4 && strcmp(&pathname[len-4], ".pyw") == 0)\r
+ --len; /* pretend 'w' isn't there */\r
+#endif\r
+ memcpy(buf, pathname, len);\r
+ buf[len] = Py_OptimizeFlag ? 'o' : 'c';\r
+ buf[len+1] = '\0';\r
+\r
+ return buf;\r
+}\r
+\r
+\r
+/* Given a pathname for a Python source file, its time of last\r
+ modification, and a pathname for a compiled file, check whether the\r
+ compiled file represents the same version of the source. If so,\r
+ return a FILE pointer for the compiled file, positioned just after\r
+ the header; if not, return NULL.\r
+ Doesn't set an exception. */\r
+\r
+static FILE *\r
+check_compiled_module(char *pathname, time_t mtime, char *cpathname)\r
+{\r
+ FILE *fp;\r
+ long magic;\r
+ long pyc_mtime;\r
+\r
+ fp = fopen(cpathname, "rb");\r
+ if (fp == NULL)\r
+ return NULL;\r
+ magic = PyMarshal_ReadLongFromFile(fp);\r
+ if (magic != pyc_magic) {\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("# %s has bad magic\n", cpathname);\r
+ fclose(fp);\r
+ return NULL;\r
+ }\r
+ pyc_mtime = PyMarshal_ReadLongFromFile(fp);\r
+ if (pyc_mtime != mtime) {\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("# %s has bad mtime\n", cpathname);\r
+ fclose(fp);\r
+ return NULL;\r
+ }\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("# %s matches %s\n", cpathname, pathname);\r
+ return fp;\r
+}\r
+\r
+\r
+/* Read a code object from a file and check it for validity */\r
+\r
+static PyCodeObject *\r
+read_compiled_module(char *cpathname, FILE *fp)\r
+{\r
+ PyObject *co;\r
+\r
+ co = PyMarshal_ReadLastObjectFromFile(fp);\r
+ if (co == NULL)\r
+ return NULL;\r
+ if (!PyCode_Check(co)) {\r
+ PyErr_Format(PyExc_ImportError,\r
+ "Non-code object in %.200s", cpathname);\r
+ Py_DECREF(co);\r
+ return NULL;\r
+ }\r
+ return (PyCodeObject *)co;\r
+}\r
+\r
+\r
+/* Load a module from a compiled file, execute it, and return its\r
+ module object WITH INCREMENTED REFERENCE COUNT */\r
+\r
+static PyObject *\r
+load_compiled_module(char *name, char *cpathname, FILE *fp)\r
+{\r
+ long magic;\r
+ PyCodeObject *co;\r
+ PyObject *m;\r
+\r
+ magic = PyMarshal_ReadLongFromFile(fp);\r
+ if (magic != pyc_magic) {\r
+ PyErr_Format(PyExc_ImportError,\r
+ "Bad magic number in %.200s", cpathname);\r
+ return NULL;\r
+ }\r
+ (void) PyMarshal_ReadLongFromFile(fp);\r
+ co = read_compiled_module(cpathname, fp);\r
+ if (co == NULL)\r
+ return NULL;\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("import %s # precompiled from %s\n",\r
+ name, cpathname);\r
+ m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, cpathname);\r
+ Py_DECREF(co);\r
+\r
+ return m;\r
+}\r
+\r
+/* Parse a source file and return the corresponding code object */\r
+\r
+static PyCodeObject *\r
+parse_source_module(const char *pathname, FILE *fp)\r
+{\r
+ PyCodeObject *co = NULL;\r
+ mod_ty mod;\r
+ PyCompilerFlags flags;\r
+ PyArena *arena = PyArena_New();\r
+ if (arena == NULL)\r
+ return NULL;\r
+\r
+ flags.cf_flags = 0;\r
+\r
+ mod = PyParser_ASTFromFile(fp, pathname, Py_file_input, 0, 0, &flags,\r
+ NULL, arena);\r
+ if (mod) {\r
+ co = PyAST_Compile(mod, pathname, NULL, arena);\r
+ }\r
+ PyArena_Free(arena);\r
+ return co;\r
+}\r
+\r
+\r
+/* Helper to open a bytecode file for writing in exclusive mode */\r
+\r
+static FILE *\r
+open_exclusive(char *filename, mode_t mode)\r
+{\r
+#if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC)\r
+ /* Use O_EXCL to avoid a race condition when another process tries to\r
+ write the same file. When that happens, our open() call fails,\r
+ which is just fine (since it's only a cache).\r
+ XXX If the file exists and is writable but the directory is not\r
+ writable, the file will never be written. Oh well.\r
+ */\r
+ int fd;\r
+ (void) unlink(filename);\r
+ fd = open(filename, O_EXCL|O_CREAT|O_WRONLY|O_TRUNC\r
+#ifdef O_BINARY\r
+ |O_BINARY /* necessary for Windows */\r
+#endif\r
+#ifdef __VMS\r
+ , mode, "ctxt=bin", "shr=nil"\r
+#else\r
+ , mode\r
+#endif\r
+ );\r
+ if (fd < 0)\r
+ return NULL;\r
+ return fdopen(fd, "wb");\r
+#else\r
+ /* Best we can do -- on Windows this can't happen anyway */\r
+ return fopen(filename, "wb");\r
+#endif\r
+}\r
+\r
+\r
+/* Write a compiled module to a file, placing the time of last\r
+ modification of its source into the header.\r
+ Errors are ignored, if a write error occurs an attempt is made to\r
+ remove the file. */\r
+\r
+static void\r
+write_compiled_module(PyCodeObject *co, char *cpathname, struct stat *srcstat)\r
+{\r
+ FILE *fp;\r
+ time_t mtime = srcstat->st_mtime;\r
+#ifdef MS_WINDOWS /* since Windows uses different permissions */\r
+ mode_t mode = srcstat->st_mode & ~S_IEXEC;\r
+#else\r
+ mode_t mode = srcstat->st_mode & ~S_IXUSR & ~S_IXGRP & ~S_IXOTH;\r
+#endif\r
+\r
+ fp = open_exclusive(cpathname, mode);\r
+ if (fp == NULL) {\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr(\r
+ "# can't create %s\n", cpathname);\r
+ return;\r
+ }\r
+ PyMarshal_WriteLongToFile(pyc_magic, fp, Py_MARSHAL_VERSION);\r
+ /* First write a 0 for mtime */\r
+ PyMarshal_WriteLongToFile(0L, fp, Py_MARSHAL_VERSION);\r
+ PyMarshal_WriteObjectToFile((PyObject *)co, fp, Py_MARSHAL_VERSION);\r
+ if (fflush(fp) != 0 || ferror(fp)) {\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("# can't write %s\n", cpathname);\r
+ /* Don't keep partial file */\r
+ fclose(fp);\r
+ (void) unlink(cpathname);\r
+ return;\r
+ }\r
+ /* Now write the true mtime */\r
+ fseek(fp, 4L, 0);\r
+ assert(mtime < LONG_MAX);\r
+ PyMarshal_WriteLongToFile((long)mtime, fp, Py_MARSHAL_VERSION);\r
+ fflush(fp);\r
+ fclose(fp);\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("# wrote %s\n", cpathname);\r
+}\r
+\r
+static void\r
+update_code_filenames(PyCodeObject *co, PyObject *oldname, PyObject *newname)\r
+{\r
+ PyObject *constants, *tmp;\r
+ Py_ssize_t i, n;\r
+\r
+ if (!_PyString_Eq(co->co_filename, oldname))\r
+ return;\r
+\r
+ tmp = co->co_filename;\r
+ co->co_filename = newname;\r
+ Py_INCREF(co->co_filename);\r
+ Py_DECREF(tmp);\r
+\r
+ constants = co->co_consts;\r
+ n = PyTuple_GET_SIZE(constants);\r
+ for (i = 0; i < n; i++) {\r
+ tmp = PyTuple_GET_ITEM(constants, i);\r
+ if (PyCode_Check(tmp))\r
+ update_code_filenames((PyCodeObject *)tmp,\r
+ oldname, newname);\r
+ }\r
+}\r
+\r
+static int\r
+update_compiled_module(PyCodeObject *co, char *pathname)\r
+{\r
+ PyObject *oldname, *newname;\r
+\r
+ if (strcmp(PyString_AsString(co->co_filename), pathname) == 0)\r
+ return 0;\r
+\r
+ newname = PyString_FromString(pathname);\r
+ if (newname == NULL)\r
+ return -1;\r
+\r
+ oldname = co->co_filename;\r
+ Py_INCREF(oldname);\r
+ update_code_filenames(co, oldname, newname);\r
+ Py_DECREF(oldname);\r
+ Py_DECREF(newname);\r
+ return 1;\r
+}\r
+\r
+/* Load a source module from a given file and return its module\r
+ object WITH INCREMENTED REFERENCE COUNT. If there's a matching\r
+ byte-compiled file, use that instead. */\r
+\r
+static PyObject *\r
+load_source_module(char *name, char *pathname, FILE *fp)\r
+{\r
+ struct stat st;\r
+ FILE *fpc;\r
+ char buf[MAXPATHLEN+1];\r
+ char *cpathname;\r
+ PyCodeObject *co;\r
+ PyObject *m;\r
+\r
+ if (fstat(fileno(fp), &st) != 0) {\r
+ PyErr_Format(PyExc_RuntimeError,\r
+ "unable to get file status from '%s'",\r
+ pathname);\r
+ return NULL;\r
+ }\r
+#if SIZEOF_TIME_T > 4\r
+ /* Python's .pyc timestamp handling presumes that the timestamp fits\r
+ in 4 bytes. This will be fine until sometime in the year 2038,\r
+ when a 4-byte signed time_t will overflow.\r
+ */\r
+ if (st.st_mtime >> 32) {\r
+ PyErr_SetString(PyExc_OverflowError,\r
+ "modification time overflows a 4 byte field");\r
+ return NULL;\r
+ }\r
+#endif\r
+ cpathname = make_compiled_pathname(pathname, buf,\r
+ (size_t)MAXPATHLEN + 1);\r
+ if (cpathname != NULL &&\r
+ (fpc = check_compiled_module(pathname, st.st_mtime, cpathname))) {\r
+ co = read_compiled_module(cpathname, fpc);\r
+ fclose(fpc);\r
+ if (co == NULL)\r
+ return NULL;\r
+ if (update_compiled_module(co, pathname) < 0)\r
+ return NULL;\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("import %s # precompiled from %s\n",\r
+ name, cpathname);\r
+ pathname = cpathname;\r
+ }\r
+ else {\r
+ co = parse_source_module(pathname, fp);\r
+ if (co == NULL)\r
+ return NULL;\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("import %s # from %s\n",\r
+ name, pathname);\r
+ if (cpathname) {\r
+ PyObject *ro = PySys_GetObject("dont_write_bytecode");\r
+ if (ro == NULL || !PyObject_IsTrue(ro))\r
+ write_compiled_module(co, cpathname, &st);\r
+ }\r
+ }\r
+ m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, pathname);\r
+ Py_DECREF(co);\r
+\r
+ return m;\r
+}\r
+\r
+\r
+/* Forward */\r
+static PyObject *load_module(char *, FILE *, char *, int, PyObject *);\r
+static struct filedescr *find_module(char *, char *, PyObject *,\r
+ char *, size_t, FILE **, PyObject **);\r
+static struct _frozen *find_frozen(char *name);\r
+\r
+/* Load a package and return its module object WITH INCREMENTED\r
+ REFERENCE COUNT */\r
+\r
+static PyObject *\r
+load_package(char *name, char *pathname)\r
+{\r
+ PyObject *m, *d;\r
+ PyObject *file = NULL;\r
+ PyObject *path = NULL;\r
+ int err;\r
+ char buf[MAXPATHLEN+1];\r
+ FILE *fp = NULL;\r
+ struct filedescr *fdp;\r
+\r
+ m = PyImport_AddModule(name);\r
+ if (m == NULL)\r
+ return NULL;\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("import %s # directory %s\n",\r
+ name, pathname);\r
+ d = PyModule_GetDict(m);\r
+ file = PyString_FromString(pathname);\r
+ if (file == NULL)\r
+ goto error;\r
+ path = Py_BuildValue("[O]", file);\r
+ if (path == NULL)\r
+ goto error;\r
+ err = PyDict_SetItemString(d, "__file__", file);\r
+ if (err == 0)\r
+ err = PyDict_SetItemString(d, "__path__", path);\r
+ if (err != 0)\r
+ goto error;\r
+ buf[0] = '\0';\r
+ fdp = find_module(name, "__init__", path, buf, sizeof(buf), &fp, NULL);\r
+ if (fdp == NULL) {\r
+ if (PyErr_ExceptionMatches(PyExc_ImportError)) {\r
+ PyErr_Clear();\r
+ Py_INCREF(m);\r
+ }\r
+ else\r
+ m = NULL;\r
+ goto cleanup;\r
+ }\r
+ m = load_module(name, fp, buf, fdp->type, NULL);\r
+ if (fp != NULL)\r
+ fclose(fp);\r
+ goto cleanup;\r
+\r
+ error:\r
+ m = NULL;\r
+ cleanup:\r
+ Py_XDECREF(path);\r
+ Py_XDECREF(file);\r
+ return m;\r
+}\r
+\r
+\r
+/* Helper to test for built-in module */\r
+\r
+static int\r
+is_builtin(char *name)\r
+{\r
+ int i;\r
+ for (i = 0; PyImport_Inittab[i].name != NULL; i++) {\r
+ if (strcmp(name, PyImport_Inittab[i].name) == 0) {\r
+ if (PyImport_Inittab[i].initfunc == NULL)\r
+ return -1;\r
+ else\r
+ return 1;\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+\r
+\r
+/* Return an importer object for a sys.path/pkg.__path__ item 'p',\r
+ possibly by fetching it from the path_importer_cache dict. If it\r
+ wasn't yet cached, traverse path_hooks until a hook is found\r
+ that can handle the path item. Return None if no hook could;\r
+ this tells our caller it should fall back to the builtin\r
+ import mechanism. Cache the result in path_importer_cache.\r
+ Returns a borrowed reference. */\r
+\r
+static PyObject *\r
+get_path_importer(PyObject *path_importer_cache, PyObject *path_hooks,\r
+ PyObject *p)\r
+{\r
+ PyObject *importer;\r
+ Py_ssize_t j, nhooks;\r
+\r
+ /* These conditions are the caller's responsibility: */\r
+ assert(PyList_Check(path_hooks));\r
+ assert(PyDict_Check(path_importer_cache));\r
+\r
+ nhooks = PyList_Size(path_hooks);\r
+ if (nhooks < 0)\r
+ return NULL; /* Shouldn't happen */\r
+\r
+ importer = PyDict_GetItem(path_importer_cache, p);\r
+ if (importer != NULL)\r
+ return importer;\r
+\r
+ /* set path_importer_cache[p] to None to avoid recursion */\r
+ if (PyDict_SetItem(path_importer_cache, p, Py_None) != 0)\r
+ return NULL;\r
+\r
+ for (j = 0; j < nhooks; j++) {\r
+ PyObject *hook = PyList_GetItem(path_hooks, j);\r
+ if (hook == NULL)\r
+ return NULL;\r
+ importer = PyObject_CallFunctionObjArgs(hook, p, NULL);\r
+ if (importer != NULL)\r
+ break;\r
+\r
+ if (!PyErr_ExceptionMatches(PyExc_ImportError)) {\r
+ return NULL;\r
+ }\r
+ PyErr_Clear();\r
+ }\r
+ if (importer == NULL) {\r
+ importer = PyObject_CallFunctionObjArgs(\r
+ (PyObject *)&PyNullImporter_Type, p, NULL\r
+ );\r
+ if (importer == NULL) {\r
+ if (PyErr_ExceptionMatches(PyExc_ImportError)) {\r
+ PyErr_Clear();\r
+ return Py_None;\r
+ }\r
+ }\r
+ }\r
+ if (importer != NULL) {\r
+ int err = PyDict_SetItem(path_importer_cache, p, importer);\r
+ Py_DECREF(importer);\r
+ if (err != 0)\r
+ return NULL;\r
+ }\r
+ return importer;\r
+}\r
+\r
+PyAPI_FUNC(PyObject *)\r
+PyImport_GetImporter(PyObject *path) {\r
+ PyObject *importer=NULL, *path_importer_cache=NULL, *path_hooks=NULL;\r
+\r
+ if ((path_importer_cache = PySys_GetObject("path_importer_cache"))) {\r
+ if ((path_hooks = PySys_GetObject("path_hooks"))) {\r
+ importer = get_path_importer(path_importer_cache,\r
+ path_hooks, path);\r
+ }\r
+ }\r
+ Py_XINCREF(importer); /* get_path_importer returns a borrowed reference */\r
+ return importer;\r
+}\r
+\r
+/* Search the path (default sys.path) for a module. Return the\r
+ corresponding filedescr struct, and (via return arguments) the\r
+ pathname and an open file. Return NULL if the module is not found. */\r
+\r
+#ifdef MS_COREDLL\r
+extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr **,\r
+ char *, Py_ssize_t);\r
+#endif\r
+\r
+static int case_ok(char *, Py_ssize_t, Py_ssize_t, char *);\r
+static int find_init_module(char *); /* Forward */\r
+static struct filedescr importhookdescr = {"", "", IMP_HOOK};\r
+\r
+static struct filedescr *\r
+find_module(char *fullname, char *subname, PyObject *path, char *buf,\r
+ size_t buflen, FILE **p_fp, PyObject **p_loader)\r
+{\r
+ Py_ssize_t i, npath;\r
+ size_t len, namelen;\r
+ struct filedescr *fdp = NULL;\r
+ char *filemode;\r
+ FILE *fp = NULL;\r
+ PyObject *path_hooks, *path_importer_cache;\r
+#ifndef RISCOS\r
+ struct stat statbuf;\r
+#endif\r
+ static struct filedescr fd_frozen = {"", "", PY_FROZEN};\r
+ static struct filedescr fd_builtin = {"", "", C_BUILTIN};\r
+ static struct filedescr fd_package = {"", "", PKG_DIRECTORY};\r
+ char name[MAXPATHLEN+1];\r
+#if defined(PYOS_OS2)\r
+ size_t saved_len;\r
+ size_t saved_namelen;\r
+ char *saved_buf = NULL;\r
+#endif\r
+ if (p_loader != NULL)\r
+ *p_loader = NULL;\r
+\r
+ if (strlen(subname) > MAXPATHLEN) {\r
+ PyErr_SetString(PyExc_OverflowError,\r
+ "module name is too long");\r
+ return NULL;\r
+ }\r
+ strcpy(name, subname);\r
+\r
+ /* sys.meta_path import hook */\r
+ if (p_loader != NULL) {\r
+ PyObject *meta_path;\r
+\r
+ meta_path = PySys_GetObject("meta_path");\r
+ if (meta_path == NULL || !PyList_Check(meta_path)) {\r
+ PyErr_SetString(PyExc_ImportError,\r
+ "sys.meta_path must be a list of "\r
+ "import hooks");\r
+ return NULL;\r
+ }\r
+ Py_INCREF(meta_path); /* zap guard */\r
+ npath = PyList_Size(meta_path);\r
+ for (i = 0; i < npath; i++) {\r
+ PyObject *loader;\r
+ PyObject *hook = PyList_GetItem(meta_path, i);\r
+ loader = PyObject_CallMethod(hook, "find_module",\r
+ "sO", fullname,\r
+ path != NULL ?\r
+ path : Py_None);\r
+ if (loader == NULL) {\r
+ Py_DECREF(meta_path);\r
+ return NULL; /* true error */\r
+ }\r
+ if (loader != Py_None) {\r
+ /* a loader was found */\r
+ *p_loader = loader;\r
+ Py_DECREF(meta_path);\r
+ return &importhookdescr;\r
+ }\r
+ Py_DECREF(loader);\r
+ }\r
+ Py_DECREF(meta_path);\r
+ }\r
+\r
+ if (path != NULL && PyString_Check(path)) {\r
+ /* The only type of submodule allowed inside a "frozen"\r
+ package are other frozen modules or packages. */\r
+ if (PyString_Size(path) + 1 + strlen(name) >= (size_t)buflen) {\r
+ PyErr_SetString(PyExc_ImportError,\r
+ "full frozen module name too long");\r
+ return NULL;\r
+ }\r
+ strcpy(buf, PyString_AsString(path));\r
+ strcat(buf, ".");\r
+ strcat(buf, name);\r
+ strcpy(name, buf);\r
+ if (find_frozen(name) != NULL) {\r
+ strcpy(buf, name);\r
+ return &fd_frozen;\r
+ }\r
+ PyErr_Format(PyExc_ImportError,\r
+ "No frozen submodule named %.200s", name);\r
+ return NULL;\r
+ }\r
+ if (path == NULL) {\r
+ if (is_builtin(name)) {\r
+ strcpy(buf, name);\r
+ return &fd_builtin;\r
+ }\r
+ if ((find_frozen(name)) != NULL) {\r
+ strcpy(buf, name);\r
+ return &fd_frozen;\r
+ }\r
+\r
+#ifdef MS_COREDLL\r
+ fp = PyWin_FindRegisteredModule(name, &fdp, buf, buflen);\r
+ if (fp != NULL) {\r
+ *p_fp = fp;\r
+ return fdp;\r
+ }\r
+#endif\r
+ path = PySys_GetObject("path");\r
+ }\r
+ if (path == NULL || !PyList_Check(path)) {\r
+ PyErr_SetString(PyExc_ImportError,\r
+ "sys.path must be a list of directory names");\r
+ return NULL;\r
+ }\r
+\r
+ path_hooks = PySys_GetObject("path_hooks");\r
+ if (path_hooks == NULL || !PyList_Check(path_hooks)) {\r
+ PyErr_SetString(PyExc_ImportError,\r
+ "sys.path_hooks must be a list of "\r
+ "import hooks");\r
+ return NULL;\r
+ }\r
+ path_importer_cache = PySys_GetObject("path_importer_cache");\r
+ if (path_importer_cache == NULL ||\r
+ !PyDict_Check(path_importer_cache)) {\r
+ PyErr_SetString(PyExc_ImportError,\r
+ "sys.path_importer_cache must be a dict");\r
+ return NULL;\r
+ }\r
+\r
+ npath = PyList_Size(path);\r
+ namelen = strlen(name);\r
+ for (i = 0; i < npath; i++) {\r
+ PyObject *copy = NULL;\r
+ PyObject *v = PyList_GetItem(path, i);\r
+ if (!v)\r
+ return NULL;\r
+#ifdef Py_USING_UNICODE\r
+ if (PyUnicode_Check(v)) {\r
+ copy = PyUnicode_Encode(PyUnicode_AS_UNICODE(v),\r
+ PyUnicode_GET_SIZE(v), Py_FileSystemDefaultEncoding, NULL);\r
+ if (copy == NULL)\r
+ return NULL;\r
+ v = copy;\r
+ }\r
+ else\r
+#endif\r
+ if (!PyString_Check(v))\r
+ continue;\r
+ len = PyString_GET_SIZE(v);\r
+ if (len + 2 + namelen + MAXSUFFIXSIZE >= buflen) {\r
+ Py_XDECREF(copy);\r
+ continue; /* Too long */\r
+ }\r
+ strcpy(buf, PyString_AS_STRING(v));\r
+ if (strlen(buf) != len) {\r
+ Py_XDECREF(copy);\r
+ continue; /* v contains '\0' */\r
+ }\r
+\r
+ /* sys.path_hooks import hook */\r
+ if (p_loader != NULL) {\r
+ PyObject *importer;\r
+\r
+ importer = get_path_importer(path_importer_cache,\r
+ path_hooks, v);\r
+ if (importer == NULL) {\r
+ Py_XDECREF(copy);\r
+ return NULL;\r
+ }\r
+ /* Note: importer is a borrowed reference */\r
+ if (importer != Py_None) {\r
+ PyObject *loader;\r
+ loader = PyObject_CallMethod(importer,\r
+ "find_module",\r
+ "s", fullname);\r
+ Py_XDECREF(copy);\r
+ if (loader == NULL)\r
+ return NULL; /* error */\r
+ if (loader != Py_None) {\r
+ /* a loader was found */\r
+ *p_loader = loader;\r
+ return &importhookdescr;\r
+ }\r
+ Py_DECREF(loader);\r
+ continue;\r
+ }\r
+ }\r
+ /* no hook was found, use builtin import */\r
+\r
+ if (len > 0 && buf[len-1] != SEP\r
+#ifdef ALTSEP\r
+ && buf[len-1] != ALTSEP\r
+#endif\r
+ )\r
+ buf[len++] = SEP;\r
+ strcpy(buf+len, name);\r
+ len += namelen;\r
+\r
+ /* Check for package import (buf holds a directory name,\r
+ and there's an __init__ module in that directory */\r
+#ifdef HAVE_STAT\r
+ if (stat(buf, &statbuf) == 0 && /* it exists */\r
+ S_ISDIR(statbuf.st_mode) && /* it's a directory */\r
+ case_ok(buf, len, namelen, name)) { /* case matches */\r
+ if (find_init_module(buf)) { /* and has __init__.py */\r
+ Py_XDECREF(copy);\r
+ return &fd_package;\r
+ }\r
+ else {\r
+ char warnstr[MAXPATHLEN+80];\r
+ sprintf(warnstr, "Not importing directory "\r
+ "'%.*s': missing __init__.py",\r
+ MAXPATHLEN, buf);\r
+ if (PyErr_Warn(PyExc_ImportWarning,\r
+ warnstr)) {\r
+ Py_XDECREF(copy);\r
+ return NULL;\r
+ }\r
+ }\r
+ }\r
+#else\r
+ /* XXX How are you going to test for directories? */\r
+#ifdef RISCOS\r
+ if (isdir(buf) &&\r
+ case_ok(buf, len, namelen, name)) {\r
+ if (find_init_module(buf)) {\r
+ Py_XDECREF(copy);\r
+ return &fd_package;\r
+ }\r
+ else {\r
+ char warnstr[MAXPATHLEN+80];\r
+ sprintf(warnstr, "Not importing directory "\r
+ "'%.*s': missing __init__.py",\r
+ MAXPATHLEN, buf);\r
+ if (PyErr_Warn(PyExc_ImportWarning,\r
+ warnstr)) {\r
+ Py_XDECREF(copy);\r
+ return NULL;\r
+ }\r
+ }\r
+#endif\r
+#endif\r
+#if defined(PYOS_OS2)\r
+ /* take a snapshot of the module spec for restoration\r
+ * after the 8 character DLL hackery\r
+ */\r
+ saved_buf = strdup(buf);\r
+ saved_len = len;\r
+ saved_namelen = namelen;\r
+#endif /* PYOS_OS2 */\r
+ for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {\r
+#if defined(PYOS_OS2) && defined(HAVE_DYNAMIC_LOADING)\r
+ /* OS/2 limits DLLs to 8 character names (w/o\r
+ extension)\r
+ * so if the name is longer than that and its a\r
+ * dynamically loaded module we're going to try,\r
+ * truncate the name before trying\r
+ */\r
+ if (strlen(subname) > 8) {\r
+ /* is this an attempt to load a C extension? */\r
+ const struct filedescr *scan;\r
+ scan = _PyImport_DynLoadFiletab;\r
+ while (scan->suffix != NULL) {\r
+ if (!strcmp(scan->suffix, fdp->suffix))\r
+ break;\r
+ else\r
+ scan++;\r
+ }\r
+ if (scan->suffix != NULL) {\r
+ /* yes, so truncate the name */\r
+ namelen = 8;\r
+ len -= strlen(subname) - namelen;\r
+ buf[len] = '\0';\r
+ }\r
+ }\r
+#endif /* PYOS_OS2 */\r
+ strcpy(buf+len, fdp->suffix);\r
+ if (Py_VerboseFlag > 1)\r
+ PySys_WriteStderr("# trying %s\n", buf);\r
+ filemode = fdp->mode;\r
+ if (filemode[0] == 'U')\r
+ filemode = "r" PY_STDIOTEXTMODE;\r
+ fp = fopen(buf, filemode);\r
+ if (fp != NULL) {\r
+ if (case_ok(buf, len, namelen, name))\r
+ break;\r
+ else { /* continue search */\r
+ fclose(fp);\r
+ fp = NULL;\r
+ }\r
+ }\r
+#if defined(PYOS_OS2)\r
+ /* restore the saved snapshot */\r
+ strcpy(buf, saved_buf);\r
+ len = saved_len;\r
+ namelen = saved_namelen;\r
+#endif\r
+ }\r
+#if defined(PYOS_OS2)\r
+ /* don't need/want the module name snapshot anymore */\r
+ if (saved_buf)\r
+ {\r
+ free(saved_buf);\r
+ saved_buf = NULL;\r
+ }\r
+#endif\r
+ Py_XDECREF(copy);\r
+ if (fp != NULL)\r
+ break;\r
+ }\r
+ if (fp == NULL) {\r
+ PyErr_Format(PyExc_ImportError,\r
+ "No module named %.200s", name);\r
+ return NULL;\r
+ }\r
+ *p_fp = fp;\r
+ return fdp;\r
+}\r
+\r
+/* Helpers for main.c\r
+ * Find the source file corresponding to a named module\r
+ */\r
+struct filedescr *\r
+_PyImport_FindModule(const char *name, PyObject *path, char *buf,\r
+ size_t buflen, FILE **p_fp, PyObject **p_loader)\r
+{\r
+ return find_module((char *) name, (char *) name, path,\r
+ buf, buflen, p_fp, p_loader);\r
+}\r
+\r
+PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr * fd)\r
+{\r
+ return fd->type == PY_SOURCE || fd->type == PY_COMPILED;\r
+}\r
+\r
+/* case_ok(char* buf, Py_ssize_t len, Py_ssize_t namelen, char* name)\r
+ * The arguments here are tricky, best shown by example:\r
+ * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0\r
+ * ^ ^ ^ ^\r
+ * |--------------------- buf ---------------------|\r
+ * |------------------- len ------------------|\r
+ * |------ name -------|\r
+ * |----- namelen -----|\r
+ * buf is the full path, but len only counts up to (& exclusive of) the\r
+ * extension. name is the module name, also exclusive of extension.\r
+ *\r
+ * We've already done a successful stat() or fopen() on buf, so know that\r
+ * there's some match, possibly case-insensitive.\r
+ *\r
+ * case_ok() is to return 1 if there's a case-sensitive match for\r
+ * name, else 0. case_ok() is also to return 1 if envar PYTHONCASEOK\r
+ * exists.\r
+ *\r
+ * case_ok() is used to implement case-sensitive import semantics even\r
+ * on platforms with case-insensitive filesystems. It's trivial to implement\r
+ * for case-sensitive filesystems. It's pretty much a cross-platform\r
+ * nightmare for systems with case-insensitive filesystems.\r
+ */\r
+\r
+/* First we may need a pile of platform-specific header files; the sequence\r
+ * of #if's here should match the sequence in the body of case_ok().\r
+ */\r
+#if defined(MS_WINDOWS)\r
+#include <windows.h>\r
+\r
+#elif defined(DJGPP)\r
+#include <dir.h>\r
+\r
+#elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)\r
+#include <sys/types.h>\r
+#include <dirent.h>\r
+\r
+#elif defined(PYOS_OS2)\r
+#define INCL_DOS\r
+#define INCL_DOSERRORS\r
+#define INCL_NOPMAPI\r
+#include <os2.h>\r
+\r
+#elif defined(RISCOS)\r
+#include "oslib/osfscontrol.h"\r
+#endif\r
+\r
+static int\r
+case_ok(char *buf, Py_ssize_t len, Py_ssize_t namelen, char *name)\r
+{\r
+/* Pick a platform-specific implementation; the sequence of #if's here should\r
+ * match the sequence just above.\r
+ */\r
+\r
+/* MS_WINDOWS */\r
+#if defined(MS_WINDOWS)\r
+ WIN32_FIND_DATA data;\r
+ HANDLE h;\r
+\r
+ if (Py_GETENV("PYTHONCASEOK") != NULL)\r
+ return 1;\r
+\r
+ h = FindFirstFile(buf, &data);\r
+ if (h == INVALID_HANDLE_VALUE) {\r
+ PyErr_Format(PyExc_NameError,\r
+ "Can't find file for module %.100s\n(filename %.300s)",\r
+ name, buf);\r
+ return 0;\r
+ }\r
+ FindClose(h);\r
+ return strncmp(data.cFileName, name, namelen) == 0;\r
+\r
+/* DJGPP */\r
+#elif defined(DJGPP)\r
+ struct ffblk ffblk;\r
+ int done;\r
+\r
+ if (Py_GETENV("PYTHONCASEOK") != NULL)\r
+ return 1;\r
+\r
+ done = findfirst(buf, &ffblk, FA_ARCH|FA_RDONLY|FA_HIDDEN|FA_DIREC);\r
+ if (done) {\r
+ PyErr_Format(PyExc_NameError,\r
+ "Can't find file for module %.100s\n(filename %.300s)",\r
+ name, buf);\r
+ return 0;\r
+ }\r
+ return strncmp(ffblk.ff_name, name, namelen) == 0;\r
+\r
+/* new-fangled macintosh (macosx) or Cygwin */\r
+#elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)\r
+ DIR *dirp;\r
+ struct dirent *dp;\r
+ char dirname[MAXPATHLEN + 1];\r
+ const int dirlen = len - namelen - 1; /* don't want trailing SEP */\r
+\r
+ if (Py_GETENV("PYTHONCASEOK") != NULL)\r
+ return 1;\r
+\r
+ /* Copy the dir component into dirname; substitute "." if empty */\r
+ if (dirlen <= 0) {\r
+ dirname[0] = '.';\r
+ dirname[1] = '\0';\r
+ }\r
+ else {\r
+ assert(dirlen <= MAXPATHLEN);\r
+ memcpy(dirname, buf, dirlen);\r
+ dirname[dirlen] = '\0';\r
+ }\r
+ /* Open the directory and search the entries for an exact match. */\r
+ dirp = opendir(dirname);\r
+ if (dirp) {\r
+ char *nameWithExt = buf + len - namelen;\r
+ while ((dp = readdir(dirp)) != NULL) {\r
+ const int thislen =\r
+#ifdef _DIRENT_HAVE_D_NAMELEN\r
+ dp->d_namlen;\r
+#else\r
+ strlen(dp->d_name);\r
+#endif\r
+ if (thislen >= namelen &&\r
+ strcmp(dp->d_name, nameWithExt) == 0) {\r
+ (void)closedir(dirp);\r
+ return 1; /* Found */\r
+ }\r
+ }\r
+ (void)closedir(dirp);\r
+ }\r
+ return 0 ; /* Not found */\r
+\r
+/* RISC OS */\r
+#elif defined(RISCOS)\r
+ char canon[MAXPATHLEN+1]; /* buffer for the canonical form of the path */\r
+ char buf2[MAXPATHLEN+2];\r
+ char *nameWithExt = buf+len-namelen;\r
+ int canonlen;\r
+ os_error *e;\r
+\r
+ if (Py_GETENV("PYTHONCASEOK") != NULL)\r
+ return 1;\r
+\r
+ /* workaround:\r
+ append wildcard, otherwise case of filename wouldn't be touched */\r
+ strcpy(buf2, buf);\r
+ strcat(buf2, "*");\r
+\r
+ e = xosfscontrol_canonicalise_path(buf2,canon,0,0,MAXPATHLEN+1,&canonlen);\r
+ canonlen = MAXPATHLEN+1-canonlen;\r
+ if (e || canonlen<=0 || canonlen>(MAXPATHLEN+1) )\r
+ return 0;\r
+ if (strcmp(nameWithExt, canon+canonlen-strlen(nameWithExt))==0)\r
+ return 1; /* match */\r
+\r
+ return 0;\r
+\r
+/* OS/2 */\r
+#elif defined(PYOS_OS2)\r
+ HDIR hdir = 1;\r
+ ULONG srchcnt = 1;\r
+ FILEFINDBUF3 ffbuf;\r
+ APIRET rc;\r
+\r
+ if (Py_GETENV("PYTHONCASEOK") != NULL)\r
+ return 1;\r
+\r
+ rc = DosFindFirst(buf,\r
+ &hdir,\r
+ FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY,\r
+ &ffbuf, sizeof(ffbuf),\r
+ &srchcnt,\r
+ FIL_STANDARD);\r
+ if (rc != NO_ERROR)\r
+ return 0;\r
+ return strncmp(ffbuf.achName, name, namelen) == 0;\r
+\r
+/* assuming it's a case-sensitive filesystem, so there's nothing to do! */\r
+#else\r
+ return 1;\r
+\r
+#endif\r
+}\r
+\r
+\r
+#ifdef HAVE_STAT\r
+/* Helper to look for __init__.py or __init__.py[co] in potential package */\r
+static int\r
+find_init_module(char *buf)\r
+{\r
+ const size_t save_len = strlen(buf);\r
+ size_t i = save_len;\r
+ char *pname; /* pointer to start of __init__ */\r
+ struct stat statbuf;\r
+\r
+/* For calling case_ok(buf, len, namelen, name):\r
+ * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0\r
+ * ^ ^ ^ ^\r
+ * |--------------------- buf ---------------------|\r
+ * |------------------- len ------------------|\r
+ * |------ name -------|\r
+ * |----- namelen -----|\r
+ */\r
+ if (save_len + 13 >= MAXPATHLEN)\r
+ return 0;\r
+ buf[i++] = SEP;\r
+ pname = buf + i;\r
+ strcpy(pname, "__init__.py");\r
+ if (stat(buf, &statbuf) == 0) {\r
+ if (case_ok(buf,\r
+ save_len + 9, /* len("/__init__") */\r
+ 8, /* len("__init__") */\r
+ pname)) {\r
+ buf[save_len] = '\0';\r
+ return 1;\r
+ }\r
+ }\r
+ i += strlen(pname);\r
+ strcpy(buf+i, Py_OptimizeFlag ? "o" : "c");\r
+ if (stat(buf, &statbuf) == 0) {\r
+ if (case_ok(buf,\r
+ save_len + 9, /* len("/__init__") */\r
+ 8, /* len("__init__") */\r
+ pname)) {\r
+ buf[save_len] = '\0';\r
+ return 1;\r
+ }\r
+ }\r
+ buf[save_len] = '\0';\r
+ return 0;\r
+}\r
+\r
+#else\r
+\r
+#ifdef RISCOS\r
+static int\r
+find_init_module(buf)\r
+ char *buf;\r
+{\r
+ int save_len = strlen(buf);\r
+ int i = save_len;\r
+\r
+ if (save_len + 13 >= MAXPATHLEN)\r
+ return 0;\r
+ buf[i++] = SEP;\r
+ strcpy(buf+i, "__init__/py");\r
+ if (isfile(buf)) {\r
+ buf[save_len] = '\0';\r
+ return 1;\r
+ }\r
+\r
+ if (Py_OptimizeFlag)\r
+ strcpy(buf+i, "o");\r
+ else\r
+ strcpy(buf+i, "c");\r
+ if (isfile(buf)) {\r
+ buf[save_len] = '\0';\r
+ return 1;\r
+ }\r
+ buf[save_len] = '\0';\r
+ return 0;\r
+}\r
+#endif /*RISCOS*/\r
+\r
+#endif /* HAVE_STAT */\r
+\r
+\r
+static int init_builtin(char *); /* Forward */\r
+\r
+/* Load an external module using the default search path and return\r
+ its module object WITH INCREMENTED REFERENCE COUNT */\r
+\r
+static PyObject *\r
+load_module(char *name, FILE *fp, char *pathname, int type, PyObject *loader)\r
+{\r
+ PyObject *modules;\r
+ PyObject *m;\r
+ int err;\r
+\r
+ /* First check that there's an open file (if we need one) */\r
+ switch (type) {\r
+ case PY_SOURCE:\r
+ case PY_COMPILED:\r
+ if (fp == NULL) {\r
+ PyErr_Format(PyExc_ValueError,\r
+ "file object required for import (type code %d)",\r
+ type);\r
+ return NULL;\r
+ }\r
+ }\r
+\r
+ switch (type) {\r
+\r
+ case PY_SOURCE:\r
+ m = load_source_module(name, pathname, fp);\r
+ break;\r
+\r
+ case PY_COMPILED:\r
+ m = load_compiled_module(name, pathname, fp);\r
+ break;\r
+\r
+#ifdef HAVE_DYNAMIC_LOADING\r
+ case C_EXTENSION:\r
+ m = _PyImport_LoadDynamicModule(name, pathname, fp);\r
+ break;\r
+#endif\r
+\r
+ case PKG_DIRECTORY:\r
+ m = load_package(name, pathname);\r
+ break;\r
+\r
+ case C_BUILTIN:\r
+ case PY_FROZEN:\r
+ if (pathname != NULL && pathname[0] != '\0')\r
+ name = pathname;\r
+ if (type == C_BUILTIN)\r
+ err = init_builtin(name);\r
+ else\r
+ err = PyImport_ImportFrozenModule(name);\r
+ if (err < 0)\r
+ return NULL;\r
+ if (err == 0) {\r
+ PyErr_Format(PyExc_ImportError,\r
+ "Purported %s module %.200s not found",\r
+ type == C_BUILTIN ?\r
+ "builtin" : "frozen",\r
+ name);\r
+ return NULL;\r
+ }\r
+ modules = PyImport_GetModuleDict();\r
+ m = PyDict_GetItemString(modules, name);\r
+ if (m == NULL) {\r
+ PyErr_Format(\r
+ PyExc_ImportError,\r
+ "%s module %.200s not properly initialized",\r
+ type == C_BUILTIN ?\r
+ "builtin" : "frozen",\r
+ name);\r
+ return NULL;\r
+ }\r
+ Py_INCREF(m);\r
+ break;\r
+\r
+ case IMP_HOOK: {\r
+ if (loader == NULL) {\r
+ PyErr_SetString(PyExc_ImportError,\r
+ "import hook without loader");\r
+ return NULL;\r
+ }\r
+ m = PyObject_CallMethod(loader, "load_module", "s", name);\r
+ break;\r
+ }\r
+\r
+ default:\r
+ PyErr_Format(PyExc_ImportError,\r
+ "Don't know how to import %.200s (type code %d)",\r
+ name, type);\r
+ m = NULL;\r
+\r
+ }\r
+\r
+ return m;\r
+}\r
+\r
+\r
+/* Initialize a built-in module.\r
+ Return 1 for success, 0 if the module is not found, and -1 with\r
+ an exception set if the initialization failed. */\r
+\r
+static int\r
+init_builtin(char *name)\r
+{\r
+ struct _inittab *p;\r
+\r
+ if (_PyImport_FindExtension(name, name) != NULL)\r
+ return 1;\r
+\r
+ for (p = PyImport_Inittab; p->name != NULL; p++) {\r
+ if (strcmp(name, p->name) == 0) {\r
+ if (p->initfunc == NULL) {\r
+ PyErr_Format(PyExc_ImportError,\r
+ "Cannot re-init internal module %.200s",\r
+ name);\r
+ return -1;\r
+ }\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("import %s # builtin\n", name);\r
+ (*p->initfunc)();\r
+ if (PyErr_Occurred())\r
+ return -1;\r
+ if (_PyImport_FixupExtension(name, name) == NULL)\r
+ return -1;\r
+ return 1;\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+\r
+\r
+/* Frozen modules */\r
+\r
+static struct _frozen *\r
+find_frozen(char *name)\r
+{\r
+ struct _frozen *p;\r
+\r
+ for (p = PyImport_FrozenModules; ; p++) {\r
+ if (p->name == NULL)\r
+ return NULL;\r
+ if (strcmp(p->name, name) == 0)\r
+ break;\r
+ }\r
+ return p;\r
+}\r
+\r
+static PyObject *\r
+get_frozen_object(char *name)\r
+{\r
+ struct _frozen *p = find_frozen(name);\r
+ int size;\r
+\r
+ if (p == NULL) {\r
+ PyErr_Format(PyExc_ImportError,\r
+ "No such frozen object named %.200s",\r
+ name);\r
+ return NULL;\r
+ }\r
+ if (p->code == NULL) {\r
+ PyErr_Format(PyExc_ImportError,\r
+ "Excluded frozen object named %.200s",\r
+ name);\r
+ return NULL;\r
+ }\r
+ size = p->size;\r
+ if (size < 0)\r
+ size = -size;\r
+ return PyMarshal_ReadObjectFromString((char *)p->code, size);\r
+}\r
+\r
+/* Initialize a frozen module.\r
+ Return 1 for succes, 0 if the module is not found, and -1 with\r
+ an exception set if the initialization failed.\r
+ This function is also used from frozenmain.c */\r
+\r
+int\r
+PyImport_ImportFrozenModule(char *name)\r
+{\r
+ struct _frozen *p = find_frozen(name);\r
+ PyObject *co;\r
+ PyObject *m;\r
+ int ispackage;\r
+ int size;\r
+\r
+ if (p == NULL)\r
+ return 0;\r
+ if (p->code == NULL) {\r
+ PyErr_Format(PyExc_ImportError,\r
+ "Excluded frozen object named %.200s",\r
+ name);\r
+ return -1;\r
+ }\r
+ size = p->size;\r
+ ispackage = (size < 0);\r
+ if (ispackage)\r
+ size = -size;\r
+ if (Py_VerboseFlag)\r
+ PySys_WriteStderr("import %s # frozen%s\n",\r
+ name, ispackage ? " package" : "");\r
+ co = PyMarshal_ReadObjectFromString((char *)p->code, size);\r
+ if (co == NULL)\r
+ return -1;\r
+ if (!PyCode_Check(co)) {\r
+ PyErr_Format(PyExc_TypeError,\r
+ "frozen object %.200s is not a code object",\r
+ name);\r
+ goto err_return;\r
+ }\r
+ if (ispackage) {\r
+ /* Set __path__ to the package name */\r
+ PyObject *d, *s;\r
+ int err;\r
+ m = PyImport_AddModule(name);\r
+ if (m == NULL)\r
+ goto err_return;\r
+ d = PyModule_GetDict(m);\r
+ s = PyString_InternFromString(name);\r
+ if (s == NULL)\r
+ goto err_return;\r
+ err = PyDict_SetItemString(d, "__path__", s);\r
+ Py_DECREF(s);\r
+ if (err != 0)\r
+ goto err_return;\r
+ }\r
+ m = PyImport_ExecCodeModuleEx(name, co, "<frozen>");\r
+ if (m == NULL)\r
+ goto err_return;\r
+ Py_DECREF(co);\r
+ Py_DECREF(m);\r
+ return 1;\r
+err_return:\r
+ Py_DECREF(co);\r
+ return -1;\r
+}\r
+\r
+\r
+/* Import a module, either built-in, frozen, or external, and return\r
+ its module object WITH INCREMENTED REFERENCE COUNT */\r
+\r
+PyObject *\r
+PyImport_ImportModule(const char *name)\r
+{\r
+ PyObject *pname;\r
+ PyObject *result;\r
+\r
+ pname = PyString_FromString(name);\r
+ if (pname == NULL)\r
+ return NULL;\r
+ result = PyImport_Import(pname);\r
+ Py_DECREF(pname);\r
+ return result;\r
+}\r
+\r
+/* Import a module without blocking\r
+ *\r
+ * At first it tries to fetch the module from sys.modules. If the module was\r
+ * never loaded before it loads it with PyImport_ImportModule() unless another\r
+ * thread holds the import lock. In the latter case the function raises an\r
+ * ImportError instead of blocking.\r
+ *\r
+ * Returns the module object with incremented ref count.\r
+ */\r
+PyObject *\r
+PyImport_ImportModuleNoBlock(const char *name)\r
+{\r
+ PyObject *result;\r
+ PyObject *modules;\r
+#ifdef WITH_THREAD\r
+ long me;\r
+#endif\r
+\r
+ /* Try to get the module from sys.modules[name] */\r
+ modules = PyImport_GetModuleDict();\r
+ if (modules == NULL)\r
+ return NULL;\r
+\r
+ result = PyDict_GetItemString(modules, name);\r
+ if (result != NULL) {\r
+ Py_INCREF(result);\r
+ return result;\r
+ }\r
+ else {\r
+ PyErr_Clear();\r
+ }\r
+#ifdef WITH_THREAD\r
+ /* check the import lock\r
+ * me might be -1 but I ignore the error here, the lock function\r
+ * takes care of the problem */\r
+ me = PyThread_get_thread_ident();\r
+ if (import_lock_thread == -1 || import_lock_thread == me) {\r
+ /* no thread or me is holding the lock */\r
+ return PyImport_ImportModule(name);\r
+ }\r
+ else {\r
+ PyErr_Format(PyExc_ImportError,\r
+ "Failed to import %.200s because the import lock"\r
+ "is held by another thread.",\r
+ name);\r
+ return NULL;\r
+ }\r
+#else\r
+ return PyImport_ImportModule(name);\r
+#endif\r
+}\r
+\r
+/* Forward declarations for helper routines */\r
+static PyObject *get_parent(PyObject *globals, char *buf,\r
+ Py_ssize_t *p_buflen, int level);\r
+static PyObject *load_next(PyObject *mod, PyObject *altmod,\r
+ char **p_name, char *buf, Py_ssize_t *p_buflen);\r
+static int mark_miss(char *name);\r
+static int ensure_fromlist(PyObject *mod, PyObject *fromlist,\r
+ char *buf, Py_ssize_t buflen, int recursive);\r
+static PyObject * import_submodule(PyObject *mod, char *name, char *fullname);\r
+\r
+/* The Magnum Opus of dotted-name import :-) */\r
+\r
+static PyObject *\r
+import_module_level(char *name, PyObject *globals, PyObject *locals,\r
+ PyObject *fromlist, int level)\r
+{\r
+ char buf[MAXPATHLEN+1];\r
+ Py_ssize_t buflen = 0;\r
+ PyObject *parent, *head, *next, *tail;\r
+\r
+ if (strchr(name, '/') != NULL\r
+#ifdef MS_WINDOWS\r
+ || strchr(name, '\\') != NULL\r
+#endif\r
+ ) {\r
+ PyErr_SetString(PyExc_ImportError,\r
+ "Import by filename is not supported.");\r
+ return NULL;\r
+ }\r
+\r
+ parent = get_parent(globals, buf, &buflen, level);\r
+ if (parent == NULL)\r
+ return NULL;\r
+\r
+ head = load_next(parent, level < 0 ? Py_None : parent, &name, buf,\r
+ &buflen);\r
+ if (head == NULL)\r
+ return NULL;\r
+\r
+ tail = head;\r
+ Py_INCREF(tail);\r
+ while (name) {\r
+ next = load_next(tail, tail, &name, buf, &buflen);\r
+ Py_DECREF(tail);\r
+ if (next == NULL) {\r
+ Py_DECREF(head);\r
+ return NULL;\r
+ }\r
+ tail = next;\r
+ }\r
+ if (tail == Py_None) {\r
+ /* If tail is Py_None, both get_parent and load_next found\r
+ an empty module name: someone called __import__("") or\r
+ doctored faulty bytecode */\r
+ Py_DECREF(tail);\r
+ Py_DECREF(head);\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "Empty module name");\r
+ return NULL;\r
+ }\r
+\r
+ if (fromlist != NULL) {\r
+ if (fromlist == Py_None || !PyObject_IsTrue(fromlist))\r
+ fromlist = NULL;\r
+ }\r
+\r
+ if (fromlist == NULL) {\r
+ Py_DECREF(tail);\r
+ return head;\r
+ }\r
+\r
+ Py_DECREF(head);\r
+ if (!ensure_fromlist(tail, fromlist, buf, buflen, 0)) {\r
+ Py_DECREF(tail);\r
+ return NULL;\r
+ }\r
+\r
+ return tail;\r
+}\r
+\r
+PyObject *\r
+PyImport_ImportModuleLevel(char *name, PyObject *globals, PyObject *locals,\r
+ PyObject *fromlist, int level)\r
+{\r
+ PyObject *result;\r
+ _PyImport_AcquireLock();\r
+ result = import_module_level(name, globals, locals, fromlist, level);\r
+ if (_PyImport_ReleaseLock() < 0) {\r
+ Py_XDECREF(result);\r
+ PyErr_SetString(PyExc_RuntimeError,\r
+ "not holding the import lock");\r
+ return NULL;\r
+ }\r
+ return result;\r
+}\r
+\r
+/* Return the package that an import is being performed in. If globals comes\r
+ from the module foo.bar.bat (not itself a package), this returns the\r
+ sys.modules entry for foo.bar. If globals is from a package's __init__.py,\r
+ the package's entry in sys.modules is returned, as a borrowed reference.\r
+\r
+ The *name* of the returned package is returned in buf, with the length of\r
+ the name in *p_buflen.\r
+\r
+ If globals doesn't come from a package or a module in a package, or a\r
+ corresponding entry is not found in sys.modules, Py_None is returned.\r
+*/\r
+static PyObject *\r
+get_parent(PyObject *globals, char *buf, Py_ssize_t *p_buflen, int level)\r
+{\r
+ static PyObject *namestr = NULL;\r
+ static PyObject *pathstr = NULL;\r
+ static PyObject *pkgstr = NULL;\r
+ PyObject *pkgname, *modname, *modpath, *modules, *parent;\r
+ int orig_level = level;\r
+\r
+ if (globals == NULL || !PyDict_Check(globals) || !level)\r
+ return Py_None;\r
+\r
+ if (namestr == NULL) {\r
+ namestr = PyString_InternFromString("__name__");\r
+ if (namestr == NULL)\r
+ return NULL;\r
+ }\r
+ if (pathstr == NULL) {\r
+ pathstr = PyString_InternFromString("__path__");\r
+ if (pathstr == NULL)\r
+ return NULL;\r
+ }\r
+ if (pkgstr == NULL) {\r
+ pkgstr = PyString_InternFromString("__package__");\r
+ if (pkgstr == NULL)\r
+ return NULL;\r
+ }\r
+\r
+ *buf = '\0';\r
+ *p_buflen = 0;\r
+ pkgname = PyDict_GetItem(globals, pkgstr);\r
+\r
+ if ((pkgname != NULL) && (pkgname != Py_None)) {\r
+ /* __package__ is set, so use it */\r
+ Py_ssize_t len;\r
+ if (!PyString_Check(pkgname)) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "__package__ set to non-string");\r
+ return NULL;\r
+ }\r
+ len = PyString_GET_SIZE(pkgname);\r
+ if (len == 0) {\r
+ if (level > 0) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "Attempted relative import in non-package");\r
+ return NULL;\r
+ }\r
+ return Py_None;\r
+ }\r
+ if (len > MAXPATHLEN) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "Package name too long");\r
+ return NULL;\r
+ }\r
+ strcpy(buf, PyString_AS_STRING(pkgname));\r
+ } else {\r
+ /* __package__ not set, so figure it out and set it */\r
+ modname = PyDict_GetItem(globals, namestr);\r
+ if (modname == NULL || !PyString_Check(modname))\r
+ return Py_None;\r
+\r
+ modpath = PyDict_GetItem(globals, pathstr);\r
+ if (modpath != NULL) {\r
+ /* __path__ is set, so modname is already the package name */\r
+ Py_ssize_t len = PyString_GET_SIZE(modname);\r
+ int error;\r
+ if (len > MAXPATHLEN) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "Module name too long");\r
+ return NULL;\r
+ }\r
+ strcpy(buf, PyString_AS_STRING(modname));\r
+ error = PyDict_SetItem(globals, pkgstr, modname);\r
+ if (error) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "Could not set __package__");\r
+ return NULL;\r
+ }\r
+ } else {\r
+ /* Normal module, so work out the package name if any */\r
+ char *start = PyString_AS_STRING(modname);\r
+ char *lastdot = strrchr(start, '.');\r
+ size_t len;\r
+ int error;\r
+ if (lastdot == NULL && level > 0) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "Attempted relative import in non-package");\r
+ return NULL;\r
+ }\r
+ if (lastdot == NULL) {\r
+ error = PyDict_SetItem(globals, pkgstr, Py_None);\r
+ if (error) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "Could not set __package__");\r
+ return NULL;\r
+ }\r
+ return Py_None;\r
+ }\r
+ len = lastdot - start;\r
+ if (len >= MAXPATHLEN) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "Module name too long");\r
+ return NULL;\r
+ }\r
+ strncpy(buf, start, len);\r
+ buf[len] = '\0';\r
+ pkgname = PyString_FromString(buf);\r
+ if (pkgname == NULL) {\r
+ return NULL;\r
+ }\r
+ error = PyDict_SetItem(globals, pkgstr, pkgname);\r
+ Py_DECREF(pkgname);\r
+ if (error) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "Could not set __package__");\r
+ return NULL;\r
+ }\r
+ }\r
+ }\r
+ while (--level > 0) {\r
+ char *dot = strrchr(buf, '.');\r
+ if (dot == NULL) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "Attempted relative import beyond "\r
+ "toplevel package");\r
+ return NULL;\r
+ }\r
+ *dot = '\0';\r
+ }\r
+ *p_buflen = strlen(buf);\r
+\r
+ modules = PyImport_GetModuleDict();\r
+ parent = PyDict_GetItemString(modules, buf);\r
+ if (parent == NULL) {\r
+ if (orig_level < 1) {\r
+ PyObject *err_msg = PyString_FromFormat(\r
+ "Parent module '%.200s' not found "\r
+ "while handling absolute import", buf);\r
+ if (err_msg == NULL) {\r
+ return NULL;\r
+ }\r
+ if (!PyErr_WarnEx(PyExc_RuntimeWarning,\r
+ PyString_AsString(err_msg), 1)) {\r
+ *buf = '\0';\r
+ *p_buflen = 0;\r
+ parent = Py_None;\r
+ }\r
+ Py_DECREF(err_msg);\r
+ } else {\r
+ PyErr_Format(PyExc_SystemError,\r
+ "Parent module '%.200s' not loaded, "\r
+ "cannot perform relative import", buf);\r
+ }\r
+ }\r
+ return parent;\r
+ /* We expect, but can't guarantee, if parent != None, that:\r
+ - parent.__name__ == buf\r
+ - parent.__dict__ is globals\r
+ If this is violated... Who cares? */\r
+}\r
+\r
+/* altmod is either None or same as mod */\r
+static PyObject *\r
+load_next(PyObject *mod, PyObject *altmod, char **p_name, char *buf,\r
+ Py_ssize_t *p_buflen)\r
+{\r
+ char *name = *p_name;\r
+ char *dot = strchr(name, '.');\r
+ size_t len;\r
+ char *p;\r
+ PyObject *result;\r
+\r
+ if (strlen(name) == 0) {\r
+ /* completely empty module name should only happen in\r
+ 'from . import' (or '__import__("")')*/\r
+ Py_INCREF(mod);\r
+ *p_name = NULL;\r
+ return mod;\r
+ }\r
+\r
+ if (dot == NULL) {\r
+ *p_name = NULL;\r
+ len = strlen(name);\r
+ }\r
+ else {\r
+ *p_name = dot+1;\r
+ len = dot-name;\r
+ }\r
+ if (len == 0) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "Empty module name");\r
+ return NULL;\r
+ }\r
+\r
+ p = buf + *p_buflen;\r
+ if (p != buf)\r
+ *p++ = '.';\r
+ if (p+len-buf >= MAXPATHLEN) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "Module name too long");\r
+ return NULL;\r
+ }\r
+ strncpy(p, name, len);\r
+ p[len] = '\0';\r
+ *p_buflen = p+len-buf;\r
+\r
+ result = import_submodule(mod, p, buf);\r
+ if (result == Py_None && altmod != mod) {\r
+ Py_DECREF(result);\r
+ /* Here, altmod must be None and mod must not be None */\r
+ result = import_submodule(altmod, p, p);\r
+ if (result != NULL && result != Py_None) {\r
+ if (mark_miss(buf) != 0) {\r
+ Py_DECREF(result);\r
+ return NULL;\r
+ }\r
+ strncpy(buf, name, len);\r
+ buf[len] = '\0';\r
+ *p_buflen = len;\r
+ }\r
+ }\r
+ if (result == NULL)\r
+ return NULL;\r
+\r
+ if (result == Py_None) {\r
+ Py_DECREF(result);\r
+ PyErr_Format(PyExc_ImportError,\r
+ "No module named %.200s", name);\r
+ return NULL;\r
+ }\r
+\r
+ return result;\r
+}\r
+\r
+static int\r
+mark_miss(char *name)\r
+{\r
+ PyObject *modules = PyImport_GetModuleDict();\r
+ return PyDict_SetItemString(modules, name, Py_None);\r
+}\r
+\r
+static int\r
+ensure_fromlist(PyObject *mod, PyObject *fromlist, char *buf, Py_ssize_t buflen,\r
+ int recursive)\r
+{\r
+ int i;\r
+\r
+ if (!PyObject_HasAttrString(mod, "__path__"))\r
+ return 1;\r
+\r
+ for (i = 0; ; i++) {\r
+ PyObject *item = PySequence_GetItem(fromlist, i);\r
+ int hasit;\r
+ if (item == NULL) {\r
+ if (PyErr_ExceptionMatches(PyExc_IndexError)) {\r
+ PyErr_Clear();\r
+ return 1;\r
+ }\r
+ return 0;\r
+ }\r
+ if (!PyString_Check(item)) {\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "Item in ``from list'' not a string");\r
+ Py_DECREF(item);\r
+ return 0;\r
+ }\r
+ if (PyString_AS_STRING(item)[0] == '*') {\r
+ PyObject *all;\r
+ Py_DECREF(item);\r
+ /* See if the package defines __all__ */\r
+ if (recursive)\r
+ continue; /* Avoid endless recursion */\r
+ all = PyObject_GetAttrString(mod, "__all__");\r
+ if (all == NULL)\r
+ PyErr_Clear();\r
+ else {\r
+ int ret = ensure_fromlist(mod, all, buf, buflen, 1);\r
+ Py_DECREF(all);\r
+ if (!ret)\r
+ return 0;\r
+ }\r
+ continue;\r
+ }\r
+ hasit = PyObject_HasAttr(mod, item);\r
+ if (!hasit) {\r
+ char *subname = PyString_AS_STRING(item);\r
+ PyObject *submod;\r
+ char *p;\r
+ if (buflen + strlen(subname) >= MAXPATHLEN) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "Module name too long");\r
+ Py_DECREF(item);\r
+ return 0;\r
+ }\r
+ p = buf + buflen;\r
+ *p++ = '.';\r
+ strcpy(p, subname);\r
+ submod = import_submodule(mod, subname, buf);\r
+ Py_XDECREF(submod);\r
+ if (submod == NULL) {\r
+ Py_DECREF(item);\r
+ return 0;\r
+ }\r
+ }\r
+ Py_DECREF(item);\r
+ }\r
+\r
+ /* NOTREACHED */\r
+}\r
+\r
+static int\r
+add_submodule(PyObject *mod, PyObject *submod, char *fullname, char *subname,\r
+ PyObject *modules)\r
+{\r
+ if (mod == Py_None)\r
+ return 1;\r
+ /* Irrespective of the success of this load, make a\r
+ reference to it in the parent package module. A copy gets\r
+ saved in the modules dictionary under the full name, so get a\r
+ reference from there, if need be. (The exception is when the\r
+ load failed with a SyntaxError -- then there's no trace in\r
+ sys.modules. In that case, of course, do nothing extra.) */\r
+ if (submod == NULL) {\r
+ submod = PyDict_GetItemString(modules, fullname);\r
+ if (submod == NULL)\r
+ return 1;\r
+ }\r
+ if (PyModule_Check(mod)) {\r
+ /* We can't use setattr here since it can give a\r
+ * spurious warning if the submodule name shadows a\r
+ * builtin name */\r
+ PyObject *dict = PyModule_GetDict(mod);\r
+ if (!dict)\r
+ return 0;\r
+ if (PyDict_SetItemString(dict, subname, submod) < 0)\r
+ return 0;\r
+ }\r
+ else {\r
+ if (PyObject_SetAttrString(mod, subname, submod) < 0)\r
+ return 0;\r
+ }\r
+ return 1;\r
+}\r
+\r
+static PyObject *\r
+import_submodule(PyObject *mod, char *subname, char *fullname)\r
+{\r
+ PyObject *modules = PyImport_GetModuleDict();\r
+ PyObject *m = NULL;\r
+\r
+ /* Require:\r
+ if mod == None: subname == fullname\r
+ else: mod.__name__ + "." + subname == fullname\r
+ */\r
+\r
+ if ((m = PyDict_GetItemString(modules, fullname)) != NULL) {\r
+ Py_INCREF(m);\r
+ }\r
+ else {\r
+ PyObject *path, *loader = NULL;\r
+ char buf[MAXPATHLEN+1];\r
+ struct filedescr *fdp;\r
+ FILE *fp = NULL;\r
+\r
+ if (mod == Py_None)\r
+ path = NULL;\r
+ else {\r
+ path = PyObject_GetAttrString(mod, "__path__");\r
+ if (path == NULL) {\r
+ PyErr_Clear();\r
+ Py_INCREF(Py_None);\r
+ return Py_None;\r
+ }\r
+ }\r
+\r
+ buf[0] = '\0';\r
+ fdp = find_module(fullname, subname, path, buf, MAXPATHLEN+1,\r
+ &fp, &loader);\r
+ Py_XDECREF(path);\r
+ if (fdp == NULL) {\r
+ if (!PyErr_ExceptionMatches(PyExc_ImportError))\r
+ return NULL;\r
+ PyErr_Clear();\r
+ Py_INCREF(Py_None);\r
+ return Py_None;\r
+ }\r
+ m = load_module(fullname, fp, buf, fdp->type, loader);\r
+ Py_XDECREF(loader);\r
+ if (fp)\r
+ fclose(fp);\r
+ if (!add_submodule(mod, m, fullname, subname, modules)) {\r
+ Py_XDECREF(m);\r
+ m = NULL;\r
+ }\r
+ }\r
+\r
+ return m;\r
+}\r
+\r
+\r
+/* Re-import a module of any kind and return its module object, WITH\r
+ INCREMENTED REFERENCE COUNT */\r
+\r
+PyObject *\r
+PyImport_ReloadModule(PyObject *m)\r
+{\r
+ PyInterpreterState *interp = PyThreadState_Get()->interp;\r
+ PyObject *modules_reloading = interp->modules_reloading;\r
+ PyObject *modules = PyImport_GetModuleDict();\r
+ PyObject *path = NULL, *loader = NULL, *existing_m = NULL;\r
+ char *name, *subname;\r
+ char buf[MAXPATHLEN+1];\r
+ struct filedescr *fdp;\r
+ FILE *fp = NULL;\r
+ PyObject *newm;\r
+\r
+ if (modules_reloading == NULL) {\r
+ Py_FatalError("PyImport_ReloadModule: "\r
+ "no modules_reloading dictionary!");\r
+ return NULL;\r
+ }\r
+\r
+ if (m == NULL || !PyModule_Check(m)) {\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "reload() argument must be module");\r
+ return NULL;\r
+ }\r
+ name = PyModule_GetName(m);\r
+ if (name == NULL)\r
+ return NULL;\r
+ if (m != PyDict_GetItemString(modules, name)) {\r
+ PyErr_Format(PyExc_ImportError,\r
+ "reload(): module %.200s not in sys.modules",\r
+ name);\r
+ return NULL;\r
+ }\r
+ existing_m = PyDict_GetItemString(modules_reloading, name);\r
+ if (existing_m != NULL) {\r
+ /* Due to a recursive reload, this module is already\r
+ being reloaded. */\r
+ Py_INCREF(existing_m);\r
+ return existing_m;\r
+ }\r
+ if (PyDict_SetItemString(modules_reloading, name, m) < 0)\r
+ return NULL;\r
+\r
+ subname = strrchr(name, '.');\r
+ if (subname == NULL)\r
+ subname = name;\r
+ else {\r
+ PyObject *parentname, *parent;\r
+ parentname = PyString_FromStringAndSize(name, (subname-name));\r
+ if (parentname == NULL) {\r
+ imp_modules_reloading_clear();\r
+ return NULL;\r
+ }\r
+ parent = PyDict_GetItem(modules, parentname);\r
+ if (parent == NULL) {\r
+ PyErr_Format(PyExc_ImportError,\r
+ "reload(): parent %.200s not in sys.modules",\r
+ PyString_AS_STRING(parentname));\r
+ Py_DECREF(parentname);\r
+ imp_modules_reloading_clear();\r
+ return NULL;\r
+ }\r
+ Py_DECREF(parentname);\r
+ subname++;\r
+ path = PyObject_GetAttrString(parent, "__path__");\r
+ if (path == NULL)\r
+ PyErr_Clear();\r
+ }\r
+ buf[0] = '\0';\r
+ fdp = find_module(name, subname, path, buf, MAXPATHLEN+1, &fp, &loader);\r
+ Py_XDECREF(path);\r
+\r
+ if (fdp == NULL) {\r
+ Py_XDECREF(loader);\r
+ imp_modules_reloading_clear();\r
+ return NULL;\r
+ }\r
+\r
+ newm = load_module(name, fp, buf, fdp->type, loader);\r
+ Py_XDECREF(loader);\r
+\r
+ if (fp)\r
+ fclose(fp);\r
+ if (newm == NULL) {\r
+ /* load_module probably removed name from modules because of\r
+ * the error. Put back the original module object. We're\r
+ * going to return NULL in this case regardless of whether\r
+ * replacing name succeeds, so the return value is ignored.\r
+ */\r
+ PyDict_SetItemString(modules, name, m);\r
+ }\r
+ imp_modules_reloading_clear();\r
+ return newm;\r
+}\r
+\r
+\r
+/* Higher-level import emulator which emulates the "import" statement\r
+ more accurately -- it invokes the __import__() function from the\r
+ builtins of the current globals. This means that the import is\r
+ done using whatever import hooks are installed in the current\r
+ environment, e.g. by "rexec".\r
+ A dummy list ["__doc__"] is passed as the 4th argument so that\r
+ e.g. PyImport_Import(PyString_FromString("win32com.client.gencache"))\r
+ will return <module "gencache"> instead of <module "win32com">. */\r
+\r
+PyObject *\r
+PyImport_Import(PyObject *module_name)\r
+{\r
+ static PyObject *silly_list = NULL;\r
+ static PyObject *builtins_str = NULL;\r
+ static PyObject *import_str = NULL;\r
+ PyObject *globals = NULL;\r
+ PyObject *import = NULL;\r
+ PyObject *builtins = NULL;\r
+ PyObject *r = NULL;\r
+\r
+ /* Initialize constant string objects */\r
+ if (silly_list == NULL) {\r
+ import_str = PyString_InternFromString("__import__");\r
+ if (import_str == NULL)\r
+ return NULL;\r
+ builtins_str = PyString_InternFromString("__builtins__");\r
+ if (builtins_str == NULL)\r
+ return NULL;\r
+ silly_list = Py_BuildValue("[s]", "__doc__");\r
+ if (silly_list == NULL)\r
+ return NULL;\r
+ }\r
+\r
+ /* Get the builtins from current globals */\r
+ globals = PyEval_GetGlobals();\r
+ if (globals != NULL) {\r
+ Py_INCREF(globals);\r
+ builtins = PyObject_GetItem(globals, builtins_str);\r
+ if (builtins == NULL)\r
+ goto err;\r
+ }\r
+ else {\r
+ /* No globals -- use standard builtins, and fake globals */\r
+ builtins = PyImport_ImportModuleLevel("__builtin__",\r
+ NULL, NULL, NULL, 0);\r
+ if (builtins == NULL)\r
+ return NULL;\r
+ globals = Py_BuildValue("{OO}", builtins_str, builtins);\r
+ if (globals == NULL)\r
+ goto err;\r
+ }\r
+\r
+ /* Get the __import__ function from the builtins */\r
+ if (PyDict_Check(builtins)) {\r
+ import = PyObject_GetItem(builtins, import_str);\r
+ if (import == NULL)\r
+ PyErr_SetObject(PyExc_KeyError, import_str);\r
+ }\r
+ else\r
+ import = PyObject_GetAttr(builtins, import_str);\r
+ if (import == NULL)\r
+ goto err;\r
+\r
+ /* Call the __import__ function with the proper argument list\r
+ * Always use absolute import here. */\r
+ r = PyObject_CallFunction(import, "OOOOi", module_name, globals,\r
+ globals, silly_list, 0, NULL);\r
+\r
+ err:\r
+ Py_XDECREF(globals);\r
+ Py_XDECREF(builtins);\r
+ Py_XDECREF(import);\r
+\r
+ return r;\r
+}\r
+\r
+\r
+/* Module 'imp' provides Python access to the primitives used for\r
+ importing modules.\r
+*/\r
+\r
+static PyObject *\r
+imp_get_magic(PyObject *self, PyObject *noargs)\r
+{\r
+ char buf[4];\r
+\r
+ buf[0] = (char) ((pyc_magic >> 0) & 0xff);\r
+ buf[1] = (char) ((pyc_magic >> 8) & 0xff);\r
+ buf[2] = (char) ((pyc_magic >> 16) & 0xff);\r
+ buf[3] = (char) ((pyc_magic >> 24) & 0xff);\r
+\r
+ return PyString_FromStringAndSize(buf, 4);\r
+}\r
+\r
+static PyObject *\r
+imp_get_suffixes(PyObject *self, PyObject *noargs)\r
+{\r
+ PyObject *list;\r
+ struct filedescr *fdp;\r
+\r
+ list = PyList_New(0);\r
+ if (list == NULL)\r
+ return NULL;\r
+ for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {\r
+ PyObject *item = Py_BuildValue("ssi",\r
+ fdp->suffix, fdp->mode, fdp->type);\r
+ if (item == NULL) {\r
+ Py_DECREF(list);\r
+ return NULL;\r
+ }\r
+ if (PyList_Append(list, item) < 0) {\r
+ Py_DECREF(list);\r
+ Py_DECREF(item);\r
+ return NULL;\r
+ }\r
+ Py_DECREF(item);\r
+ }\r
+ return list;\r
+}\r
+\r
+static PyObject *\r
+call_find_module(char *name, PyObject *path)\r
+{\r
+ extern int fclose(FILE *);\r
+ PyObject *fob, *ret;\r
+ struct filedescr *fdp;\r
+ char pathname[MAXPATHLEN+1];\r
+ FILE *fp = NULL;\r
+\r
+ pathname[0] = '\0';\r
+ if (path == Py_None)\r
+ path = NULL;\r
+ fdp = find_module(NULL, name, path, pathname, MAXPATHLEN+1, &fp, NULL);\r
+ if (fdp == NULL)\r
+ return NULL;\r
+ if (fp != NULL) {\r
+ fob = PyFile_FromFile(fp, pathname, fdp->mode, fclose);\r
+ if (fob == NULL) {\r
+ fclose(fp);\r
+ return NULL;\r
+ }\r
+ }\r
+ else {\r
+ fob = Py_None;\r
+ Py_INCREF(fob);\r
+ }\r
+ ret = Py_BuildValue("Os(ssi)",\r
+ fob, pathname, fdp->suffix, fdp->mode, fdp->type);\r
+ Py_DECREF(fob);\r
+ return ret;\r
+}\r
+\r
+static PyObject *\r
+imp_find_module(PyObject *self, PyObject *args)\r
+{\r
+ char *name;\r
+ PyObject *path = NULL;\r
+ if (!PyArg_ParseTuple(args, "s|O:find_module", &name, &path))\r
+ return NULL;\r
+ return call_find_module(name, path);\r
+}\r
+\r
+static PyObject *\r
+imp_init_builtin(PyObject *self, PyObject *args)\r
+{\r
+ char *name;\r
+ int ret;\r
+ PyObject *m;\r
+ if (!PyArg_ParseTuple(args, "s:init_builtin", &name))\r
+ return NULL;\r
+ ret = init_builtin(name);\r
+ if (ret < 0)\r
+ return NULL;\r
+ if (ret == 0) {\r
+ Py_INCREF(Py_None);\r
+ return Py_None;\r
+ }\r
+ m = PyImport_AddModule(name);\r
+ Py_XINCREF(m);\r
+ return m;\r
+}\r
+\r
+static PyObject *\r
+imp_init_frozen(PyObject *self, PyObject *args)\r
+{\r
+ char *name;\r
+ int ret;\r
+ PyObject *m;\r
+ if (!PyArg_ParseTuple(args, "s:init_frozen", &name))\r
+ return NULL;\r
+ ret = PyImport_ImportFrozenModule(name);\r
+ if (ret < 0)\r
+ return NULL;\r
+ if (ret == 0) {\r
+ Py_INCREF(Py_None);\r
+ return Py_None;\r
+ }\r
+ m = PyImport_AddModule(name);\r
+ Py_XINCREF(m);\r
+ return m;\r
+}\r
+\r
+static PyObject *\r
+imp_get_frozen_object(PyObject *self, PyObject *args)\r
+{\r
+ char *name;\r
+\r
+ if (!PyArg_ParseTuple(args, "s:get_frozen_object", &name))\r
+ return NULL;\r
+ return get_frozen_object(name);\r
+}\r
+\r
+static PyObject *\r
+imp_is_builtin(PyObject *self, PyObject *args)\r
+{\r
+ char *name;\r
+ if (!PyArg_ParseTuple(args, "s:is_builtin", &name))\r
+ return NULL;\r
+ return PyInt_FromLong(is_builtin(name));\r
+}\r
+\r
+static PyObject *\r
+imp_is_frozen(PyObject *self, PyObject *args)\r
+{\r
+ char *name;\r
+ struct _frozen *p;\r
+ if (!PyArg_ParseTuple(args, "s:is_frozen", &name))\r
+ return NULL;\r
+ p = find_frozen(name);\r
+ return PyBool_FromLong((long) (p == NULL ? 0 : p->size));\r
+}\r
+\r
+static FILE *\r
+get_file(char *pathname, PyObject *fob, char *mode)\r
+{\r
+ FILE *fp;\r
+ if (fob == NULL) {\r
+ if (mode[0] == 'U')\r
+ mode = "r" PY_STDIOTEXTMODE;\r
+ fp = fopen(pathname, mode);\r
+ if (fp == NULL)\r
+ PyErr_SetFromErrno(PyExc_IOError);\r
+ }\r
+ else {\r
+ fp = PyFile_AsFile(fob);\r
+ if (fp == NULL)\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "bad/closed file object");\r
+ }\r
+ return fp;\r
+}\r
+\r
+static PyObject *\r
+imp_load_compiled(PyObject *self, PyObject *args)\r
+{\r
+ char *name;\r
+ char *pathname;\r
+ PyObject *fob = NULL;\r
+ PyObject *m;\r
+ FILE *fp;\r
+ if (!PyArg_ParseTuple(args, "ss|O!:load_compiled", &name, &pathname,\r
+ &PyFile_Type, &fob))\r
+ return NULL;\r
+ fp = get_file(pathname, fob, "rb");\r
+ if (fp == NULL)\r
+ return NULL;\r
+ m = load_compiled_module(name, pathname, fp);\r
+ if (fob == NULL)\r
+ fclose(fp);\r
+ return m;\r
+}\r
+\r
+#ifdef HAVE_DYNAMIC_LOADING\r
+\r
+static PyObject *\r
+imp_load_dynamic(PyObject *self, PyObject *args)\r
+{\r
+ char *name;\r
+ char *pathname;\r
+ PyObject *fob = NULL;\r
+ PyObject *m;\r
+ FILE *fp = NULL;\r
+ if (!PyArg_ParseTuple(args, "ss|O!:load_dynamic", &name, &pathname,\r
+ &PyFile_Type, &fob))\r
+ return NULL;\r
+ if (fob) {\r
+ fp = get_file(pathname, fob, "r");\r
+ if (fp == NULL)\r
+ return NULL;\r
+ }\r
+ m = _PyImport_LoadDynamicModule(name, pathname, fp);\r
+ return m;\r
+}\r
+\r
+#endif /* HAVE_DYNAMIC_LOADING */\r
+\r
+static PyObject *\r
+imp_load_source(PyObject *self, PyObject *args)\r
+{\r
+ char *name;\r
+ char *pathname;\r
+ PyObject *fob = NULL;\r
+ PyObject *m;\r
+ FILE *fp;\r
+ if (!PyArg_ParseTuple(args, "ss|O!:load_source", &name, &pathname,\r
+ &PyFile_Type, &fob))\r
+ return NULL;\r
+ fp = get_file(pathname, fob, "r");\r
+ if (fp == NULL)\r
+ return NULL;\r
+ m = load_source_module(name, pathname, fp);\r
+ if (fob == NULL)\r
+ fclose(fp);\r
+ return m;\r
+}\r
+\r
+static PyObject *\r
+imp_load_module(PyObject *self, PyObject *args)\r
+{\r
+ char *name;\r
+ PyObject *fob;\r
+ char *pathname;\r
+ char *suffix; /* Unused */\r
+ char *mode;\r
+ int type;\r
+ FILE *fp;\r
+\r
+ if (!PyArg_ParseTuple(args, "sOs(ssi):load_module",\r
+ &name, &fob, &pathname,\r
+ &suffix, &mode, &type))\r
+ return NULL;\r
+ if (*mode) {\r
+ /* Mode must start with 'r' or 'U' and must not contain '+'.\r
+ Implicit in this test is the assumption that the mode\r
+ may contain other modifiers like 'b' or 't'. */\r
+\r
+ if (!(*mode == 'r' || *mode == 'U') || strchr(mode, '+')) {\r
+ PyErr_Format(PyExc_ValueError,\r
+ "invalid file open mode %.200s", mode);\r
+ return NULL;\r
+ }\r
+ }\r
+ if (fob == Py_None)\r
+ fp = NULL;\r
+ else {\r
+ if (!PyFile_Check(fob)) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "load_module arg#2 should be a file or None");\r
+ return NULL;\r
+ }\r
+ fp = get_file(pathname, fob, mode);\r
+ if (fp == NULL)\r
+ return NULL;\r
+ }\r
+ return load_module(name, fp, pathname, type, NULL);\r
+}\r
+\r
+static PyObject *\r
+imp_load_package(PyObject *self, PyObject *args)\r
+{\r
+ char *name;\r
+ char *pathname;\r
+ if (!PyArg_ParseTuple(args, "ss:load_package", &name, &pathname))\r
+ return NULL;\r
+ return load_package(name, pathname);\r
+}\r
+\r
+static PyObject *\r
+imp_new_module(PyObject *self, PyObject *args)\r
+{\r
+ char *name;\r
+ if (!PyArg_ParseTuple(args, "s:new_module", &name))\r
+ return NULL;\r
+ return PyModule_New(name);\r
+}\r
+\r
+static PyObject *\r
+imp_reload(PyObject *self, PyObject *v)\r
+{\r
+ return PyImport_ReloadModule(v);\r
+}\r
+\r
+\r
+/* Doc strings */\r
+\r
+PyDoc_STRVAR(doc_imp,\r
+"This module provides the components needed to build your own\n\\r
+__import__ function. Undocumented functions are obsolete.");\r
+\r
+PyDoc_STRVAR(doc_reload,\r
+"reload(module) -> module\n\\r
+\n\\r
+Reload the module. The module must have been successfully imported before.");\r
+\r
+PyDoc_STRVAR(doc_find_module,\r
+"find_module(name, [path]) -> (file, filename, (suffix, mode, type))\n\\r
+Search for a module. If path is omitted or None, search for a\n\\r
+built-in, frozen or special module and continue search in sys.path.\n\\r
+The module name cannot contain '.'; to search for a submodule of a\n\\r
+package, pass the submodule name and the package's __path__.");\r
+\r
+PyDoc_STRVAR(doc_load_module,\r
+"load_module(name, file, filename, (suffix, mode, type)) -> module\n\\r
+Load a module, given information returned by find_module().\n\\r
+The module name must include the full package name, if any.");\r
+\r
+PyDoc_STRVAR(doc_get_magic,\r
+"get_magic() -> string\n\\r
+Return the magic number for .pyc or .pyo files.");\r
+\r
+PyDoc_STRVAR(doc_get_suffixes,\r
+"get_suffixes() -> [(suffix, mode, type), ...]\n\\r
+Return a list of (suffix, mode, type) tuples describing the files\n\\r
+that find_module() looks for.");\r
+\r
+PyDoc_STRVAR(doc_new_module,\r
+"new_module(name) -> module\n\\r
+Create a new module. Do not enter it in sys.modules.\n\\r
+The module name must include the full package name, if any.");\r
+\r
+PyDoc_STRVAR(doc_lock_held,\r
+"lock_held() -> boolean\n\\r
+Return True if the import lock is currently held, else False.\n\\r
+On platforms without threads, return False.");\r
+\r
+PyDoc_STRVAR(doc_acquire_lock,\r
+"acquire_lock() -> None\n\\r
+Acquires the interpreter's import lock for the current thread.\n\\r
+This lock should be used by import hooks to ensure thread-safety\n\\r
+when importing modules.\n\\r
+On platforms without threads, this function does nothing.");\r
+\r
+PyDoc_STRVAR(doc_release_lock,\r
+"release_lock() -> None\n\\r
+Release the interpreter's import lock.\n\\r
+On platforms without threads, this function does nothing.");\r
+\r
+static PyMethodDef imp_methods[] = {\r
+ {"reload", imp_reload, METH_O, doc_reload},\r
+ {"find_module", imp_find_module, METH_VARARGS, doc_find_module},\r
+ {"get_magic", imp_get_magic, METH_NOARGS, doc_get_magic},\r
+ {"get_suffixes", imp_get_suffixes, METH_NOARGS, doc_get_suffixes},\r
+ {"load_module", imp_load_module, METH_VARARGS, doc_load_module},\r
+ {"new_module", imp_new_module, METH_VARARGS, doc_new_module},\r
+ {"lock_held", imp_lock_held, METH_NOARGS, doc_lock_held},\r
+ {"acquire_lock", imp_acquire_lock, METH_NOARGS, doc_acquire_lock},\r
+ {"release_lock", imp_release_lock, METH_NOARGS, doc_release_lock},\r
+ /* The rest are obsolete */\r
+ {"get_frozen_object", imp_get_frozen_object, METH_VARARGS},\r
+ {"init_builtin", imp_init_builtin, METH_VARARGS},\r
+ {"init_frozen", imp_init_frozen, METH_VARARGS},\r
+ {"is_builtin", imp_is_builtin, METH_VARARGS},\r
+ {"is_frozen", imp_is_frozen, METH_VARARGS},\r
+ {"load_compiled", imp_load_compiled, METH_VARARGS},\r
+#ifdef HAVE_DYNAMIC_LOADING\r
+ {"load_dynamic", imp_load_dynamic, METH_VARARGS},\r
+#endif\r
+ {"load_package", imp_load_package, METH_VARARGS},\r
+ {"load_source", imp_load_source, METH_VARARGS},\r
+ {NULL, NULL} /* sentinel */\r
+};\r
+\r
+static int\r
+setint(PyObject *d, char *name, int value)\r
+{\r
+ PyObject *v;\r
+ int err;\r
+\r
+ v = PyInt_FromLong((long)value);\r
+ err = PyDict_SetItemString(d, name, v);\r
+ Py_XDECREF(v);\r
+ return err;\r
+}\r
+\r
+typedef struct {\r
+ PyObject_HEAD\r
+} NullImporter;\r
+\r
+static int\r
+NullImporter_init(NullImporter *self, PyObject *args, PyObject *kwds)\r
+{\r
+ char *path;\r
+ Py_ssize_t pathlen;\r
+\r
+ if (!_PyArg_NoKeywords("NullImporter()", kwds))\r
+ return -1;\r
+\r
+ if (!PyArg_ParseTuple(args, "s:NullImporter",\r
+ &path))\r
+ return -1;\r
+\r
+ pathlen = strlen(path);\r
+ if (pathlen == 0) {\r
+ PyErr_SetString(PyExc_ImportError, "empty pathname");\r
+ return -1;\r
+ } else {\r
+#ifndef RISCOS\r
+#ifndef MS_WINDOWS\r
+ struct stat statbuf;\r
+ int rv;\r
+\r
+ rv = stat(path, &statbuf);\r
+ if (rv == 0) {\r
+ /* it exists */\r
+ if (S_ISDIR(statbuf.st_mode)) {\r
+ /* it's a directory */\r
+ PyErr_SetString(PyExc_ImportError,\r
+ "existing directory");\r
+ return -1;\r
+ }\r
+ }\r
+#else /* MS_WINDOWS */\r
+ DWORD rv;\r
+ /* see issue1293 and issue3677:\r
+ * stat() on Windows doesn't recognise paths like\r
+ * "e:\\shared\\" and "\\\\whiterab-c2znlh\\shared" as dirs.\r
+ */\r
+ rv = GetFileAttributesA(path);\r
+ if (rv != INVALID_FILE_ATTRIBUTES) {\r
+ /* it exists */\r
+ if (rv & FILE_ATTRIBUTE_DIRECTORY) {\r
+ /* it's a directory */\r
+ PyErr_SetString(PyExc_ImportError,\r
+ "existing directory");\r
+ return -1;\r
+ }\r
+ }\r
+#endif\r
+#else /* RISCOS */\r
+ if (object_exists(path)) {\r
+ /* it exists */\r
+ if (isdir(path)) {\r
+ /* it's a directory */\r
+ PyErr_SetString(PyExc_ImportError,\r
+ "existing directory");\r
+ return -1;\r
+ }\r
+ }\r
+#endif\r
+ }\r
+ return 0;\r
+}\r
+\r
+static PyObject *\r
+NullImporter_find_module(NullImporter *self, PyObject *args)\r
+{\r
+ Py_RETURN_NONE;\r
+}\r
+\r
+static PyMethodDef NullImporter_methods[] = {\r
+ {"find_module", (PyCFunction)NullImporter_find_module, METH_VARARGS,\r
+ "Always return None"\r
+ },\r
+ {NULL} /* Sentinel */\r
+};\r
+\r
+\r
+PyTypeObject PyNullImporter_Type = {\r
+ PyVarObject_HEAD_INIT(NULL, 0)\r
+ "imp.NullImporter", /*tp_name*/\r
+ sizeof(NullImporter), /*tp_basicsize*/\r
+ 0, /*tp_itemsize*/\r
+ 0, /*tp_dealloc*/\r
+ 0, /*tp_print*/\r
+ 0, /*tp_getattr*/\r
+ 0, /*tp_setattr*/\r
+ 0, /*tp_compare*/\r
+ 0, /*tp_repr*/\r
+ 0, /*tp_as_number*/\r
+ 0, /*tp_as_sequence*/\r
+ 0, /*tp_as_mapping*/\r
+ 0, /*tp_hash */\r
+ 0, /*tp_call*/\r
+ 0, /*tp_str*/\r
+ 0, /*tp_getattro*/\r
+ 0, /*tp_setattro*/\r
+ 0, /*tp_as_buffer*/\r
+ Py_TPFLAGS_DEFAULT, /*tp_flags*/\r
+ "Null importer object", /* tp_doc */\r
+ 0, /* tp_traverse */\r
+ 0, /* tp_clear */\r
+ 0, /* tp_richcompare */\r
+ 0, /* tp_weaklistoffset */\r
+ 0, /* tp_iter */\r
+ 0, /* tp_iternext */\r
+ NullImporter_methods, /* tp_methods */\r
+ 0, /* tp_members */\r
+ 0, /* tp_getset */\r
+ 0, /* tp_base */\r
+ 0, /* tp_dict */\r
+ 0, /* tp_descr_get */\r
+ 0, /* tp_descr_set */\r
+ 0, /* tp_dictoffset */\r
+ (initproc)NullImporter_init, /* tp_init */\r
+ 0, /* tp_alloc */\r
+ PyType_GenericNew /* tp_new */\r
+};\r
+\r
+\r
+PyMODINIT_FUNC\r
+initimp(void)\r
+{\r
+ PyObject *m, *d;\r
+\r
+ if (PyType_Ready(&PyNullImporter_Type) < 0)\r
+ goto failure;\r
+\r
+ m = Py_InitModule4("imp", imp_methods, doc_imp,\r
+ NULL, PYTHON_API_VERSION);\r
+ if (m == NULL)\r
+ goto failure;\r
+ d = PyModule_GetDict(m);\r
+ if (d == NULL)\r
+ goto failure;\r
+\r
+ if (setint(d, "SEARCH_ERROR", SEARCH_ERROR) < 0) goto failure;\r
+ if (setint(d, "PY_SOURCE", PY_SOURCE) < 0) goto failure;\r
+ if (setint(d, "PY_COMPILED", PY_COMPILED) < 0) goto failure;\r
+ if (setint(d, "C_EXTENSION", C_EXTENSION) < 0) goto failure;\r
+ if (setint(d, "PY_RESOURCE", PY_RESOURCE) < 0) goto failure;\r
+ if (setint(d, "PKG_DIRECTORY", PKG_DIRECTORY) < 0) goto failure;\r
+ if (setint(d, "C_BUILTIN", C_BUILTIN) < 0) goto failure;\r
+ if (setint(d, "PY_FROZEN", PY_FROZEN) < 0) goto failure;\r
+ if (setint(d, "PY_CODERESOURCE", PY_CODERESOURCE) < 0) goto failure;\r
+ if (setint(d, "IMP_HOOK", IMP_HOOK) < 0) goto failure;\r
+\r
+ Py_INCREF(&PyNullImporter_Type);\r
+ PyModule_AddObject(m, "NullImporter", (PyObject *)&PyNullImporter_Type);\r
+ failure:\r
+ ;\r
+}\r
+\r
+\r
+/* API for embedding applications that want to add their own entries\r
+ to the table of built-in modules. This should normally be called\r
+ *before* Py_Initialize(). When the table resize fails, -1 is\r
+ returned and the existing table is unchanged.\r
+\r
+ After a similar function by Just van Rossum. */\r
+\r
+int\r
+PyImport_ExtendInittab(struct _inittab *newtab)\r
+{\r
+ static struct _inittab *our_copy = NULL;\r
+ struct _inittab *p;\r
+ int i, n;\r
+\r
+ /* Count the number of entries in both tables */\r
+ for (n = 0; newtab[n].name != NULL; n++)\r
+ ;\r
+ if (n == 0)\r
+ return 0; /* Nothing to do */\r
+ for (i = 0; PyImport_Inittab[i].name != NULL; i++)\r
+ ;\r
+\r
+ /* Allocate new memory for the combined table */\r
+ p = our_copy;\r
+ PyMem_RESIZE(p, struct _inittab, i+n+1);\r
+ if (p == NULL)\r
+ return -1;\r
+\r
+ /* Copy the tables into the new memory */\r
+ if (our_copy != PyImport_Inittab)\r
+ memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab));\r
+ PyImport_Inittab = our_copy = p;\r
+ memcpy(p+i, newtab, (n+1) * sizeof(struct _inittab));\r
+\r
+ return 0;\r
+}\r
+\r
+/* Shorthand to add a single entry given a name and a function */\r
+\r
+int\r
+PyImport_AppendInittab(const char *name, void (*initfunc)(void))\r
+{\r
+ struct _inittab newtab[2];\r
+\r
+ memset(newtab, '\0', sizeof newtab);\r
+\r
+ newtab[0].name = (char *)name;\r
+ newtab[0].initfunc = initfunc;\r
+\r
+ return PyImport_ExtendInittab(newtab);\r
+}\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
Python-$(PYTHON_VERSION)/Modules/zipimport.c #\r
Python-$(PYTHON_VERSION)/Modules/zlibmodule.c #\r
\r
-# Python-$(PYTHON_VERSION)/Modules/_csv.c #\r
-# Python-$(PYTHON_VERSION)/Modules/symtablemodule.c #\r
+ Python-$(PYTHON_VERSION)/Modules/_csv.c #\r
+ Python-$(PYTHON_VERSION)/Modules/symtablemodule.c #\r
\r
#Modules/cjkcodecs\r
Python-$(PYTHON_VERSION)/Modules/cjkcodecs/multibytecodec.c #\r
[BuildOptions]\r
MSFT:*_*_IA32_CC_FLAGS = /Oi- /wd4018 /wd4054 /wd4055 /wd4101 /wd4131 /wd4152 /wd4204 /wd4210 /wd4244 /wd4267 /wd4305 /wd4310 /wd4389 /wd4701 /wd4702 /wd4706 /I$(WORKSPACE)\AppPkg\Applications\Python\Ia32 /I$(WORKSPACE)\AppPkg\Applications\Python\Efi /I$(WORKSPACE)\AppPkg\Applications\Python\Python-$(PYTHON_VERSION)\Include\r
MSFT:*_*_X64_CC_FLAGS = /Oi- /wd4018 /wd4054 /wd4055 /wd4101 /wd4131 /wd4152 /wd4204 /wd4210 /wd4244 /wd4267 /wd4305 /wd4310 /wd4389 /wd4701 /wd4702 /wd4706 /I$(WORKSPACE)\AppPkg\Applications\Python\X64 /I$(WORKSPACE)\AppPkg\Applications\Python\Efi /I$(WORKSPACE)\AppPkg\Applications\Python\Python-$(PYTHON_VERSION)\Include\r
+ GCC:*_*_IA32_CC_FLAGS = -fno-builtin -Wno-format -I$(WORKSPACE)/AppPkg/Applications/Python/Ia32 -I$(WORKSPACE)/AppPkg/Applications/Python/Python-$(PYTHON_VERSION)/Include\r
+ GCC:*_*_X64_CC_FLAGS = -Wno-format -I$(WORKSPACE)/AppPkg/Applications/Python/X64 -I$(WORKSPACE)/AppPkg/Applications/Python/Python-$(PYTHON_VERSION)/Include\r
GCC:*_*_IPF_SYMRENAME_FLAGS = --redefine-syms=$(WORKSPACE)/StdLib/GccSymRename.txt\r
1) There is no input line editing. Backspace, ^C, etc. do not work.\r
2) All C extension modules must be statically linked (built in)\r
3) The site and os modules must exist as discrete files in ...\lib\python.27\r
+ 4) User-specific configurations are not supported.\r
+ 5) Environment variables are not supported.\r
\r
3. Getting and Building the latest version of Python\r
======================================================\r
function accepting a varying number of arguments, if access to the varying\r
arguments is desired.\r
\r
- Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials are licensed and made available under\r
the terms and conditions of the BSD License that accompanies this distribution.\r
The full text of the license may be found at\r
#endif\r
/*@}*/\r
\r
+/** Provide a generic version of the compiler-dependent __va_copy macro.\r
+ Some software, such as Python 2.7.2, relies upon the existence of __va_copy.\r
+ If this macro is not defined, it just assigns one va_list item to another.\r
+ This breaks for compiler environments that define va_list as an array or structure.\r
+**/\r
+#ifndef __va_copy\r
+ #define __va_copy va_copy\r
+#endif\r
+\r
#endif /* _STDARG_H */\r
projects / mirror_edk2.git / commitdiff