[GR-8776] Use _sre as regex fallback engine.

PullRequest: graalpython/114

Author: fangerer

graalpython/com.oracle.graal.python.cext/include/Python.h

@@ -260,6 +260,9 @@ PyAPI_FUNC(PyObject *) _PyObject_FastCallKeywords(
 #define _PyObject_CallNoArg(func) \
     _PyObject_FastCallDict((func), NULL, 0, NULL)
 
+#define _PyObject_CallArg1(func, arg) \
+    _PyObject_FastCall((func), &(arg), 1)
+
 PyAPI_FUNC(PyObject *) _PyObject_Call_Prepend(
     PyObject *callable,
     PyObject *obj,

graalpython/com.oracle.graal.python.cext/include/abstract.h

@@ -0,0 +1,31 @@
+/* Copyright (c) 2018, Oracle and/or its affiliates.
+ * Copyright (C) 1996-2017 Python Software Foundation
+ *
+ * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+ */
+
+#ifndef Py_ITEROBJECT_H
+#define Py_ITEROBJECT_H
+/* Iterators (the basic kind, over a sequence) */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_DATA(PyTypeObject) PySeqIter_Type;
+PyAPI_DATA(PyTypeObject) PyCallIter_Type;
+PyAPI_DATA(PyTypeObject) PyCmpWrapper_Type;
+
+#define PySeqIter_Check(op) (Py_TYPE(op) == &PySeqIter_Type)
+
+PyAPI_FUNC(PyObject *) PySeqIter_New(PyObject *);
+
+
+#define PyCallIter_Check(op) (Py_TYPE(op) == &PyCallIter_Type)
+
+PyAPI_FUNC(PyObject *) PyCallIter_New(PyObject *, PyObject *);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_ITEROBJECT_H */
+

graalpython/com.oracle.graal.python.cext/include/iterobject.h

@@ -99,7 +99,7 @@ PyAPI_FUNC(long long) PyLong_AsLongLongAndOverflow(PyObject *, int *);
 
 PyAPI_FUNC(PyObject *) PyLong_FromString(const char *, char **, int);
 #ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) PyLong_FromUnicode(Py_UNICODE*, Py_ssize_t, int);
+PyAPI_FUNC(PyObject *) PyLong_FromUnicode(Py_UNICODE*, Py_ssize_t, int) Py_DEPRECATED(3.3);
 PyAPI_FUNC(PyObject *) PyLong_FromUnicodeObject(PyObject *u, int base);
 PyAPI_FUNC(PyObject *) _PyLong_FromBytes(const char *, Py_ssize_t, int);
 #endif
@@ -214,6 +214,11 @@ PyAPI_FUNC(long) PyOS_strtol(const char *, char **, int);
 PyAPI_FUNC(PyObject *) _PyLong_GCD(PyObject *, PyObject *);
 #endif /* !Py_LIMITED_API */
 
+#ifndef Py_LIMITED_API
+PyAPI_DATA(PyObject *) _PyLong_Zero;
+PyAPI_DATA(PyObject *) _PyLong_One;
+#endif
+
 #ifdef __cplusplus
 }
 #endif

graalpython/com.oracle.graal.python.cext/include/longobject.h

@@ -103,11 +103,8 @@ typedef struct _PyArg_Parser {
 #endif
 PyAPI_FUNC(int) _PyArg_ParseTupleAndKeywordsFast(PyObject *, PyObject *,
                                                  struct _PyArg_Parser *, ...);
-PyAPI_FUNC(int) _PyArg_ParseStack(
-    PyObject *const *args,
-    Py_ssize_t nargs,
-    const char *format,
-    ...);
+PyAPI_FUNC(int) _PyArg_ParseStack(PyObject **args, Py_ssize_t nargs, PyObject *kwnames,
+                                  struct _PyArg_Parser *, ...);
 PyAPI_FUNC(int) _PyArg_ParseStackAndKeywords(
     PyObject *const *args,
     Py_ssize_t nargs,

graalpython/com.oracle.graal.python.cext/include/modsupport.h

@@ -297,33 +297,36 @@ extern PyGC_Head *_PyGC_generation0;
 
 /* Tell the GC to track this object.  NB: While the object is tracked the
  * collector it must be safe to call the ob_traverse method. */
-#define _PyObject_GC_TRACK(o) do { \
-    PyGC_Head *g = _Py_AS_GC(o); \
-    if (_PyGCHead_REFS(g) != _PyGC_REFS_UNTRACKED) \
-        Py_FatalError("GC object already tracked"); \
-    _PyGCHead_SET_REFS(g, _PyGC_REFS_REACHABLE); \
-    g->gc.gc_next = _PyGC_generation0; \
-    g->gc.gc_prev = _PyGC_generation0->gc.gc_prev; \
-    g->gc.gc_prev->gc.gc_next = g; \
-    _PyGC_generation0->gc.gc_prev = g; \
-    } while (0);
+//#define _PyObject_GC_TRACK(o) do { \
+//    PyGC_Head *g = _Py_AS_GC(o); \
+//    if (_PyGCHead_REFS(g) != _PyGC_REFS_UNTRACKED) \
+//        Py_FatalError("GC object already tracked"); \
+//    _PyGCHead_SET_REFS(g, _PyGC_REFS_REACHABLE); \
+//    g->gc.gc_next = _PyGC_generation0; \
+//    g->gc.gc_prev = _PyGC_generation0->gc.gc_prev; \
+//    g->gc.gc_prev->gc.gc_next = g; \
+//    _PyGC_generation0->gc.gc_prev = g; \
+//    } while (0);
+#define _PyObject_GC_TRACK(o)
 
 /* Tell the GC to stop tracking this object.
  * gc_next doesn't need to be set to NULL, but doing so is a good
  * way to provoke memory errors if calling code is confused.
  */
-#define _PyObject_GC_UNTRACK(o) do { \
-    PyGC_Head *g = _Py_AS_GC(o); \
-    assert(_PyGCHead_REFS(g) != _PyGC_REFS_UNTRACKED); \
-    _PyGCHead_SET_REFS(g, _PyGC_REFS_UNTRACKED); \
-    g->gc.gc_prev->gc.gc_next = g->gc.gc_next; \
-    g->gc.gc_next->gc.gc_prev = g->gc.gc_prev; \
-    g->gc.gc_next = NULL; \
-    } while (0);
+#define _PyObject_GC_UNTRACK(o)
+//#define _PyObject_GC_UNTRACK(o) do { \
+//    PyGC_Head *g = _Py_AS_GC(o); \
+//    assert(_PyGCHead_REFS(g) != _PyGC_REFS_UNTRACKED); \
+//    _PyGCHead_SET_REFS(g, _PyGC_REFS_UNTRACKED); \
+//    g->gc.gc_prev->gc.gc_next = g->gc.gc_next; \
+//    g->gc.gc_next->gc.gc_prev = g->gc.gc_prev; \
+//    g->gc.gc_next = NULL; \
+//    } while (0);
 
 /* True if the object is currently tracked by the GC. */
-#define _PyObject_GC_IS_TRACKED(o) \
-    (_PyGC_REFS(o) != _PyGC_REFS_UNTRACKED)
+#define _PyObject_GC_IS_TRACKED(o) 0
+//#define _PyObject_GC_IS_TRACKED(o) \
+//    (_PyGC_REFS(o) != _PyGC_REFS_UNTRACKED)
 
 /* True if the object may be tracked by the GC in the future, or already is.
    This can be useful to implement some optimizations. */