STY: f2py - replace macros in old_defines.h with new.

8 files changed, 123 insertions, 123 deletions

diff --git a/numpy/f2py/capi_maps.py b/numpy/f2py/capi_maps.py
index beff1e212..7fd1179c3 100644
--- a/numpy/f2py/capi_maps.py
+++ b/numpy/f2py/capi_maps.py
@@ -49,45 +49,45 @@ c2py_map={'double':'float',
           'complex_long_double':'complex',          # forced casting
           'string':'string',
           }
-c2capi_map={'double':'PyArray_DOUBLE',
-            'float':'PyArray_FLOAT',
-            'long_double':'PyArray_DOUBLE',           # forced casting
-            'char':'PyArray_CHAR',
-            'unsigned_char':'PyArray_UBYTE',
-            'signed_char':'PyArray_SBYTE',
-            'short':'PyArray_SHORT',
-            'unsigned_short':'PyArray_USHORT',
-            'int':'PyArray_INT',
-            'unsigned':'PyArray_UINT',
-            'long':'PyArray_LONG',
-            'long_long':'PyArray_LONG',                # forced casting
-            'complex_float':'PyArray_CFLOAT',
-            'complex_double':'PyArray_CDOUBLE',
-            'complex_long_double':'PyArray_CDOUBLE',   # forced casting
-            'string':'PyArray_CHAR'}
+c2capi_map={'double':'NPY_DOUBLE',
+            'float':'NPY_FLOAT',
+            'long_double':'NPY_DOUBLE',           # forced casting
+            'char':'NPY_CHAR',
+            'unsigned_char':'NPY_UBYTE',
+            'signed_char':'NPY_BYTE',
+            'short':'NPY_SHORT',
+            'unsigned_short':'NPY_USHORT',
+            'int':'NPY_INT',
+            'unsigned':'NPY_UINT',
+            'long':'NPY_LONG',
+            'long_long':'NPY_LONG',                # forced casting
+            'complex_float':'NPY_CFLOAT',
+            'complex_double':'NPY_CDOUBLE',
+            'complex_long_double':'NPY_CDOUBLE',   # forced casting
+            'string':'NPY_CHAR'}
 
 #These new maps aren't used anyhere yet, but should be by default
 #  unless building numeric or numarray extensions.
 if using_newcore:
-    c2capi_map={'double':'PyArray_DOUBLE',
-            'float':'PyArray_FLOAT',
-            'long_double':'PyArray_LONGDOUBLE',
-            'char':'PyArray_BYTE',
-            'unsigned_char':'PyArray_UBYTE',
-            'signed_char':'PyArray_BYTE',
-            'short':'PyArray_SHORT',
-            'unsigned_short':'PyArray_USHORT',
-            'int':'PyArray_INT',
-            'unsigned':'PyArray_UINT',
-            'long':'PyArray_LONG',
-            'unsigned_long':'PyArray_ULONG',
-            'long_long':'PyArray_LONGLONG',
-            'unsigned_long_long':'Pyarray_ULONGLONG',
-            'complex_float':'PyArray_CFLOAT',
-            'complex_double':'PyArray_CDOUBLE',
-            'complex_long_double':'PyArray_CDOUBLE',
-            'string':'PyArray_CHAR', # f2py 2e is not ready for PyArray_STRING (must set itemisize etc)
-            #'string':'PyArray_STRING'
+    c2capi_map={'double':'NPY_DOUBLE',
+            'float':'NPY_FLOAT',
+            'long_double':'NPY_LONGDOUBLE',
+            'char':'NPY_BYTE',
+            'unsigned_char':'NPY_UBYTE',
+            'signed_char':'NPY_BYTE',
+            'short':'NPY_SHORT',
+            'unsigned_short':'NPY_USHORT',
+            'int':'NPY_INT',
+            'unsigned':'NPY_UINT',
+            'long':'NPY_LONG',
+            'unsigned_long':'NPY_ULONG',
+            'long_long':'NPY_LONGLONG',
+            'unsigned_long_long':'NPY_ULONGLONG',
+            'complex_float':'NPY_CFLOAT',
+            'complex_double':'NPY_CDOUBLE',
+            'complex_long_double':'NPY_CDOUBLE',
+            'string':'NPY_CHAR', # f2py 2e is not ready for NPY_STRING (must set itemisize etc)
+            #'string':'NPY_STRING'
 
                 }
 c2pycode_map={'double':'d',
diff --git a/numpy/f2py/cfuncs.py b/numpy/f2py/cfuncs.py
index 9410a9f27..4956e5740 100644
--- a/numpy/f2py/cfuncs.py
+++ b/numpy/f2py/cfuncs.py
@@ -316,9 +316,9 @@ cppmacros['pyobj_from_string1size']='#define pyobj_from_string1size(v,len) (PySt
 needs['TRYPYARRAYTEMPLATE']=['PRINTPYOBJERR']
 cppmacros['TRYPYARRAYTEMPLATE']="""\
 /* New SciPy */
-#define TRYPYARRAYTEMPLATECHAR case PyArray_STRING: *(char *)(arr->data)=*v; break;
-#define TRYPYARRAYTEMPLATELONG case PyArray_LONG: *(long *)(arr->data)=*v; break;
-#define TRYPYARRAYTEMPLATEOBJECT case PyArray_OBJECT: (arr->descr->f->setitem)(pyobj_from_ ## ctype ## 1(*v),arr->data); break;
+#define TRYPYARRAYTEMPLATECHAR case NPY_STRING: *(char *)(arr->data)=*v; break;
+#define TRYPYARRAYTEMPLATELONG case NPY_LONG: *(long *)(arr->data)=*v; break;
+#define TRYPYARRAYTEMPLATEOBJECT case NPY_OBJECT: (arr->descr->f->setitem)(pyobj_from_ ## ctype ## 1(*v),arr->data); break;
 
 #define TRYPYARRAYTEMPLATE(ctype,typecode) \\
         PyArrayObject *arr = NULL;\\
@@ -327,24 +327,24 @@ cppmacros['TRYPYARRAYTEMPLATE']="""\
         if (!(arr=(PyArrayObject *)obj)) {fprintf(stderr,\"TRYPYARRAYTEMPLATE:\");PRINTPYOBJERR(obj);return 0;}\\
         if (arr->descr->type==typecode)  {*(ctype *)(arr->data)=*v; return 1;}\\
         switch (arr->descr->type_num) {\\
-                case PyArray_DOUBLE: *(double *)(arr->data)=*v; break;\\
-                case PyArray_INT: *(int *)(arr->data)=*v; break;\\
-                case PyArray_LONG: *(long *)(arr->data)=*v; break;\\
-                case PyArray_FLOAT: *(float *)(arr->data)=*v; break;\\
-                case PyArray_CDOUBLE: *(double *)(arr->data)=*v; break;\\
-                case PyArray_CFLOAT: *(float *)(arr->data)=*v; break;\\
-                case PyArray_BOOL: *(npy_bool *)(arr->data)=(*v!=0); break;\\
-                case PyArray_UBYTE: *(unsigned char *)(arr->data)=*v; break;\\
-                case PyArray_BYTE: *(signed char *)(arr->data)=*v; break;\\
-                case PyArray_SHORT: *(short *)(arr->data)=*v; break;\\
-                case PyArray_USHORT: *(npy_ushort *)(arr->data)=*v; break;\\
-                case PyArray_UINT: *(npy_uint *)(arr->data)=*v; break;\\
-                case PyArray_ULONG: *(npy_ulong *)(arr->data)=*v; break;\\
-                case PyArray_LONGLONG: *(npy_longlong *)(arr->data)=*v; break;\\
-                case PyArray_ULONGLONG: *(npy_ulonglong *)(arr->data)=*v; break;\\
-                case PyArray_LONGDOUBLE: *(npy_longdouble *)(arr->data)=*v; break;\\
-                case PyArray_CLONGDOUBLE: *(npy_longdouble *)(arr->data)=*v; break;\\
-                case PyArray_OBJECT: (arr->descr->f->setitem)(pyobj_from_ ## ctype ## 1(*v),arr->data, arr); break;\\
+                case NPY_DOUBLE: *(double *)(arr->data)=*v; break;\\
+                case NPY_INT: *(int *)(arr->data)=*v; break;\\
+                case NPY_LONG: *(long *)(arr->data)=*v; break;\\
+                case NPY_FLOAT: *(float *)(arr->data)=*v; break;\\
+                case NPY_CDOUBLE: *(double *)(arr->data)=*v; break;\\
+                case NPY_CFLOAT: *(float *)(arr->data)=*v; break;\\
+                case NPY_BOOL: *(npy_bool *)(arr->data)=(*v!=0); break;\\
+                case NPY_UBYTE: *(unsigned char *)(arr->data)=*v; break;\\
+                case NPY_BYTE: *(signed char *)(arr->data)=*v; break;\\
+                case NPY_SHORT: *(short *)(arr->data)=*v; break;\\
+                case NPY_USHORT: *(npy_ushort *)(arr->data)=*v; break;\\
+                case NPY_UINT: *(npy_uint *)(arr->data)=*v; break;\\
+                case NPY_ULONG: *(npy_ulong *)(arr->data)=*v; break;\\
+                case NPY_LONGLONG: *(npy_longlong *)(arr->data)=*v; break;\\
+                case NPY_ULONGLONG: *(npy_ulonglong *)(arr->data)=*v; break;\\
+                case NPY_LONGDOUBLE: *(npy_longdouble *)(arr->data)=*v; break;\\
+                case NPY_CLONGDOUBLE: *(npy_longdouble *)(arr->data)=*v; break;\\
+                case NPY_OBJECT: (arr->descr->f->setitem)(pyobj_from_ ## ctype ## 1(*v),arr->data, arr); break;\\
         default: return -2;\\
         };\\
         return 1
@@ -352,7 +352,7 @@ cppmacros['TRYPYARRAYTEMPLATE']="""\
 
 needs['TRYCOMPLEXPYARRAYTEMPLATE']=['PRINTPYOBJERR']
 cppmacros['TRYCOMPLEXPYARRAYTEMPLATE']="""\
-#define TRYCOMPLEXPYARRAYTEMPLATEOBJECT case PyArray_OBJECT: (arr->descr->f->setitem)(pyobj_from_complex_ ## ctype ## 1((*v)),arr->data, arr); break;
+#define TRYCOMPLEXPYARRAYTEMPLATEOBJECT case NPY_OBJECT: (arr->descr->f->setitem)(pyobj_from_complex_ ## ctype ## 1((*v)),arr->data, arr); break;
 #define TRYCOMPLEXPYARRAYTEMPLATE(ctype,typecode)\\
         PyArrayObject *arr = NULL;\\
         if (!obj) return -2;\\
@@ -364,24 +364,24 @@ cppmacros['TRYCOMPLEXPYARRAYTEMPLATE']="""\
             return 1;\\
         }\\
         switch (arr->descr->type_num) {\\
-                case PyArray_CDOUBLE: *(double *)(arr->data)=(*v).r;*(double *)(arr->data+sizeof(double))=(*v).i;break;\\
-                case PyArray_CFLOAT: *(float *)(arr->data)=(*v).r;*(float *)(arr->data+sizeof(float))=(*v).i;break;\\
-                case PyArray_DOUBLE: *(double *)(arr->data)=(*v).r; break;\\
-                case PyArray_LONG: *(long *)(arr->data)=(*v).r; break;\\
-                case PyArray_FLOAT: *(float *)(arr->data)=(*v).r; break;\\
-                case PyArray_INT: *(int *)(arr->data)=(*v).r; break;\\
-                case PyArray_SHORT: *(short *)(arr->data)=(*v).r; break;\\
-                case PyArray_UBYTE: *(unsigned char *)(arr->data)=(*v).r; break;\\
-                case PyArray_BYTE: *(signed char *)(arr->data)=(*v).r; break;\\
-                case PyArray_BOOL: *(npy_bool *)(arr->data)=((*v).r!=0 && (*v).i!=0); break;\\
-                case PyArray_USHORT: *(npy_ushort *)(arr->data)=(*v).r; break;\\
-                case PyArray_UINT: *(npy_uint *)(arr->data)=(*v).r; break;\\
-                case PyArray_ULONG: *(npy_ulong *)(arr->data)=(*v).r; break;\\
-                case PyArray_LONGLONG: *(npy_longlong *)(arr->data)=(*v).r; break;\\
-                case PyArray_ULONGLONG: *(npy_ulonglong *)(arr->data)=(*v).r; break;\\
-                case PyArray_LONGDOUBLE: *(npy_longdouble *)(arr->data)=(*v).r; break;\\
-                case PyArray_CLONGDOUBLE: *(npy_longdouble *)(arr->data)=(*v).r;*(npy_longdouble *)(arr->data+sizeof(npy_longdouble))=(*v).i;break;\\
-                case PyArray_OBJECT: (arr->descr->f->setitem)(pyobj_from_complex_ ## ctype ## 1((*v)),arr->data, arr); break;\\
+                case NPY_CDOUBLE: *(double *)(arr->data)=(*v).r;*(double *)(arr->data+sizeof(double))=(*v).i;break;\\
+                case NPY_CFLOAT: *(float *)(arr->data)=(*v).r;*(float *)(arr->data+sizeof(float))=(*v).i;break;\\
+                case NPY_DOUBLE: *(double *)(arr->data)=(*v).r; break;\\
+                case NPY_LONG: *(long *)(arr->data)=(*v).r; break;\\
+                case NPY_FLOAT: *(float *)(arr->data)=(*v).r; break;\\
+                case NPY_INT: *(int *)(arr->data)=(*v).r; break;\\
+                case NPY_SHORT: *(short *)(arr->data)=(*v).r; break;\\
+                case NPY_UBYTE: *(unsigned char *)(arr->data)=(*v).r; break;\\
+                case NPY_BYTE: *(signed char *)(arr->data)=(*v).r; break;\\
+                case NPY_BOOL: *(npy_bool *)(arr->data)=((*v).r!=0 && (*v).i!=0); break;\\
+                case NPY_USHORT: *(npy_ushort *)(arr->data)=(*v).r; break;\\
+                case NPY_UINT: *(npy_uint *)(arr->data)=(*v).r; break;\\
+                case NPY_ULONG: *(npy_ulong *)(arr->data)=(*v).r; break;\\
+                case NPY_LONGLONG: *(npy_longlong *)(arr->data)=(*v).r; break;\\
+                case NPY_ULONGLONG: *(npy_ulonglong *)(arr->data)=(*v).r; break;\\
+                case NPY_LONGDOUBLE: *(npy_longdouble *)(arr->data)=(*v).r; break;\\
+                case NPY_CLONGDOUBLE: *(npy_longdouble *)(arr->data)=(*v).r;*(npy_longdouble *)(arr->data+sizeof(npy_longdouble))=(*v).i;break;\\
+                case NPY_OBJECT: (arr->descr->f->setitem)(pyobj_from_complex_ ## ctype ## 1((*v)),arr->data, arr); break;\\
                 default: return -2;\\
         };\\
         return -1;
@@ -391,7 +391,7 @@ cppmacros['TRYCOMPLEXPYARRAYTEMPLATE']="""\
 ## \tif (PyArray_Check(obj)) arr = (PyArrayObject *)obj;\\
 ## \telse arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj,typenum,0,0);\\
 ## \tif (arr) {\\
-## \t\tif (arr->descr->type_num==PyArray_OBJECT) {\\
+## \t\tif (arr->descr->type_num==NPY_OBJECT) {\\
 ## \t\t\tif (!ctype ## _from_pyobj(v,(arr->descr->getitem)(arr->data),\"\"))\\
 ## \t\t\tgoto capi_fail;\\
 ## \t\t} else {\\
@@ -407,7 +407,7 @@ cppmacros['TRYCOMPLEXPYARRAYTEMPLATE']="""\
 ## \tif (PyArray_Check(obj)) arr = (PyArrayObject *)obj;\\
 ## \telse arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj,typenum,0,0);\\
 ## \tif (arr) {\\
-## \t\tif (arr->descr->type_num==PyArray_OBJECT) {\\
+## \t\tif (arr->descr->type_num==NPY_OBJECT) {\\
 ## \t\t\tif (!ctype ## _from_pyobj(v,(arr->descr->getitem)(arr->data),\"\"))\\
 ## \t\t\tgoto capi_fail;\\
 ## \t\t} else {\\
@@ -812,7 +812,7 @@ static int long_double_from_pyobj(long_double* v,PyObject *obj,const char *errme
 \t\t\tPyArray_ScalarAsCtype(obj, v);
 \t\t\treturn 1;
 \t\t}
-\t\telse if (PyArray_Check(obj) && PyArray_TYPE(obj)==PyArray_LONGDOUBLE) {
+\t\telse if (PyArray_Check(obj) && PyArray_TYPE(obj)==NPY_LONGDOUBLE) {
 \t\t\t(*v) = *((npy_longdouble *)PyArray_DATA(obj));
 \t\t\treturn 1;
 \t\t}
@@ -885,7 +885,7 @@ static int complex_long_double_from_pyobj(complex_long_double* v,PyObject *obj,c
 \t\t\tPyArray_ScalarAsCtype(obj, v);
 \t\t\treturn 1;
 \t\t}
-\t\telse if (PyArray_Check(obj) && PyArray_TYPE(obj)==PyArray_CLONGDOUBLE) {
+\t\telse if (PyArray_Check(obj) && PyArray_TYPE(obj)==NPY_CLONGDOUBLE) {
 \t\t\t(*v).r = ((npy_clongdouble *)PyArray_DATA(obj))->real;
 \t\t\t(*v).i = ((npy_clongdouble *)PyArray_DATA(obj))->imag;
 \t\t\treturn 1;
@@ -929,10 +929,10 @@ static int complex_double_from_pyobj(complex_double* v,PyObject *obj,const char
 \tif (PyArray_CheckScalar(obj)) { /* 0-dim array or still array scalar */
 \t\tPyObject *arr;
 \t\tif (PyArray_Check(obj)) {
-\t\t\tarr = PyArray_Cast((PyArrayObject *)obj, PyArray_CDOUBLE);
+\t\t\tarr = PyArray_Cast((PyArrayObject *)obj, NPY_CDOUBLE);
 \t\t}
 \t\telse {
-\t\t\tarr = PyArray_FromScalar(obj, PyArray_DescrFromType(PyArray_CDOUBLE));
+\t\t\tarr = PyArray_FromScalar(obj, PyArray_DescrFromType(NPY_CDOUBLE));
 \t\t}
 \t\tif (arr==NULL) return 0;
 \t\t(*v).r = ((npy_cdouble *)PyArray_DATA(arr))->real;
@@ -1121,7 +1121,7 @@ def buildcfuncs():
         cppmacros[m]='#define %s(v) (PyArray_SimpleNewFromData(0,NULL,%s,(char *)v))'%(m,c2capi_map[k])
     k='string'
     m='pyarr_from_p_%s1'%k
-    cppmacros[m]='#define %s(v,dims) (PyArray_SimpleNewFromData(1,dims,PyArray_CHAR,(char *)v))'%(m)
+    cppmacros[m]='#define %s(v,dims) (PyArray_SimpleNewFromData(1,dims,NPY_CHAR,(char *)v))'%(m)
 
 
 ############ Auxiliary functions for sorting needs ###################
diff --git a/numpy/f2py/doc/fortranobject.tex b/numpy/f2py/doc/fortranobject.tex
index dbb244cdd..88a56835e 100644
--- a/numpy/f2py/doc/fortranobject.tex
+++ b/numpy/f2py/doc/fortranobject.tex
@@ -77,7 +77,7 @@ typedef struct {
   int rank;                  /* array rank, 0 for scalar, max is F2PY_MAX_DIMS,
                                 || rank=-1 for Fortran routine */
   struct {int d[F2PY_MAX_DIMS];} dims;  /* dimensions of the array, || not used */
-  int type;                  /* PyArray_<type> || not used */
+  int type;                  /* NPY_<type> || not used */
   char *data;                /* pointer to array || Fortran routine */
   void (*func)();            /* initialization function for
                                 allocatable arrays:
@@ -182,7 +182,7 @@ In order to access the variable \texttt{i} from Python,
 \texttt{PyFortranObject} is defined as follows:
 \begin{verbatim}
 static FortranDataDef f2py_bar_def[] = {
-  {"i",0,{-1},PyArray_INT},
+  {"i",0,{-1},NPY_INT},
   {NULL}
 };
 static void f2py_setup_bar(char *i) {
@@ -328,7 +328,7 @@ end module fun
 Then
 \begin{verbatim}
 static FortranDataDef f2py_fun_def[] = {
-  {"i",0,{-1},PyArray_INT},
+  {"i",0,{-1},NPY_INT},
   {NULL}
 };
 static void f2py_setup_fun(char *i) {
@@ -370,7 +370,7 @@ end module fun
 Then
 \begin{verbatim}
 static FortranDataDef f2py_fun_def[] = {
-  {"r",1,{-1},PyArray_FLOAT},
+  {"r",1,{-1},NPY_FLOAT},
   {NULL}
 };
 static void f2py_setup_fun(void (*r)()) {
diff --git a/numpy/f2py/docs/HISTORY.txt b/numpy/f2py/docs/HISTORY.txt
index 72b683eb0..077189ee2 100644
--- a/numpy/f2py/docs/HISTORY.txt
+++ b/numpy/f2py/docs/HISTORY.txt
@@ -491,7 +491,7 @@ Release 2.35.229-1505
 
   - Fixed reference counting bug that appeared when constructing extra
     argument list to callback functions.
-  - Added ``PyArray_LONG != PyArray_INT`` test.
+  - Added ``NPY_LONG != NPY_INT`` test.
 
 * f2py2e.py
 
diff --git a/numpy/f2py/src/fortranobject.c b/numpy/f2py/src/fortranobject.c
index ff80fa7e5..f5e2c6244 100644
--- a/numpy/f2py/src/fortranobject.c
+++ b/numpy/f2py/src/fortranobject.c
@@ -51,10 +51,10 @@ PyFortranObject_New(FortranDataDef* defs, f2py_void_func init) {
             PyDict_SetItemString(fp->dict,fp->defs[i].name,v);
         } else
             if ((fp->defs[i].data)!=NULL) { /* Is Fortran variable or array (not allocatable) */
-                if (fp->defs[i].type == PyArray_STRING) {
+                if (fp->defs[i].type == NPY_STRING) {
                     int n = fp->defs[i].rank-1;
                     v = PyArray_New(&PyArray_Type, n, fp->defs[i].dims.d,
-                                    PyArray_STRING, NULL, fp->defs[i].data, fp->defs[i].dims.d[n],
+                                    NPY_STRING, NULL, fp->defs[i].data, fp->defs[i].dims.d[n],
                                     NPY_FARRAY, NULL);
                 }
                 else {
diff --git a/numpy/f2py/src/test/foomodule.c b/numpy/f2py/src/test/foomodule.c
index ed839b3d5..10f02f42b 100644
--- a/numpy/f2py/src/test/foomodule.c
+++ b/numpy/f2py/src/test/foomodule.c
@@ -63,10 +63,10 @@ static PyObject *mod_init(PyObject *capi_self, PyObject *capi_args,
 
 /* F90 module */
 static FortranDataDef f2py_mod_def[] = {
-    {"a",0, {}, PyArray_INT},
-    {"b",0, {}, PyArray_DOUBLE},
-    {"c",1, {3}, PyArray_DOUBLE},
-    {"d",1, {-1}, PyArray_DOUBLE},
+    {"a",0, {}, NPY_INT},
+    {"b",0, {}, NPY_DOUBLE},
+    {"c",1, {3}, NPY_DOUBLE},
+    {"d",1, {-1}, NPY_DOUBLE},
     {"init",-1,{},0,NULL,(void *)mod_init},
     {NULL}
 };
@@ -84,9 +84,9 @@ extern void F_FUNC(f2pyinitmod,F2PYINITMOD)();
 
 /* COMMON block */
 static FortranDataDef f2py_foodata_def[] = {
-    {"a",0, {}, PyArray_INT},
-    {"b",0, {}, PyArray_DOUBLE},
-    {"c",1, {3}, PyArray_DOUBLE},
+    {"a",0, {}, NPY_INT},
+    {"b",0, {}, NPY_DOUBLE},
+    {"c",1, {3}, NPY_DOUBLE},
     {NULL}
 };
 static void f2py_setup_foodata(char *a,char *b,char *c) {
diff --git a/numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c b/numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c
index 73aa40862..e75a667eb 100644
--- a/numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c
+++ b/numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c
@@ -163,32 +163,32 @@ PyMODINIT_FUNC inittest_array_from_pyobj_ext(void) {
   PyDict_SetItemString(d, "F2PY_INTENT_C", PyInt_FromLong(F2PY_INTENT_C));
   PyDict_SetItemString(d, "F2PY_OPTIONAL", PyInt_FromLong(F2PY_OPTIONAL));
   PyDict_SetItemString(d, "F2PY_INTENT_INPLACE", PyInt_FromLong(F2PY_INTENT_INPLACE));
-  PyDict_SetItemString(d, "PyArray_BOOL", PyInt_FromLong(PyArray_BOOL));
-  PyDict_SetItemString(d, "PyArray_BYTE", PyInt_FromLong(PyArray_BYTE));
-  PyDict_SetItemString(d, "PyArray_UBYTE", PyInt_FromLong(PyArray_UBYTE));
-  PyDict_SetItemString(d, "PyArray_SHORT", PyInt_FromLong(PyArray_SHORT));
-  PyDict_SetItemString(d, "PyArray_USHORT", PyInt_FromLong(PyArray_USHORT));
-  PyDict_SetItemString(d, "PyArray_INT", PyInt_FromLong(PyArray_INT));
-  PyDict_SetItemString(d, "PyArray_UINT", PyInt_FromLong(PyArray_UINT));
-  PyDict_SetItemString(d, "PyArray_INTP", PyInt_FromLong(PyArray_INTP));
-  PyDict_SetItemString(d, "PyArray_UINTP", PyInt_FromLong(PyArray_UINTP));
-  PyDict_SetItemString(d, "PyArray_LONG", PyInt_FromLong(PyArray_LONG));
-  PyDict_SetItemString(d, "PyArray_ULONG", PyInt_FromLong(PyArray_ULONG));
-  PyDict_SetItemString(d, "PyArray_LONGLONG", PyInt_FromLong(PyArray_LONGLONG));
-  PyDict_SetItemString(d, "PyArray_ULONGLONG", PyInt_FromLong(PyArray_ULONGLONG));
-  PyDict_SetItemString(d, "PyArray_FLOAT", PyInt_FromLong(PyArray_FLOAT));
-  PyDict_SetItemString(d, "PyArray_DOUBLE", PyInt_FromLong(PyArray_DOUBLE));
-  PyDict_SetItemString(d, "PyArray_LONGDOUBLE", PyInt_FromLong(PyArray_LONGDOUBLE));
-  PyDict_SetItemString(d, "PyArray_CFLOAT", PyInt_FromLong(PyArray_CFLOAT));
-  PyDict_SetItemString(d, "PyArray_CDOUBLE", PyInt_FromLong(PyArray_CDOUBLE));
-  PyDict_SetItemString(d, "PyArray_CLONGDOUBLE", PyInt_FromLong(PyArray_CLONGDOUBLE));
-  PyDict_SetItemString(d, "PyArray_OBJECT", PyInt_FromLong(PyArray_OBJECT));
-  PyDict_SetItemString(d, "PyArray_STRING", PyInt_FromLong(PyArray_STRING));
-  PyDict_SetItemString(d, "PyArray_UNICODE", PyInt_FromLong(PyArray_UNICODE));
-  PyDict_SetItemString(d, "PyArray_VOID", PyInt_FromLong(PyArray_VOID));
-  PyDict_SetItemString(d, "PyArray_NTYPES", PyInt_FromLong(PyArray_NTYPES));
-  PyDict_SetItemString(d, "PyArray_NOTYPE", PyInt_FromLong(PyArray_NOTYPE));
-  PyDict_SetItemString(d, "PyArray_UDERDEF", PyInt_FromLong(PyArray_USERDEF));
+  PyDict_SetItemString(d, "NPY_BOOL", PyInt_FromLong(NPY_BOOL));
+  PyDict_SetItemString(d, "NPY_BYTE", PyInt_FromLong(NPY_BYTE));
+  PyDict_SetItemString(d, "NPY_UBYTE", PyInt_FromLong(NPY_UBYTE));
+  PyDict_SetItemString(d, "NPY_SHORT", PyInt_FromLong(NPY_SHORT));
+  PyDict_SetItemString(d, "NPY_USHORT", PyInt_FromLong(NPY_USHORT));
+  PyDict_SetItemString(d, "NPY_INT", PyInt_FromLong(NPY_INT));
+  PyDict_SetItemString(d, "NPY_UINT", PyInt_FromLong(NPY_UINT));
+  PyDict_SetItemString(d, "NPY_INTP", PyInt_FromLong(NPY_INTP));
+  PyDict_SetItemString(d, "NPY_UINTP", PyInt_FromLong(NPY_UINTP));
+  PyDict_SetItemString(d, "NPY_LONG", PyInt_FromLong(NPY_LONG));
+  PyDict_SetItemString(d, "NPY_ULONG", PyInt_FromLong(NPY_ULONG));
+  PyDict_SetItemString(d, "NPY_LONGLONG", PyInt_FromLong(NPY_LONGLONG));
+  PyDict_SetItemString(d, "NPY_ULONGLONG", PyInt_FromLong(NPY_ULONGLONG));
+  PyDict_SetItemString(d, "NPY_FLOAT", PyInt_FromLong(NPY_FLOAT));
+  PyDict_SetItemString(d, "NPY_DOUBLE", PyInt_FromLong(NPY_DOUBLE));
+  PyDict_SetItemString(d, "NPY_LONGDOUBLE", PyInt_FromLong(NPY_LONGDOUBLE));
+  PyDict_SetItemString(d, "NPY_CFLOAT", PyInt_FromLong(NPY_CFLOAT));
+  PyDict_SetItemString(d, "NPY_CDOUBLE", PyInt_FromLong(NPY_CDOUBLE));
+  PyDict_SetItemString(d, "NPY_CLONGDOUBLE", PyInt_FromLong(NPY_CLONGDOUBLE));
+  PyDict_SetItemString(d, "NPY_OBJECT", PyInt_FromLong(NPY_OBJECT));
+  PyDict_SetItemString(d, "NPY_STRING", PyInt_FromLong(NPY_STRING));
+  PyDict_SetItemString(d, "NPY_UNICODE", PyInt_FromLong(NPY_UNICODE));
+  PyDict_SetItemString(d, "NPY_VOID", PyInt_FromLong(NPY_VOID));
+  PyDict_SetItemString(d, "NPY_NTYPES", PyInt_FromLong(NPY_NTYPES));
+  PyDict_SetItemString(d, "NPY_NOTYPE", PyInt_FromLong(NPY_NOTYPE));
+  PyDict_SetItemString(d, "NPY_USERDEF", PyInt_FromLong(NPY_USERDEF));
 
   PyDict_SetItemString(d, "CONTIGUOUS", PyInt_FromLong(NPY_CONTIGUOUS));
   PyDict_SetItemString(d, "FORTRAN", PyInt_FromLong(NPY_FORTRAN));
diff --git a/numpy/f2py/tests/test_array_from_pyobj.py b/numpy/f2py/tests/test_array_from_pyobj.py
index e760e8e4e..be85a308a 100644
--- a/numpy/f2py/tests/test_array_from_pyobj.py
+++ b/numpy/f2py/tests/test_array_from_pyobj.py
@@ -129,7 +129,7 @@ class Type(object):
 
     def _init(self,name):
         self.NAME = name.upper()
-        self.type_num = getattr(wrap,'PyArray_'+self.NAME)
+        self.type_num = getattr(wrap,'NPY_'+self.NAME)
         assert_equal(self.type_num,typeinfo[self.NAME][1])
         self.dtype = typeinfo[self.NAME][-1]
         self.elsize = typeinfo[self.NAME][2] / 8