From: Robert Bradshaw <robertwb@math.washington.edu>
Date: Tue, 26 Jan 2010 06:47:09 +0000 (-0800)
Subject: INLINE -> CYTHON_INLINE to avoid conflicts
X-Git-Tag: 0.12.1~9
X-Git-Url: http://git.tremily.us/?a=commitdiff_plain;h=3dfaebdb8fc89c31f0c78724cbbea184e3f7083e;p=cython.git

INLINE -> CYTHON_INLINE to avoid conflicts
---

diff --git a/Cython/Compiler/Buffer.py b/Cython/Compiler/Buffer.py
index e807d428..98535dee 100644
--- a/Cython/Compiler/Buffer.py
+++ b/Cython/Compiler/Buffer.py
@@ -446,9 +446,9 @@ def buf_lookup_full_code(proto, defin, name, nd):
     proto.putln("#define %s(type, buf, %s) (type)(%s_imp(buf, %s))" % (name, macroargs, name, macroargs))
 
     funcargs = ", ".join(["Py_ssize_t i%d, Py_ssize_t s%d, Py_ssize_t o%d" % (i, i, i) for i in range(nd)])
-    proto.putln("static INLINE void* %s_imp(void* buf, %s);" % (name, funcargs))
+    proto.putln("static CYTHON_INLINE void* %s_imp(void* buf, %s);" % (name, funcargs))
     defin.putln(dedent("""
-        static INLINE void* %s_imp(void* buf, %s) {
+        static CYTHON_INLINE void* %s_imp(void* buf, %s) {
           char* ptr = (char*)buf;
         """) % (name, funcargs) + "".join([dedent("""\
           ptr += s%d * i%d;
@@ -723,10 +723,10 @@ typedef struct {
 } __Pyx_BufFmt_StackElem;
 
 
-static INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info);
+static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info);
 static int __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack);
 """, impl="""
-static INLINE int __Pyx_IsLittleEndian(void) {
+static CYTHON_INLINE int __Pyx_IsLittleEndian(void) {
   unsigned int n = 1;
   return *(unsigned char*)(&n) != 0;
 }
@@ -1123,7 +1123,7 @@ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const cha
   }
 }
 
-static INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) {
+static CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) {
   buf->buf = NULL;
   buf->obj = NULL;
   buf->strides = __Pyx_zeros;
@@ -1164,7 +1164,7 @@ fail:;
   return -1;
 }
 
-static INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) {
+static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) {
   if (info->buf == NULL) return;
   if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL;
   __Pyx_ReleaseBuffer(info);
diff --git a/Cython/Compiler/Builtin.py b/Cython/Compiler/Builtin.py
index 6f033d1d..b0ad215e 100644
--- a/Cython/Compiler/Builtin.py
+++ b/Cython/Compiler/Builtin.py
@@ -294,19 +294,19 @@ proto = """
 #define PySet_Pop(set) \\
     PyObject_CallMethod(set, (char *)"pop", NULL)
 
-static INLINE int PySet_Clear(PyObject *set) {
+static CYTHON_INLINE int PySet_Clear(PyObject *set) {
     PyObject *ret = PyObject_CallMethod(set, (char *)"clear", NULL);
     if (!ret) return -1;
     Py_DECREF(ret); return 0;
 }
 
-static INLINE int PySet_Discard(PyObject *set, PyObject *key) {
+static CYTHON_INLINE int PySet_Discard(PyObject *set, PyObject *key) {
     PyObject *ret = PyObject_CallMethod(set, (char *)"discard", (char *)"O", key);
     if (!ret) return -1;
     Py_DECREF(ret); return 0;
 }
 
-static INLINE int PySet_Add(PyObject *set, PyObject *key) {
+static CYTHON_INLINE int PySet_Add(PyObject *set, PyObject *key) {
     PyObject *ret = PyObject_CallMethod(set, (char *)"add", (char *)"O", key);
     if (!ret) return -1;
     Py_DECREF(ret); return 0;
diff --git a/Cython/Compiler/ExprNodes.py b/Cython/Compiler/ExprNodes.py
index 625d16af..6ee591af 100644
--- a/Cython/Compiler/ExprNodes.py
+++ b/Cython/Compiler/ExprNodes.py
@@ -5385,8 +5385,8 @@ class CmpNode(object):
     
 contians_utility_code = UtilityCode(
 proto="""
-static INLINE long __Pyx_NegateNonNeg(long b) { return unlikely(b < 0) ? b : !b; }
-static INLINE PyObject* __Pyx_PyBoolOrNull_FromLong(long b) {
+static CYTHON_INLINE long __Pyx_NegateNonNeg(long b) { return unlikely(b < 0) ? b : !b; }
+static CYTHON_INLINE PyObject* __Pyx_PyBoolOrNull_FromLong(long b) {
     return unlikely(b < 0) ? NULL : __Pyx_PyBool_FromLong(b);
 }
 """)
@@ -6113,10 +6113,10 @@ bad:
 
 type_test_utility_code = UtilityCode(
 proto = """
-static INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /*proto*/
+static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /*proto*/
 """,
 impl = """
-static INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
+static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
     if (unlikely(!type)) {
         PyErr_Format(PyExc_SystemError, "Missing type object");
         return 0;
@@ -6197,7 +6197,7 @@ impl = ""
 getitem_int_utility_code = UtilityCode(
 proto = """
 
-static INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
     PyObject *r;
     if (!j) return NULL;
     r = PyObject_GetItem(o, j);
@@ -6211,7 +6211,7 @@ static INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
                                                     __Pyx_GetItemInt_%(type)s_Fast(o, i, size <= sizeof(long)) : \\
                                                     __Pyx_GetItemInt_Generic(o, to_py_func(i)))
 
-static INLINE PyObject *__Pyx_GetItemInt_%(type)s_Fast(PyObject *o, Py_ssize_t i, int fits_long) {
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_%(type)s_Fast(PyObject *o, Py_ssize_t i, int fits_long) {
     if (likely(o != Py_None)) {
         if (likely((0 <= i) & (i < Py%(type)s_GET_SIZE(o)))) {
             PyObject *r = Py%(type)s_GET_ITEM(o, i);
@@ -6233,7 +6233,7 @@ static INLINE PyObject *__Pyx_GetItemInt_%(type)s_Fast(PyObject *o, Py_ssize_t i
                                                     __Pyx_GetItemInt_Fast(o, i, size <= sizeof(long)) : \\
                                                     __Pyx_GetItemInt_Generic(o, to_py_func(i)))
 
-static INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int fits_long) {
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int fits_long) {
     PyObject *r;
     if (PyList_CheckExact(o) && ((0 <= i) & (i < PyList_GET_SIZE(o)))) {
         r = PyList_GET_ITEM(o, i);
@@ -6265,7 +6265,7 @@ proto = """
                                                     __Pyx_SetItemInt_Fast(o, i, v, size <= sizeof(long)) : \\
                                                     __Pyx_SetItemInt_Generic(o, to_py_func(i), v))
 
-static INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
+static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
     int r;
     if (!j) return -1;
     r = PyObject_SetItem(o, j, v);
@@ -6273,7 +6273,7 @@ static INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v
     return r;
 }
 
-static INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int fits_long) {
+static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int fits_long) {
     if (PyList_CheckExact(o) && ((0 <= i) & (i < PyList_GET_SIZE(o)))) {
         Py_INCREF(v);
         Py_DECREF(PyList_GET_ITEM(o, i));
@@ -6299,7 +6299,7 @@ proto = """
                                                     __Pyx_DelItemInt_Fast(o, i, size <= sizeof(long)) : \\
                                                     __Pyx_DelItem_Generic(o, to_py_func(i)))
 
-static INLINE int __Pyx_DelItem_Generic(PyObject *o, PyObject *j) {
+static CYTHON_INLINE int __Pyx_DelItem_Generic(PyObject *o, PyObject *j) {
     int r;
     if (!j) return -1;
     r = PyObject_DelItem(o, j);
@@ -6307,7 +6307,7 @@ static INLINE int __Pyx_DelItem_Generic(PyObject *o, PyObject *j) {
     return r;
 }
 
-static INLINE int __Pyx_DelItemInt_Fast(PyObject *o, Py_ssize_t i, int fits_long) {
+static CYTHON_INLINE int __Pyx_DelItemInt_Fast(PyObject *o, Py_ssize_t i, int fits_long) {
     if (Py_TYPE(o)->tp_as_sequence && Py_TYPE(o)->tp_as_sequence->sq_ass_item && likely(i >= 0))
         return PySequence_DelItem(o, i);
     else {
@@ -6323,50 +6323,50 @@ impl = """
 
 raise_noneattr_error_utility_code = UtilityCode(
 proto = """
-static INLINE void __Pyx_RaiseNoneAttributeError(const char* attrname);
+static CYTHON_INLINE void __Pyx_RaiseNoneAttributeError(const char* attrname);
 """,
 impl = '''
-static INLINE void __Pyx_RaiseNoneAttributeError(const char* attrname) {
+static CYTHON_INLINE void __Pyx_RaiseNoneAttributeError(const char* attrname) {
     PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", attrname);
 }
 ''')
 
 raise_noneindex_error_utility_code = UtilityCode(
 proto = """
-static INLINE void __Pyx_RaiseNoneIndexingError(void);
+static CYTHON_INLINE void __Pyx_RaiseNoneIndexingError(void);
 """,
 impl = '''
-static INLINE void __Pyx_RaiseNoneIndexingError(void) {
+static CYTHON_INLINE void __Pyx_RaiseNoneIndexingError(void) {
     PyErr_SetString(PyExc_TypeError, "'NoneType' object is unsubscriptable");
 }
 ''')
 
 raise_none_iter_error_utility_code = UtilityCode(
 proto = """
-static INLINE void __Pyx_RaiseNoneNotIterableError(void);
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
 """,
 impl = '''
-static INLINE void __Pyx_RaiseNoneNotIterableError(void) {
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
     PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
 }
 ''')
 
 raise_too_many_values_to_unpack = UtilityCode(
 proto = """
-static INLINE void __Pyx_RaiseTooManyValuesError(void);
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(void);
 """,
 impl = '''
-static INLINE void __Pyx_RaiseTooManyValuesError(void) {
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(void) {
     PyErr_SetString(PyExc_ValueError, "too many values to unpack");
 }
 ''')
 
 raise_need_more_values_to_unpack = UtilityCode(
 proto = """
-static INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
 """,
 impl = '''
-static INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
     PyErr_Format(PyExc_ValueError,
         #if PY_VERSION_HEX < 0x02050000
                  "need more than %d value%s to unpack", (int)index,
@@ -6464,10 +6464,10 @@ static PyObject* __Pyx_PyEval_CallObjectWithKeywords(PyObject *callable, PyObjec
 
 int_pow_utility_code = UtilityCode(
 proto="""
-static INLINE %(type)s %(func_name)s(%(type)s, %(type)s); /* proto */
+static CYTHON_INLINE %(type)s %(func_name)s(%(type)s, %(type)s); /* proto */
 """,
 impl="""
-static INLINE %(type)s %(func_name)s(%(type)s b, %(type)s e) {
+static CYTHON_INLINE %(type)s %(func_name)s(%(type)s b, %(type)s e) {
     %(type)s t = b;
     switch (e) {
         case 3:
@@ -6494,10 +6494,10 @@ static INLINE %(type)s %(func_name)s(%(type)s b, %(type)s e) {
 
 div_int_utility_code = UtilityCode(
 proto="""
-static INLINE %(type)s __Pyx_div_%(type_name)s(%(type)s, %(type)s); /* proto */
+static CYTHON_INLINE %(type)s __Pyx_div_%(type_name)s(%(type)s, %(type)s); /* proto */
 """,
 impl="""
-static INLINE %(type)s __Pyx_div_%(type_name)s(%(type)s a, %(type)s b) {
+static CYTHON_INLINE %(type)s __Pyx_div_%(type_name)s(%(type)s a, %(type)s b) {
     %(type)s q = a / b;
     %(type)s r = a - q*b;
     q -= ((r != 0) & ((r ^ b) < 0));
@@ -6507,10 +6507,10 @@ static INLINE %(type)s __Pyx_div_%(type_name)s(%(type)s a, %(type)s b) {
 
 mod_int_utility_code = UtilityCode(
 proto="""
-static INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s, %(type)s); /* proto */
+static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s, %(type)s); /* proto */
 """,
 impl="""
-static INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s a, %(type)s b) {
+static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s a, %(type)s b) {
     %(type)s r = a %% b;
     r += ((r != 0) & ((r ^ b) < 0)) * b;
     return r;
@@ -6519,10 +6519,10 @@ static INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s a, %(type)s b) {
 
 mod_float_utility_code = UtilityCode(
 proto="""
-static INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s, %(type)s); /* proto */
+static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s, %(type)s); /* proto */
 """,
 impl="""
-static INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s a, %(type)s b) {
+static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s a, %(type)s b) {
     %(type)s r = fmod%(math_h_modifier)s(a, b);
     r += ((r != 0) & ((r < 0) ^ (b < 0))) * b;
     return r;
diff --git a/Cython/Compiler/ModuleNode.py b/Cython/Compiler/ModuleNode.py
index 5a45ad71..27e32f5b 100644
--- a/Cython/Compiler/ModuleNode.py
+++ b/Cython/Compiler/ModuleNode.py
@@ -2111,10 +2111,10 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
 
 streq_utility_code = UtilityCode(
 proto = """
-static INLINE int __Pyx_StrEq(const char *, const char *); /*proto*/
+static CYTHON_INLINE int __Pyx_StrEq(const char *, const char *); /*proto*/
 """,
 impl = """
-static INLINE int __Pyx_StrEq(const char *s1, const char *s2) {
+static CYTHON_INLINE int __Pyx_StrEq(const char *s1, const char *s2) {
      while (*s1 != '\\0' && *s1 == *s2) { s1++; s2++; }
      return *s1 == *s2;
 }
diff --git a/Cython/Compiler/Nodes.py b/Cython/Compiler/Nodes.py
index 723c975a..071c3ae0 100644
--- a/Cython/Compiler/Nodes.py
+++ b/Cython/Compiler/Nodes.py
@@ -1463,6 +1463,8 @@ class CFuncDefNode(FuncDefNode):
             storage_class = ""
         else:
             storage_class = "static "
+        if 'inline' in self.modifiers:
+            self.modifiers[self.modifiers.index('inline')] = 'cython_inline'
         code.putln("%s%s %s {" % (
             storage_class,
             ' '.join(self.modifiers).upper(), # macro forms 
@@ -4815,13 +4817,13 @@ class FromImportStatNode(StatNode):
 
 utility_function_predeclarations = \
 """
-#ifndef INLINE
+#ifndef CYTHON_INLINE
   #if defined(__GNUC__)
-    #define INLINE __inline__
+    #define CYTHON_INLINE __inline__
   #elif defined(_MSC_VER)
-    #define INLINE __inline
+    #define CYTHON_INLINE __inline
   #else
-    #define INLINE 
+    #define CYTHON_INLINE 
   #endif
 #endif
 
@@ -5009,11 +5011,11 @@ requires=[printing_utility_code])
 
 restore_exception_utility_code = UtilityCode(
 proto = """
-static INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
-static INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
+static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
+static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
 """,
 impl = """
-static INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) {
+static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) {
     PyObject *tmp_type, *tmp_value, *tmp_tb;
     PyThreadState *tstate = PyThreadState_GET();
 
@@ -5028,7 +5030,7 @@ static INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *t
     Py_XDECREF(tmp_tb);
 }
 
-static INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) {
+static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) {
     PyThreadState *tstate = PyThreadState_GET();
     *type = tstate->curexc_type;
     *value = tstate->curexc_value;
@@ -5248,11 +5250,11 @@ requires=[get_exception_utility_code])
 
 reset_exception_utility_code = UtilityCode(
 proto = """
-static INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
+static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
 static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
 """,
 impl = """
-static INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb) {
+static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb) {
     PyThreadState *tstate = PyThreadState_GET();
     *type = tstate->exc_type;
     *value = tstate->exc_value;
@@ -5351,10 +5353,10 @@ static void __Pyx_RaiseArgtupleInvalid(
 
 raise_keyword_required_utility_code = UtilityCode(
 proto = """
-static INLINE void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name); /*proto*/
+static CYTHON_INLINE void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name); /*proto*/
 """,
 impl = """
-static INLINE void __Pyx_RaiseKeywordRequired(
+static CYTHON_INLINE void __Pyx_RaiseKeywordRequired(
     const char* func_name,
     PyObject* kw_name)
 {
@@ -5396,11 +5398,11 @@ static void __Pyx_RaiseDoubleKeywordsError(
 
 keyword_string_check_utility_code = UtilityCode(
 proto = """
-static INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict,
+static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict,
     const char* function_name, int kw_allowed); /*proto*/
 """,
 impl = """
-static INLINE int __Pyx_CheckKeywordStrings(
+static CYTHON_INLINE int __Pyx_CheckKeywordStrings(
     PyObject *kwdict,
     const char* function_name,
     int kw_allowed)
diff --git a/Cython/Compiler/Optimize.py b/Cython/Compiler/Optimize.py
index d7fdf39b..a5b1378f 100644
--- a/Cython/Compiler/Optimize.py
+++ b/Cython/Compiler/Optimize.py
@@ -1583,7 +1583,7 @@ class OptimizeBuiltinCalls(Visitor.EnvTransform):
 
 append_utility_code = UtilityCode(
 proto = """
-static INLINE PyObject* __Pyx_PyObject_Append(PyObject* L, PyObject* x) {
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Append(PyObject* L, PyObject* x) {
     if (likely(PyList_CheckExact(L))) {
         if (PyList_Append(L, x) < 0) return NULL;
         Py_INCREF(Py_None);
@@ -1605,7 +1605,7 @@ impl = ""
 
 pop_utility_code = UtilityCode(
 proto = """
-static INLINE PyObject* __Pyx_PyObject_Pop(PyObject* L) {
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Pop(PyObject* L) {
     if (likely(PyList_CheckExact(L))
             /* Check that both the size is positive and no reallocation shrinking needs to be done. */
             && likely(PyList_GET_SIZE(L) > (((PyListObject*)L)->allocated >> 1))) {
@@ -1721,7 +1721,7 @@ proto = """
 
 tpnew_utility_code = UtilityCode(
 proto = """
-static INLINE PyObject* __Pyx_tp_new(PyObject* type_obj) {
+static CYTHON_INLINE PyObject* __Pyx_tp_new(PyObject* type_obj) {
     return (PyObject*) (((PyTypeObject*)(type_obj))->tp_new(
         (PyTypeObject*)(type_obj), %(TUPLE)s, NULL));
 }
diff --git a/Cython/Compiler/PyrexTypes.py b/Cython/Compiler/PyrexTypes.py
index d0f6f0a0..a10a14a2 100644
--- a/Cython/Compiler/PyrexTypes.py
+++ b/Cython/Compiler/PyrexTypes.py
@@ -638,10 +638,10 @@ type_conversion_functions = ""
 
 c_int_from_py_function = UtilityCode(
 proto="""
-static INLINE %(type)s __Pyx_PyInt_As%(SignWord)s%(TypeName)s(PyObject *);
+static CYTHON_INLINE %(type)s __Pyx_PyInt_As%(SignWord)s%(TypeName)s(PyObject *);
 """,
 impl="""
-static INLINE %(type)s __Pyx_PyInt_As%(SignWord)s%(TypeName)s(PyObject* x) {
+static CYTHON_INLINE %(type)s __Pyx_PyInt_As%(SignWord)s%(TypeName)s(PyObject* x) {
     const %(type)s neg_one = (%(type)s)-1, const_zero = 0;
     const int is_unsigned = neg_one > const_zero;
     if (sizeof(%(type)s) < sizeof(long)) {
@@ -663,10 +663,10 @@ static INLINE %(type)s __Pyx_PyInt_As%(SignWord)s%(TypeName)s(PyObject* x) {
 
 c_long_from_py_function = UtilityCode(
 proto="""
-static INLINE %(type)s __Pyx_PyInt_As%(SignWord)s%(TypeName)s(PyObject *);
+static CYTHON_INLINE %(type)s __Pyx_PyInt_As%(SignWord)s%(TypeName)s(PyObject *);
 """,
 impl="""
-static INLINE %(type)s __Pyx_PyInt_As%(SignWord)s%(TypeName)s(PyObject* x) {
+static CYTHON_INLINE %(type)s __Pyx_PyInt_As%(SignWord)s%(TypeName)s(PyObject* x) {
     const %(type)s neg_one = (%(type)s)-1, const_zero = 0;
     const int is_unsigned = neg_one > const_zero;
 #if PY_VERSION_HEX < 0x03000000
@@ -704,10 +704,10 @@ static INLINE %(type)s __Pyx_PyInt_As%(SignWord)s%(TypeName)s(PyObject* x) {
 
 c_typedef_int_from_py_function = UtilityCode(
 proto="""
-static INLINE %(type)s __Pyx_PyInt_from_py_%(TypeName)s(PyObject *);
+static CYTHON_INLINE %(type)s __Pyx_PyInt_from_py_%(TypeName)s(PyObject *);
 """,
 impl="""
-static INLINE %(type)s __Pyx_PyInt_from_py_%(TypeName)s(PyObject* x) {
+static CYTHON_INLINE %(type)s __Pyx_PyInt_from_py_%(TypeName)s(PyObject* x) {
     const %(type)s neg_one = (%(type)s)-1, const_zero = 0;
     const int is_unsigned = neg_one > const_zero;
     if (sizeof(%(type)s) == sizeof(char)) {
@@ -751,10 +751,10 @@ static INLINE %(type)s __Pyx_PyInt_from_py_%(TypeName)s(PyObject* x) {
 
 c_typedef_int_to_py_function = UtilityCode(
 proto="""
-static INLINE PyObject *__Pyx_PyInt_to_py_%(TypeName)s(%(type)s);
+static CYTHON_INLINE PyObject *__Pyx_PyInt_to_py_%(TypeName)s(%(type)s);
 """,
 impl="""
-static INLINE PyObject *__Pyx_PyInt_to_py_%(TypeName)s(%(type)s val) {
+static CYTHON_INLINE PyObject *__Pyx_PyInt_to_py_%(TypeName)s(%(type)s val) {
     const %(type)s neg_one = (%(type)s)-1, const_zero = 0;
     const int is_unsigned = neg_one > const_zero;
     if (sizeof(%(type)s) <  sizeof(long)) {
@@ -1111,21 +1111,21 @@ proto="""
 complex_from_parts_utility_code = UtilityCode(
 proto_block='utility_code_proto',
 proto="""
-static INLINE %(type)s %(type_name)s_from_parts(%(real_type)s, %(real_type)s);
+static CYTHON_INLINE %(type)s %(type_name)s_from_parts(%(real_type)s, %(real_type)s);
 """,
 impl="""
 #if CYTHON_CCOMPLEX
   #ifdef __cplusplus
-    static INLINE %(type)s %(type_name)s_from_parts(%(real_type)s x, %(real_type)s y) {
+    static CYTHON_INLINE %(type)s %(type_name)s_from_parts(%(real_type)s x, %(real_type)s y) {
       return ::std::complex< %(real_type)s >(x, y);
     }
   #else
-    static INLINE %(type)s %(type_name)s_from_parts(%(real_type)s x, %(real_type)s y) {
+    static CYTHON_INLINE %(type)s %(type_name)s_from_parts(%(real_type)s x, %(real_type)s y) {
       return x + y*(%(type)s)_Complex_I;
     }
   #endif
 #else
-    static INLINE %(type)s %(type_name)s_from_parts(%(real_type)s x, %(real_type)s y) {
+    static CYTHON_INLINE %(type)s %(type_name)s_from_parts(%(real_type)s x, %(real_type)s y) {
       %(type)s z;
       z.real = x;
       z.imag = y;
@@ -1177,65 +1177,65 @@ proto="""
     /*#define __Pyx_c_abs%(m)s(z)     (cabs%(m)s(z))*/
  #endif
 #else
-    static INLINE int __Pyx_c_eq%(m)s(%(type)s, %(type)s);
-    static INLINE %(type)s __Pyx_c_sum%(m)s(%(type)s, %(type)s);
-    static INLINE %(type)s __Pyx_c_diff%(m)s(%(type)s, %(type)s);
-    static INLINE %(type)s __Pyx_c_prod%(m)s(%(type)s, %(type)s);
-    static INLINE %(type)s __Pyx_c_quot%(m)s(%(type)s, %(type)s);
-    static INLINE %(type)s __Pyx_c_neg%(m)s(%(type)s);
-    static INLINE int __Pyx_c_is_zero%(m)s(%(type)s);
-    static INLINE %(type)s __Pyx_c_conj%(m)s(%(type)s);
-    /*static INLINE %(real_type)s __Pyx_c_abs%(m)s(%(type)s);*/
+    static CYTHON_INLINE int __Pyx_c_eq%(m)s(%(type)s, %(type)s);
+    static CYTHON_INLINE %(type)s __Pyx_c_sum%(m)s(%(type)s, %(type)s);
+    static CYTHON_INLINE %(type)s __Pyx_c_diff%(m)s(%(type)s, %(type)s);
+    static CYTHON_INLINE %(type)s __Pyx_c_prod%(m)s(%(type)s, %(type)s);
+    static CYTHON_INLINE %(type)s __Pyx_c_quot%(m)s(%(type)s, %(type)s);
+    static CYTHON_INLINE %(type)s __Pyx_c_neg%(m)s(%(type)s);
+    static CYTHON_INLINE int __Pyx_c_is_zero%(m)s(%(type)s);
+    static CYTHON_INLINE %(type)s __Pyx_c_conj%(m)s(%(type)s);
+    /*static CYTHON_INLINE %(real_type)s __Pyx_c_abs%(m)s(%(type)s);*/
 #endif
 """,
 impl="""
 #if CYTHON_CCOMPLEX
 #else
-    static INLINE int __Pyx_c_eq%(m)s(%(type)s a, %(type)s b) {
+    static CYTHON_INLINE int __Pyx_c_eq%(m)s(%(type)s a, %(type)s b) {
        return (a.real == b.real) && (a.imag == b.imag);
     }
-    static INLINE %(type)s __Pyx_c_sum%(m)s(%(type)s a, %(type)s b) {
+    static CYTHON_INLINE %(type)s __Pyx_c_sum%(m)s(%(type)s a, %(type)s b) {
         %(type)s z;
         z.real = a.real + b.real;
         z.imag = a.imag + b.imag;
         return z;
     }
-    static INLINE %(type)s __Pyx_c_diff%(m)s(%(type)s a, %(type)s b) {
+    static CYTHON_INLINE %(type)s __Pyx_c_diff%(m)s(%(type)s a, %(type)s b) {
         %(type)s z;
         z.real = a.real - b.real;
         z.imag = a.imag - b.imag;
         return z;
     }
-    static INLINE %(type)s __Pyx_c_prod%(m)s(%(type)s a, %(type)s b) {
+    static CYTHON_INLINE %(type)s __Pyx_c_prod%(m)s(%(type)s a, %(type)s b) {
         %(type)s z;
         z.real = a.real * b.real - a.imag * b.imag;
         z.imag = a.real * b.imag + a.imag * b.real;
         return z;
     }
-    static INLINE %(type)s __Pyx_c_quot%(m)s(%(type)s a, %(type)s b) {
+    static CYTHON_INLINE %(type)s __Pyx_c_quot%(m)s(%(type)s a, %(type)s b) {
         %(type)s z;
         %(real_type)s denom = b.real * b.real + b.imag * b.imag;
         z.real = (a.real * b.real + a.imag * b.imag) / denom;
         z.imag = (a.imag * b.real - a.real * b.imag) / denom;
         return z;
     }
-    static INLINE %(type)s __Pyx_c_neg%(m)s(%(type)s a) {
+    static CYTHON_INLINE %(type)s __Pyx_c_neg%(m)s(%(type)s a) {
         %(type)s z;
         z.real = -a.real;
         z.imag = -a.imag;
         return z;
     }
-    static INLINE int __Pyx_c_is_zero%(m)s(%(type)s a) {
+    static CYTHON_INLINE int __Pyx_c_is_zero%(m)s(%(type)s a) {
        return (a.real == 0) && (a.imag == 0);
     }
-    static INLINE %(type)s __Pyx_c_conj%(m)s(%(type)s a) {
+    static CYTHON_INLINE %(type)s __Pyx_c_conj%(m)s(%(type)s a) {
         %(type)s z;
         z.real =  a.real;
         z.imag = -a.imag;
         return z;
     }
 /*
-    static INLINE %(real_type)s __Pyx_c_abs%(m)s(%(type)s z) {
+    static CYTHON_INLINE %(real_type)s __Pyx_c_abs%(m)s(%(type)s z) {
 #if HAVE_HYPOT
         return hypot%(m)s(z.real, z.imag);
 #else
@@ -2127,8 +2127,8 @@ type_conversion_predeclarations = """
 #define __Pyx_PyBytes_AsUString(s)        ((unsigned char*) __Pyx_PyBytes_AsString(s))
 
 #define __Pyx_PyBool_FromLong(b) ((b) ? (Py_INCREF(Py_True), Py_True) : (Py_INCREF(Py_False), Py_False))
-static INLINE int __Pyx_PyObject_IsTrue(PyObject*);
-static INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x);
 
 #if !defined(T_PYSSIZET)
 #if PY_VERSION_HEX < 0x02050000
@@ -2192,9 +2192,9 @@ static INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x);
 #endif
 #endif
 
-static INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
-static INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
-static INLINE size_t __Pyx_PyInt_AsSize_t(PyObject*);
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
+static CYTHON_INLINE size_t __Pyx_PyInt_AsSize_t(PyObject*);
 
 #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
 
@@ -2203,13 +2203,13 @@ static INLINE size_t __Pyx_PyInt_AsSize_t(PyObject*);
 type_conversion_functions = """
 /* Type Conversion Functions */
 
-static INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
    if (x == Py_True) return 1;
    else if ((x == Py_False) | (x == Py_None)) return 0;
    else return PyObject_IsTrue(x);
 }
 
-static INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) {
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) {
   PyNumberMethods *m;
   const char *name = NULL;
   PyObject *res = NULL;
@@ -2255,7 +2255,7 @@ static INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) {
   return res;
 }
 
-static INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
   Py_ssize_t ival;
   PyObject* x = PyNumber_Index(b);
   if (!x) return -1;
@@ -2264,7 +2264,7 @@ static INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
   return ival;
 }
 
-static INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 #if PY_VERSION_HEX < 0x02050000
    if (ival <= LONG_MAX)
        return PyInt_FromLong((long)ival);
@@ -2278,7 +2278,7 @@ static INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 #endif
 }
 
-static INLINE size_t __Pyx_PyInt_AsSize_t(PyObject* x) {
+static CYTHON_INLINE size_t __Pyx_PyInt_AsSize_t(PyObject* x) {
    unsigned PY_LONG_LONG val = __Pyx_PyInt_AsUnsignedLongLong(x);
    if (unlikely(val == (unsigned PY_LONG_LONG)-1 && PyErr_Occurred())) {
        return (size_t)-1;