comparison DEPENDENCIES/mingw32/Python27/Lib/site-packages/numpy/f2py/rules.py @ 87:2a2c65a20a8b

Add Python libs and headers

+#!/usr/bin/env python
+"""
+
+Rules for building C/API module with f2py2e.
+
+Here is a skeleton of a new wrapper function (13Dec2001):
+
+wrapper_function(args)
+  declarations
+  get_python_arguments, say, `a' and `b'
+
+  get_a_from_python
+  if (successful) {
+
+    get_b_from_python
+    if (successful) {
+
+      callfortran
+      if (succesful) {
+
+        put_a_to_python
+        if (succesful) {
+
+          put_b_to_python
+          if (succesful) {
+
+            buildvalue = ...
+
+          }
+
+        }
+
+      }
+
+    }
+    cleanup_b
+
+  }
+  cleanup_a
+
+  return buildvalue
+
+Copyright 1999,2000 Pearu Peterson all rights reserved,
+Pearu Peterson <[e-mail]>
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+$Date: 2005/08/30 08:58:42 $
+Pearu Peterson
+
+"""
+from __future__ import division, absolute_import, print_function
+
+__version__ = "$Revision: 1.129 $"[10:-1]
+
+from . import __version__
+f2py_version = __version__.version
+
+import pprint
+import sys
+import time
+import copy
+
+from .auxfuncs import *
+from . import capi_maps
+from .capi_maps import *
+from . import cfuncs
+from . import common_rules
+from . import use_rules
+from . import f90mod_rules
+from . import func2subr
+
+errmess = sys.stderr.write
+outmess = sys.stdout.write
+show = pprint.pprint
+
+options={}
+sepdict={}
+#for k in ['need_cfuncs']: sepdict[k]=','
+for k in ['decl',
+          'frompyobj',
+          'cleanupfrompyobj',
+          'topyarr', 'method',
+          'pyobjfrom', 'closepyobjfrom',
+          'freemem',
+          'userincludes',
+          'includes0', 'includes', 'typedefs', 'typedefs_generated',
+          'cppmacros', 'cfuncs', 'callbacks',
+          'latexdoc',
+          'restdoc',
+          'routine_defs', 'externroutines',
+          'initf2pywraphooks',
+          'commonhooks', 'initcommonhooks',
+          'f90modhooks', 'initf90modhooks']:
+    sepdict[k]='\n'
+
+#################### Rules for C/API module #################
+
+module_rules={
+    'modulebody':"""\
+/* File: #modulename#module.c
+ * This file is auto-generated with f2py (version:#f2py_version#).
+ * f2py is a Fortran to Python Interface Generator (FPIG), Second Edition,
+ * written by Pearu Peterson <[e-mail]>.
+ * See http://cens.ioc.ee/projects/f2py2e/
+ * Generation date: """+time.asctime(time.localtime(time.time()))+"""
+ * $R"""+"""evision:$
+ * $D"""+"""ate:$
+ * Do not edit this file directly unless you know what you are doing!!!
+ */
+#ifdef __cplusplus
+extern \"C\" {
+#endif
+
+"""+gentitle("See f2py2e/cfuncs.py: includes")+"""
+#includes#
+#includes0#
+
+"""+gentitle("See f2py2e/rules.py: mod_rules['modulebody']")+"""
+static PyObject *#modulename#_error;
+static PyObject *#modulename#_module;
+
+"""+gentitle("See f2py2e/cfuncs.py: typedefs")+"""
+#typedefs#
+
+"""+gentitle("See f2py2e/cfuncs.py: typedefs_generated")+"""
+#typedefs_generated#
+
+"""+gentitle("See f2py2e/cfuncs.py: cppmacros")+"""
+#cppmacros#
+
+"""+gentitle("See f2py2e/cfuncs.py: cfuncs")+"""
+#cfuncs#
+
+"""+gentitle("See f2py2e/cfuncs.py: userincludes")+"""
+#userincludes#
+
+"""+gentitle("See f2py2e/capi_rules.py: usercode")+"""
+#usercode#
+
+/* See f2py2e/rules.py */
+#externroutines#
+
+"""+gentitle("See f2py2e/capi_rules.py: usercode1")+"""
+#usercode1#
+
+"""+gentitle("See f2py2e/cb_rules.py: buildcallback")+"""
+#callbacks#
+
+"""+gentitle("See f2py2e/rules.py: buildapi")+"""
+#body#
+
+"""+gentitle("See f2py2e/f90mod_rules.py: buildhooks")+"""
+#f90modhooks#
+
+"""+gentitle("See f2py2e/rules.py: module_rules['modulebody']")+"""
+
+"""+gentitle("See f2py2e/common_rules.py: buildhooks")+"""
+#commonhooks#
+
+"""+gentitle("See f2py2e/rules.py")+"""
+
+static FortranDataDef f2py_routine_defs[] = {
+#routine_defs#
+\t{NULL}
+};
+
+static PyMethodDef f2py_module_methods[] = {
+#pymethoddef#
+\t{NULL,NULL}
+};
+
+#if PY_VERSION_HEX >= 0x03000000
+static struct PyModuleDef moduledef = {
+\tPyModuleDef_HEAD_INIT,
+\t"#modulename#",
+\tNULL,
+\t-1,
+\tf2py_module_methods,
+\tNULL,
+\tNULL,
+\tNULL,
+\tNULL
+};
+#endif
+
+#if PY_VERSION_HEX >= 0x03000000
+#define RETVAL m
+PyMODINIT_FUNC PyInit_#modulename#(void) {
+#else
+#define RETVAL
+PyMODINIT_FUNC init#modulename#(void) {
+#endif
+\tint i;
+\tPyObject *m,*d, *s;
+#if PY_VERSION_HEX >= 0x03000000
+\tm = #modulename#_module = PyModule_Create(&moduledef);
+#else
+\tm = #modulename#_module = Py_InitModule(\"#modulename#\", f2py_module_methods);
+#endif
+\tPy_TYPE(&PyFortran_Type) = &PyType_Type;
+\timport_array();
+\tif (PyErr_Occurred())
+\t\t{PyErr_SetString(PyExc_ImportError, \"can't initialize module #modulename# (failed to import numpy)\"); return RETVAL;}
+\td = PyModule_GetDict(m);
+\ts = PyString_FromString(\"$R"""+"""evision: $\");
+\tPyDict_SetItemString(d, \"__version__\", s);
+#if PY_VERSION_HEX >= 0x03000000
+\ts = PyUnicode_FromString(
+#else
+\ts = PyString_FromString(
+#endif
+\t\t\"This module '#modulename#' is auto-generated with f2py (version:#f2py_version#).\\nFunctions:\\n\"\n#docs#\".\");
+\tPyDict_SetItemString(d, \"__doc__\", s);
+\t#modulename#_error = PyErr_NewException (\"#modulename#.error\", NULL, NULL);
+\tPy_DECREF(s);
+\tfor(i=0;f2py_routine_defs[i].name!=NULL;i++)
+\t\tPyDict_SetItemString(d, f2py_routine_defs[i].name,PyFortranObject_NewAsAttr(&f2py_routine_defs[i]));
+#initf2pywraphooks#
+#initf90modhooks#
+#initcommonhooks#
+#interface_usercode#
+
+#ifdef F2PY_REPORT_ATEXIT
+\tif (! PyErr_Occurred())
+\t\ton_exit(f2py_report_on_exit,(void*)\"#modulename#\");
+#endif
+
+\treturn RETVAL;
+}
+#ifdef __cplusplus
+}
+#endif
+""",
+    'separatorsfor':{'latexdoc':'\n\n',
+                     'restdoc':'\n\n'},
+    'latexdoc':['\\section{Module \\texttt{#texmodulename#}}\n',
+                '#modnote#\n',
+                '#latexdoc#'],
+    'restdoc':['Module #modulename#\n'+'='*80,
+               '\n#restdoc#']
+    }
+
+defmod_rules=[
+    {'body': '/*eof body*/',
+     'method': '/*eof method*/',
+     'externroutines': '/*eof externroutines*/',
+     'routine_defs': '/*eof routine_defs*/',
+     'initf90modhooks': '/*eof initf90modhooks*/',
+     'initf2pywraphooks': '/*eof initf2pywraphooks*/',
+     'initcommonhooks': '/*eof initcommonhooks*/',
+     'latexdoc': '',
+     'restdoc': '',
+     'modnote': {hasnote:'#note#',l_not(hasnote):''},
+     }
+    ]
+
+routine_rules={
+    'separatorsfor':sepdict,
+    'body':"""
+#begintitle#
+static char doc_#apiname#[] = \"\\\n#docreturn##name#(#docsignatureshort#)\\n\\nWrapper for ``#name#``.\\\n\\n#docstrsigns#\";
+/* #declfortranroutine# */
+static PyObject *#apiname#(const PyObject *capi_self,
+                           PyObject *capi_args,
+                           PyObject *capi_keywds,
+                           #functype# (*f2py_func)(#callprotoargument#)) {
+\tPyObject * volatile capi_buildvalue = NULL;
+\tvolatile int f2py_success = 1;
+#decl#
+\tstatic char *capi_kwlist[] = {#kwlist##kwlistopt##kwlistxa#NULL};
+#usercode#
+#routdebugenter#
+#ifdef F2PY_REPORT_ATEXIT
+f2py_start_clock();
+#endif
+\tif (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\\
+\t\t\"#argformat##keyformat##xaformat#:#pyname#\",\\
+\t\tcapi_kwlist#args_capi##keys_capi##keys_xa#))\n\t\treturn NULL;
+#frompyobj#
+/*end of frompyobj*/
+#ifdef F2PY_REPORT_ATEXIT
+f2py_start_call_clock();
+#endif
+#callfortranroutine#
+if (PyErr_Occurred())
+  f2py_success = 0;
+#ifdef F2PY_REPORT_ATEXIT
+f2py_stop_call_clock();
+#endif
+/*end of callfortranroutine*/
+\t\tif (f2py_success) {
+#pyobjfrom#
+/*end of pyobjfrom*/
+\t\tCFUNCSMESS(\"Building return value.\\n\");
+\t\tcapi_buildvalue = Py_BuildValue(\"#returnformat#\"#return#);
+/*closepyobjfrom*/
+#closepyobjfrom#
+\t\t} /*if (f2py_success) after callfortranroutine*/
+/*cleanupfrompyobj*/
+#cleanupfrompyobj#
+\tif (capi_buildvalue == NULL) {
+#routdebugfailure#
+\t} else {
+#routdebugleave#
+\t}
+\tCFUNCSMESS(\"Freeing memory.\\n\");
+#freemem#
+#ifdef F2PY_REPORT_ATEXIT
+f2py_stop_clock();
+#endif
+\treturn capi_buildvalue;
+}
+#endtitle#
+""",
+    'routine_defs':'#routine_def#',
+    'initf2pywraphooks':'#initf2pywraphook#',
+    'externroutines':'#declfortranroutine#',
+    'doc':'#docreturn##name#(#docsignature#)',
+    'docshort':'#docreturn##name#(#docsignatureshort#)',
+    'docs':'"\t#docreturn##name#(#docsignature#)\\n"\n',
+    'need':['arrayobject.h', 'CFUNCSMESS', 'MINMAX'],
+    'cppmacros':{debugcapi:'#define DEBUGCFUNCS'},
+    'latexdoc':['\\subsection{Wrapper function \\texttt{#texname#}}\n',
+                """
+\\noindent{{}\\verb@#docreturn##name#@{}}\\texttt{(#latexdocsignatureshort#)}
+#routnote#
+
+#latexdocstrsigns#
+"""],
+    'restdoc':['Wrapped function ``#name#``\n'+'-'*80,
+
+               ]
+    }
+
+################## Rules for C/API function ##############
+
+rout_rules=[
+    { # Init
+    'separatorsfor': {'callfortranroutine': '\n', 'routdebugenter': '\n', 'decl': '\n',
+                      'routdebugleave': '\n', 'routdebugfailure': '\n',
+                      'setjmpbuf': ' || ',
+                      'docstrreq': '\n', 'docstropt': '\n', 'docstrout': '\n',
+                      'docstrcbs': '\n', 'docstrsigns': '\\n"\n"',
+                      'latexdocstrsigns': '\n',
+                      'latexdocstrreq': '\n', 'latexdocstropt': '\n',
+                      'latexdocstrout': '\n', 'latexdocstrcbs': '\n',
+                      },
+    'kwlist': '', 'kwlistopt': '', 'callfortran': '', 'callfortranappend': '',
+    'docsign': '', 'docsignopt': '', 'decl': '/*decl*/',
+    'freemem': '/*freemem*/',
+    'docsignshort': '', 'docsignoptshort': '',
+    'docstrsigns': '', 'latexdocstrsigns': '',
+    'docstrreq': '\\nParameters\\n----------',
+    'docstropt': '\\nOther Parameters\\n----------------',
+    'docstrout': '\\nReturns\\n-------',
+    'docstrcbs': '\\nNotes\\n-----\\nCall-back functions::\\n',
+    'latexdocstrreq': '\\noindent Required arguments:',
+    'latexdocstropt': '\\noindent Optional arguments:',
+    'latexdocstrout': '\\noindent Return objects:',
+    'latexdocstrcbs': '\\noindent Call-back functions:',
+    'args_capi': '', 'keys_capi': '', 'functype': '',
+    'frompyobj': '/*frompyobj*/',
+    'cleanupfrompyobj': ['/*end of cleanupfrompyobj*/'], #this list will be reversed
+    'pyobjfrom': '/*pyobjfrom*/',
+    'closepyobjfrom': ['/*end of closepyobjfrom*/'], #this list will be reversed
+    'topyarr': '/*topyarr*/', 'routdebugleave': '/*routdebugleave*/',
+    'routdebugenter': '/*routdebugenter*/',
+    'routdebugfailure': '/*routdebugfailure*/',
+    'callfortranroutine': '/*callfortranroutine*/',
+    'argformat': '', 'keyformat': '', 'need_cfuncs': '',
+    'docreturn': '', 'return': '', 'returnformat': '', 'rformat': '',
+    'kwlistxa': '', 'keys_xa': '', 'xaformat': '', 'docsignxa': '', 'docsignxashort': '',
+    'initf2pywraphook': '',
+    'routnote': {hasnote:'--- #note#',l_not(hasnote):''},
+    }, {
+        'apiname':'f2py_rout_#modulename#_#name#',
+        'pyname':'#modulename#.#name#',
+        'decl':'',
+        '_check':l_not(ismoduleroutine)
+    }, {
+        'apiname':'f2py_rout_#modulename#_#f90modulename#_#name#',
+        'pyname':'#modulename#.#f90modulename#.#name#',
+        'decl':'',
+        '_check':ismoduleroutine
+    }, { # Subroutine
+    'functype': 'void',
+    'declfortranroutine': {l_and(l_not(l_or(ismoduleroutine, isintent_c)), l_not(isdummyroutine)):'extern void #F_FUNC#(#fortranname#,#FORTRANNAME#)(#callprotoargument#);',
+                          l_and(l_not(ismoduleroutine), isintent_c, l_not(isdummyroutine)):'extern void #fortranname#(#callprotoargument#);',
+                          ismoduleroutine:'',
+                          isdummyroutine:''
+                          },
+    'routine_def': {l_not(l_or(ismoduleroutine, isintent_c, isdummyroutine)): '\t{\"#name#\",-1,{{-1}},0,(char *)#F_FUNC#(#fortranname#,#FORTRANNAME#),(f2py_init_func)#apiname#,doc_#apiname#},',
+                   l_and(l_not(ismoduleroutine), isintent_c, l_not(isdummyroutine)): '\t{\"#name#\",-1,{{-1}},0,(char *)#fortranname#,(f2py_init_func)#apiname#,doc_#apiname#},',
+                   l_and(l_not(ismoduleroutine), isdummyroutine): '\t{\"#name#\",-1,{{-1}},0,NULL,(f2py_init_func)#apiname#,doc_#apiname#},',
+                   },
+    'need': {l_and(l_not(l_or(ismoduleroutine, isintent_c)), l_not(isdummyroutine)):'F_FUNC'},
+    'callfortranroutine': [
+        {debugcapi:["""\tfprintf(stderr,\"debug-capi:Fortran subroutine `#fortranname#(#callfortran#)\'\\n\");"""]},
+        {hasexternals:"""\
+\t\tif (#setjmpbuf#) {
+\t\t\tf2py_success = 0;
+\t\t} else {"""},
+        {isthreadsafe:'\t\t\tPy_BEGIN_ALLOW_THREADS'},
+        {hascallstatement:'''\t\t\t\t#callstatement#;
+\t\t\t\t/*(*f2py_func)(#callfortran#);*/'''},
+        {l_not(l_or(hascallstatement, isdummyroutine)):'\t\t\t\t(*f2py_func)(#callfortran#);'},
+        {isthreadsafe:'\t\t\tPy_END_ALLOW_THREADS'},
+        {hasexternals:"""\t\t}"""}
+         ],
+    '_check': l_and(issubroutine, l_not(issubroutine_wrap)),
+    }, { # Wrapped function
+    'functype': 'void',
+    'declfortranroutine': {l_not(l_or(ismoduleroutine, isdummyroutine)): 'extern void #F_WRAPPEDFUNC#(#name_lower#,#NAME#)(#callprotoargument#);',
+                          isdummyroutine: '',
+                          },
+
+    'routine_def': {l_not(l_or(ismoduleroutine, isdummyroutine)): '\t{\"#name#\",-1,{{-1}},0,(char *)#F_WRAPPEDFUNC#(#name_lower#,#NAME#),(f2py_init_func)#apiname#,doc_#apiname#},',
+                   isdummyroutine: '\t{\"#name#\",-1,{{-1}},0,NULL,(f2py_init_func)#apiname#,doc_#apiname#},',
+                   },
+    'initf2pywraphook': {l_not(l_or(ismoduleroutine, isdummyroutine)):'''
+    {
+      extern #ctype# #F_FUNC#(#name_lower#,#NAME#)(void);
+      PyObject* o = PyDict_GetItemString(d,"#name#");
+      PyObject_SetAttrString(o,"_cpointer", F2PyCapsule_FromVoidPtr((void*)#F_FUNC#(#name_lower#,#NAME#),NULL));
+#if PY_VERSION_HEX >= 0x03000000
+      PyObject_SetAttrString(o,"__name__", PyUnicode_FromString("#name#"));
+#else
+      PyObject_SetAttrString(o,"__name__", PyString_FromString("#name#"));
+#endif
+    }
+    '''},
+    'need': {l_not(l_or(ismoduleroutine, isdummyroutine)):['F_WRAPPEDFUNC', 'F_FUNC']},
+    'callfortranroutine': [
+    {debugcapi:["""\tfprintf(stderr,\"debug-capi:Fortran subroutine `f2pywrap#name_lower#(#callfortran#)\'\\n\");"""]},
+    {hasexternals:"""\
+\tif (#setjmpbuf#) {
+\t\tf2py_success = 0;
+\t} else {"""},
+    {isthreadsafe:'\tPy_BEGIN_ALLOW_THREADS'},
+    {l_not(l_or(hascallstatement, isdummyroutine)):'\t(*f2py_func)(#callfortran#);'},
+    {hascallstatement:'\t#callstatement#;\n\t/*(*f2py_func)(#callfortran#);*/'},
+    {isthreadsafe:'\tPy_END_ALLOW_THREADS'},
+    {hasexternals:'\t}'}
+    ],
+    '_check': isfunction_wrap,
+    }, { # Wrapped subroutine
+    'functype': 'void',
+    'declfortranroutine': {l_not(l_or(ismoduleroutine, isdummyroutine)): 'extern void #F_WRAPPEDFUNC#(#name_lower#,#NAME#)(#callprotoargument#);',
+                          isdummyroutine: '',
+                          },
+
+    'routine_def': {l_not(l_or(ismoduleroutine, isdummyroutine)): '\t{\"#name#\",-1,{{-1}},0,(char *)#F_WRAPPEDFUNC#(#name_lower#,#NAME#),(f2py_init_func)#apiname#,doc_#apiname#},',
+                   isdummyroutine: '\t{\"#name#\",-1,{{-1}},0,NULL,(f2py_init_func)#apiname#,doc_#apiname#},',
+                   },
+    'initf2pywraphook': {l_not(l_or(ismoduleroutine, isdummyroutine)):'''
+    {
+      extern void #F_FUNC#(#name_lower#,#NAME#)(void);
+      PyObject* o = PyDict_GetItemString(d,"#name#");
+      PyObject_SetAttrString(o,"_cpointer", F2PyCapsule_FromVoidPtr((void*)#F_FUNC#(#name_lower#,#NAME#),NULL));
+#if PY_VERSION_HEX >= 0x03000000
+      PyObject_SetAttrString(o,"__name__", PyUnicode_FromString("#name#"));
+#else
+      PyObject_SetAttrString(o,"__name__", PyString_FromString("#name#"));
+#endif
+    }
+    '''},
+    'need': {l_not(l_or(ismoduleroutine, isdummyroutine)):['F_WRAPPEDFUNC', 'F_FUNC']},
+    'callfortranroutine': [
+    {debugcapi:["""\tfprintf(stderr,\"debug-capi:Fortran subroutine `f2pywrap#name_lower#(#callfortran#)\'\\n\");"""]},
+    {hasexternals:"""\
+\tif (#setjmpbuf#) {
+\t\tf2py_success = 0;
+\t} else {"""},
+    {isthreadsafe:'\tPy_BEGIN_ALLOW_THREADS'},
+    {l_not(l_or(hascallstatement, isdummyroutine)):'\t(*f2py_func)(#callfortran#);'},
+    {hascallstatement:'\t#callstatement#;\n\t/*(*f2py_func)(#callfortran#);*/'},
+    {isthreadsafe:'\tPy_END_ALLOW_THREADS'},
+    {hasexternals:'\t}'}
+    ],
+    '_check': issubroutine_wrap,
+    }, { # Function
+    'functype':'#ctype#',
+    'docreturn':{l_not(isintent_hide):'#rname#,'},
+    'docstrout':'#pydocsignout#',
+    'latexdocstrout':['\\item[]{{}\\verb@#pydocsignout#@{}}',
+                      {hasresultnote:'--- #resultnote#'}],
+    'callfortranroutine':[{l_and(debugcapi, isstringfunction):"""\
+#ifdef USESCOMPAQFORTRAN
+\tfprintf(stderr,\"debug-capi:Fortran function #ctype# #fortranname#(#callcompaqfortran#)\\n\");
+#else
+\tfprintf(stderr,\"debug-capi:Fortran function #ctype# #fortranname#(#callfortran#)\\n\");
+#endif
+"""},
+                          {l_and(debugcapi, l_not(isstringfunction)):"""\
+\tfprintf(stderr,\"debug-capi:Fortran function #ctype# #fortranname#(#callfortran#)\\n\");
+"""}
+                          ],
+    '_check':l_and(isfunction, l_not(isfunction_wrap))
+    }, { # Scalar function
+    'declfortranroutine':{l_and(l_not(l_or(ismoduleroutine, isintent_c)), l_not(isdummyroutine)):'extern #ctype# #F_FUNC#(#fortranname#,#FORTRANNAME#)(#callprotoargument#);',
+                          l_and(l_not(ismoduleroutine), isintent_c, l_not(isdummyroutine)):'extern #ctype# #fortranname#(#callprotoargument#);',
+                          isdummyroutine:''
+                          },
+    'routine_def':{l_and(l_not(l_or(ismoduleroutine, isintent_c)), l_not(isdummyroutine)): '\t{\"#name#\",-1,{{-1}},0,(char *)#F_FUNC#(#fortranname#,#FORTRANNAME#),(f2py_init_func)#apiname#,doc_#apiname#},',
+                   l_and(l_not(ismoduleroutine), isintent_c, l_not(isdummyroutine)): '\t{\"#name#\",-1,{{-1}},0,(char *)#fortranname#,(f2py_init_func)#apiname#,doc_#apiname#},',
+                   isdummyroutine: '\t{\"#name#\",-1,{{-1}},0,NULL,(f2py_init_func)#apiname#,doc_#apiname#},',
+                   },
+    'decl':[{iscomplexfunction_warn:'\t#ctype# #name#_return_value={0,0};',
+             l_not(iscomplexfunction):'\t#ctype# #name#_return_value=0;'},
+            {iscomplexfunction:'\tPyObject *#name#_return_value_capi = Py_None;'}
+            ],
+    'callfortranroutine':[
+        {hasexternals:"""\
+\tif (#setjmpbuf#) {
+\t\tf2py_success = 0;
+\t} else {"""},
+        {isthreadsafe:'\tPy_BEGIN_ALLOW_THREADS'},
+        {hascallstatement:'''\t#callstatement#;
+/*\t#name#_return_value = (*f2py_func)(#callfortran#);*/
+'''},
+        {l_not(l_or(hascallstatement, isdummyroutine)):'\t#name#_return_value = (*f2py_func)(#callfortran#);'},
+        {isthreadsafe:'\tPy_END_ALLOW_THREADS'},
+        {hasexternals:'\t}'},
+        {l_and(debugcapi, iscomplexfunction):'\tfprintf(stderr,"#routdebugshowvalue#\\n",#name#_return_value.r,#name#_return_value.i);'},
+        {l_and(debugcapi, l_not(iscomplexfunction)):'\tfprintf(stderr,"#routdebugshowvalue#\\n",#name#_return_value);'}],
+    'pyobjfrom':{iscomplexfunction:'\t#name#_return_value_capi = pyobj_from_#ctype#1(#name#_return_value);'},
+    'need':[{l_not(isdummyroutine):'F_FUNC'},
+    {iscomplexfunction:'pyobj_from_#ctype#1'},
+    {islong_longfunction:'long_long'},
+    {islong_doublefunction:'long_double'}],
+    'returnformat':{l_not(isintent_hide):'#rformat#'},
+    'return':{iscomplexfunction:',#name#_return_value_capi',
+    l_not(l_or(iscomplexfunction, isintent_hide)):',#name#_return_value'},
+    '_check':l_and(isfunction, l_not(isstringfunction), l_not(isfunction_wrap))
+    }, { # String function # in use for --no-wrap
+    'declfortranroutine':'extern void #F_FUNC#(#fortranname#,#FORTRANNAME#)(#callprotoargument#);',
+    'routine_def':{l_not(l_or(ismoduleroutine, isintent_c)):
+#        '\t{\"#name#\",-1,{{-1}},0,(char *)F_FUNC(#fortranname#,#FORTRANNAME#),(void *)#apiname#,doc_#apiname#},',
+        '\t{\"#name#\",-1,{{-1}},0,(char *)#F_FUNC#(#fortranname#,#FORTRANNAME#),(f2py_init_func)#apiname#,doc_#apiname#},',
+        l_and(l_not(ismoduleroutine), isintent_c):
+#            '\t{\"#name#\",-1,{{-1}},0,(char *)#fortranname#,(void *)#apiname#,doc_#apiname#},'
+            '\t{\"#name#\",-1,{{-1}},0,(char *)#fortranname#,(f2py_init_func)#apiname#,doc_#apiname#},'
+                   },
+    'decl':['\t#ctype# #name#_return_value = NULL;',
+            '\tint #name#_return_value_len = 0;'],
+    'callfortran':'#name#_return_value,#name#_return_value_len,',
+    'callfortranroutine':['\t#name#_return_value_len = #rlength#;',
+                          '\tif ((#name#_return_value = (string)malloc(sizeof(char)*(#name#_return_value_len+1))) == NULL) {',
+                          '\t\tPyErr_SetString(PyExc_MemoryError, \"out of memory\");',
+                          '\t\tf2py_success = 0;',
+                          '\t} else {',
+                          "\t\t(#name#_return_value)[#name#_return_value_len] = '\\0';",
+                          '\t}',
+                          '\tif (f2py_success) {',
+                          {hasexternals:"""\
+\t\tif (#setjmpbuf#) {
+\t\t\tf2py_success = 0;
+\t\t} else {"""},
+                          {isthreadsafe:'\t\tPy_BEGIN_ALLOW_THREADS'},
+                          """\
+#ifdef USESCOMPAQFORTRAN
+\t\t(*f2py_func)(#callcompaqfortran#);
+#else
+\t\t(*f2py_func)(#callfortran#);
+#endif
+""",
+                          {isthreadsafe:'\t\tPy_END_ALLOW_THREADS'},
+                          {hasexternals:'\t\t}'},
+                          {debugcapi:'\t\tfprintf(stderr,"#routdebugshowvalue#\\n",#name#_return_value_len,#name#_return_value);'},
+                          '\t} /* if (f2py_success) after (string)malloc */',
+                          ],
+    'returnformat':'#rformat#',
+    'return':',#name#_return_value',
+    'freemem':'\tSTRINGFREE(#name#_return_value);',
+    'need':['F_FUNC', '#ctype#', 'STRINGFREE'],
+    '_check':l_and(isstringfunction, l_not(isfunction_wrap)) # ???obsolete
+    },
+    { # Debugging
+    'routdebugenter':'\tfprintf(stderr,"debug-capi:Python C/API function #modulename#.#name#(#docsignature#)\\n");',
+    'routdebugleave':'\tfprintf(stderr,"debug-capi:Python C/API function #modulename#.#name#: successful.\\n");',
+    'routdebugfailure':'\tfprintf(stderr,"debug-capi:Python C/API function #modulename#.#name#: failure.\\n");',
+    '_check':debugcapi
+    }
+    ]
+
+################ Rules for arguments ##################
+
+typedef_need_dict = {islong_long: 'long_long',
+                     islong_double: 'long_double',
+                     islong_complex: 'complex_long_double',
+                     isunsigned_char: 'unsigned_char',
+                     isunsigned_short: 'unsigned_short',
+                     isunsigned: 'unsigned',
+                     isunsigned_long_long: 'unsigned_long_long',
+                     isunsigned_chararray: 'unsigned_char',
+                     isunsigned_shortarray: 'unsigned_short',
+                     isunsigned_long_longarray: 'unsigned_long_long',
+                     issigned_long_longarray: 'long_long',
+                     }
+
+aux_rules=[
+    {
+    'separatorsfor':sepdict
+    },
+    { # Common
+    'frompyobj': ['\t/* Processing auxiliary variable #varname# */',
+                 {debugcapi:'\tfprintf(stderr,"#vardebuginfo#\\n");'},],
+    'cleanupfrompyobj': '\t/* End of cleaning variable #varname# */',
+    'need': typedef_need_dict,
+    },
+# Scalars (not complex)
+    { # Common
+    'decl': '\t#ctype# #varname# = 0;',
+    'need': {hasinitvalue:'math.h'},
+    'frompyobj': {hasinitvalue:'\t#varname# = #init#;'},
+    '_check': l_and(isscalar, l_not(iscomplex)),
+    },
+    {
+    'return': ',#varname#',
+    'docstrout': '#pydocsignout#',
+    'docreturn': '#outvarname#,',
+    'returnformat': '#varrformat#',
+    '_check': l_and(isscalar, l_not(iscomplex), isintent_out),
+    },
+# Complex scalars
+    { # Common
+    'decl':'\t#ctype# #varname#;',
+    'frompyobj': {hasinitvalue:'\t#varname#.r = #init.r#, #varname#.i = #init.i#;'},
+    '_check':iscomplex
+    },
+# String
+    { # Common
+    'decl':['\t#ctype# #varname# = NULL;',
+            '\tint slen(#varname#);',
+            ],
+    'need':['len..'],
+    '_check':isstring
+    },
+# Array
+    { # Common
+    'decl':['\t#ctype# *#varname# = NULL;',
+            '\tnpy_intp #varname#_Dims[#rank#] = {#rank*[-1]#};',
+            '\tconst int #varname#_Rank = #rank#;',
+            ],
+    'need':['len..', {hasinitvalue:'forcomb'}, {hasinitvalue:'CFUNCSMESS'}],
+    '_check':isarray
+    },
+# Scalararray
+    { # Common
+    '_check':l_and(isarray, l_not(iscomplexarray))
+    }, { # Not hidden
+    '_check':l_and(isarray, l_not(iscomplexarray), isintent_nothide)
+    },
+# Integer*1 array
+    {'need':'#ctype#',
+     '_check':isint1array,
+     '_depend':''
+     },
+# Integer*-1 array
+    {'need':'#ctype#',
+     '_check':isunsigned_chararray,
+     '_depend':''
+     },
+# Integer*-2 array
+    {'need':'#ctype#',
+     '_check':isunsigned_shortarray,
+     '_depend':''
+     },
+# Integer*-8 array
+    {'need':'#ctype#',
+     '_check':isunsigned_long_longarray,
+     '_depend':''
+     },
+# Complexarray
+    {'need':'#ctype#',
+     '_check':iscomplexarray,
+     '_depend':''
+     },
+# Stringarray
+     {
+     'callfortranappend':{isarrayofstrings:'flen(#varname#),'},
+     'need':'string',
+     '_check':isstringarray
+     }
+    ]
+
+arg_rules=[
+    {
+    'separatorsfor':sepdict
+    },
+    { # Common
+    'frompyobj': ['\t/* Processing variable #varname# */',
+                 {debugcapi:'\tfprintf(stderr,"#vardebuginfo#\\n");'},],
+    'cleanupfrompyobj': '\t/* End of cleaning variable #varname# */',
+    '_depend': '',
+    'need': typedef_need_dict,
+    },
+# Doc signatures
+    {
+    'docstropt':{l_and(isoptional, isintent_nothide):'#pydocsign#'},
+    'docstrreq':{l_and(isrequired, isintent_nothide):'#pydocsign#'},
+    'docstrout':{isintent_out:'#pydocsignout#'},
+    'latexdocstropt':{l_and(isoptional, isintent_nothide):['\\item[]{{}\\verb@#pydocsign#@{}}',
+                                                          {hasnote:'--- #note#'}]},
+    'latexdocstrreq':{l_and(isrequired, isintent_nothide):['\\item[]{{}\\verb@#pydocsign#@{}}',
+                                                          {hasnote:'--- #note#'}]},
+    'latexdocstrout':{isintent_out:['\\item[]{{}\\verb@#pydocsignout#@{}}',
+                                    {l_and(hasnote, isintent_hide):'--- #note#',
+                                     l_and(hasnote, isintent_nothide):'--- See above.'}]},
+    'depend':''
+    },
+# Required/Optional arguments
+    {
+    'kwlist':'"#varname#",',
+    'docsign':'#varname#,',
+    '_check':l_and(isintent_nothide, l_not(isoptional))
+    },
+    {
+    'kwlistopt':'"#varname#",',
+    'docsignopt':'#varname#=#showinit#,',
+    'docsignoptshort':'#varname#,',
+    '_check':l_and(isintent_nothide, isoptional)
+    },
+# Docstring/BuildValue
+    {
+    'docreturn':'#outvarname#,',
+    'returnformat':'#varrformat#',
+    '_check':isintent_out
+    },
+# Externals (call-back functions)
+    { # Common
+    'docsignxa':{isintent_nothide:'#varname#_extra_args=(),'},
+    'docsignxashort':{isintent_nothide:'#varname#_extra_args,'},
+    'docstropt':{isintent_nothide:'#varname#_extra_args : input tuple, optional\\n    Default: ()'},
+    'docstrcbs':'#cbdocstr#',
+    'latexdocstrcbs':'\\item[] #cblatexdocstr#',
+    'latexdocstropt':{isintent_nothide:'\\item[]{{}\\verb@#varname#_extra_args := () input tuple@{}} --- Extra arguments for call-back function {{}\\verb@#varname#@{}}.'},
+    'decl':['\tPyObject *#varname#_capi = Py_None;',
+            '\tPyTupleObject *#varname#_xa_capi = NULL;',
+            '\tPyTupleObject *#varname#_args_capi = NULL;',
+            '\tint #varname#_nofargs_capi = 0;',
+            {l_not(isintent_callback):'\t#cbname#_typedef #varname#_cptr;'}
+            ],
+    'kwlistxa':{isintent_nothide:'"#varname#_extra_args",'},
+    'argformat':{isrequired:'O'},
+    'keyformat':{isoptional:'O'},
+    'xaformat':{isintent_nothide:'O!'},
+    'args_capi':{isrequired:',&#varname#_capi'},
+    'keys_capi':{isoptional:',&#varname#_capi'},
+    'keys_xa':',&PyTuple_Type,&#varname#_xa_capi',
+    'setjmpbuf':'(setjmp(#cbname#_jmpbuf))',
+    'callfortran':{l_not(isintent_callback):'#varname#_cptr,'},
+    'need':['#cbname#', 'setjmp.h'],
+    '_check':isexternal
+    },
+    {
+    'frompyobj':[{l_not(isintent_callback):"""\
+if(F2PyCapsule_Check(#varname#_capi)) {
+  #varname#_cptr = F2PyCapsule_AsVoidPtr(#varname#_capi);
+} else {
+  #varname#_cptr = #cbname#;
+}
+"""}, {isintent_callback:"""\
+if (#varname#_capi==Py_None) {
+  #varname#_capi = PyObject_GetAttrString(#modulename#_module,\"#varname#\");
+  if (#varname#_capi) {
+    if (#varname#_xa_capi==NULL) {
+      if (PyObject_HasAttrString(#modulename#_module,\"#varname#_extra_args\")) {
+        PyObject* capi_tmp = PyObject_GetAttrString(#modulename#_module,\"#varname#_extra_args\");
+        if (capi_tmp)
+          #varname#_xa_capi = (PyTupleObject *)PySequence_Tuple(capi_tmp);
+        else
+          #varname#_xa_capi = (PyTupleObject *)Py_BuildValue(\"()\");
+        if (#varname#_xa_capi==NULL) {
+          PyErr_SetString(#modulename#_error,\"Failed to convert #modulename#.#varname#_extra_args to tuple.\\n\");
+          return NULL;
+        }
+      }
+    }
+  }
+  if (#varname#_capi==NULL) {
+    PyErr_SetString(#modulename#_error,\"Callback #varname# not defined (as an argument or module #modulename# attribute).\\n\");
+    return NULL;
+  }
+}
+"""},
+##    {l_not(isintent_callback):"""\
+## if (#varname#_capi==Py_None) {
+## printf(\"hoi\\n\");
+## }
+## """},
+"""\
+\t#varname#_nofargs_capi = #cbname#_nofargs;
+\tif (create_cb_arglist(#varname#_capi,#varname#_xa_capi,#maxnofargs#,#nofoptargs#,&#cbname#_nofargs,&#varname#_args_capi,\"failed in processing argument list for call-back #varname#.\")) {
+\t\tjmp_buf #varname#_jmpbuf;""",
+{debugcapi:["""\
+\t\tfprintf(stderr,\"debug-capi:Assuming %d arguments; at most #maxnofargs#(-#nofoptargs#) is expected.\\n\",#cbname#_nofargs);
+\t\tCFUNCSMESSPY(\"for #varname#=\",#cbname#_capi);""",
+{l_not(isintent_callback):"""\t\tfprintf(stderr,\"#vardebugshowvalue# (call-back in C).\\n\",#cbname#);"""}]},
+          """\
+\t\tCFUNCSMESS(\"Saving jmpbuf for `#varname#`.\\n\");
+\t\tSWAP(#varname#_capi,#cbname#_capi,PyObject);
+\t\tSWAP(#varname#_args_capi,#cbname#_args_capi,PyTupleObject);
+\t\tmemcpy(&#varname#_jmpbuf,&#cbname#_jmpbuf,sizeof(jmp_buf));""",
+          ],
+'cleanupfrompyobj':
+"""\
+\t\tCFUNCSMESS(\"Restoring jmpbuf for `#varname#`.\\n\");
+\t\t#cbname#_capi = #varname#_capi;
+\t\tPy_DECREF(#cbname#_args_capi);
+\t\t#cbname#_args_capi = #varname#_args_capi;
+\t\t#cbname#_nofargs = #varname#_nofargs_capi;
+\t\tmemcpy(&#cbname#_jmpbuf,&#varname#_jmpbuf,sizeof(jmp_buf));
+\t}""",
+    'need':['SWAP', 'create_cb_arglist'],
+    '_check':isexternal,
+    '_depend':''
+    },
+# Scalars (not complex)
+    { # Common
+    'decl':'\t#ctype# #varname# = 0;',
+    'pyobjfrom':{debugcapi:'\tfprintf(stderr,"#vardebugshowvalue#\\n",#varname#);'},
+    'callfortran':{isintent_c:'#varname#,',l_not(isintent_c):'&#varname#,'},
+    'return':{isintent_out:',#varname#'},
+    '_check':l_and(isscalar, l_not(iscomplex))
+    }, {
+    'need': {hasinitvalue:'math.h'},
+    '_check': l_and(isscalar, l_not(iscomplex)),
+    #'_depend':''
+    }, { # Not hidden
+    'decl':'\tPyObject *#varname#_capi = Py_None;',
+    'argformat':{isrequired:'O'},
+    'keyformat':{isoptional:'O'},
+    'args_capi':{isrequired:',&#varname#_capi'},
+    'keys_capi':{isoptional:',&#varname#_capi'},
+    'pyobjfrom':{isintent_inout:"""\
+\tf2py_success = try_pyarr_from_#ctype#(#varname#_capi,&#varname#);
+\tif (f2py_success) {"""},
+    'closepyobjfrom':{isintent_inout:"\t} /*if (f2py_success) of #varname# pyobjfrom*/"},
+    'need':{isintent_inout:'try_pyarr_from_#ctype#'},
+    '_check':l_and(isscalar, l_not(iscomplex), isintent_nothide)
+    }, {
+    'frompyobj':[
+# hasinitvalue...
+#   if pyobj is None:
+#     varname = init
+#   else
+#     from_pyobj(varname)
+#
+# isoptional and noinitvalue...
+#   if pyobj is not None:
+#     from_pyobj(varname)
+#   else:
+#     varname is uninitialized
+#
+# ...
+#   from_pyobj(varname)
+#
+    {hasinitvalue:'\tif (#varname#_capi == Py_None) #varname# = #init#; else',
+     '_depend':''},
+    {l_and(isoptional, l_not(hasinitvalue)):'\tif (#varname#_capi != Py_None)',
+     '_depend':''},
+    {l_not(islogical):'''\
+\t\tf2py_success = #ctype#_from_pyobj(&#varname#,#varname#_capi,"#pyname#() #nth# (#varname#) can\'t be converted to #ctype#");
+\tif (f2py_success) {'''},
+    {islogical:'''\
+\t\t#varname# = (#ctype#)PyObject_IsTrue(#varname#_capi);
+\t\tf2py_success = 1;
+\tif (f2py_success) {'''},
+     ],
+    'cleanupfrompyobj':'\t} /*if (f2py_success) of #varname#*/',
+    'need':{l_not(islogical):'#ctype#_from_pyobj'},
+    '_check':l_and(isscalar, l_not(iscomplex), isintent_nothide),
+    '_depend':''
+#    },{ # Hidden
+#    '_check':l_and(isscalar,l_not(iscomplex),isintent_hide)
+    }, { # Hidden
+    'frompyobj':{hasinitvalue:'\t#varname# = #init#;'},
+    'need':typedef_need_dict,
+    '_check':l_and(isscalar, l_not(iscomplex), isintent_hide),
+    '_depend':''
+    }, { # Common
+    'frompyobj':{debugcapi:'\tfprintf(stderr,"#vardebugshowvalue#\\n",#varname#);'},
+    '_check':l_and(isscalar, l_not(iscomplex)),
+    '_depend':''
+    },
+# Complex scalars
+    { # Common
+    'decl':'\t#ctype# #varname#;',
+    'callfortran':{isintent_c:'#varname#,',l_not(isintent_c):'&#varname#,'},
+    'pyobjfrom':{debugcapi:'\tfprintf(stderr,"#vardebugshowvalue#\\n",#varname#.r,#varname#.i);'},
+    'return':{isintent_out:',#varname#_capi'},
+    '_check':iscomplex
+    }, { # Not hidden
+    'decl':'\tPyObject *#varname#_capi = Py_None;',
+    'argformat':{isrequired:'O'},
+    'keyformat':{isoptional:'O'},
+    'args_capi':{isrequired:',&#varname#_capi'},
+    'keys_capi':{isoptional:',&#varname#_capi'},
+    'need':{isintent_inout:'try_pyarr_from_#ctype#'},
+    'pyobjfrom':{isintent_inout:"""\
+\t\tf2py_success = try_pyarr_from_#ctype#(#varname#_capi,&#varname#);
+\t\tif (f2py_success) {"""},
+    'closepyobjfrom':{isintent_inout:"\t\t} /*if (f2py_success) of #varname# pyobjfrom*/"},
+    '_check':l_and(iscomplex, isintent_nothide)
+    }, {
+    'frompyobj':[{hasinitvalue:'\tif (#varname#_capi==Py_None) {#varname#.r = #init.r#, #varname#.i = #init.i#;} else'},
+                 {l_and(isoptional, l_not(hasinitvalue)):'\tif (#varname#_capi != Py_None)'},
+#                 '\t\tf2py_success = #ctype#_from_pyobj(&#varname#,#varname#_capi,"#ctype#_from_pyobj failed in converting #nth# `#varname#\' of #pyname# to C #ctype#\\n");'
+                 '\t\tf2py_success = #ctype#_from_pyobj(&#varname#,#varname#_capi,"#pyname#() #nth# (#varname#) can\'t be converted to #ctype#");'
+                 '\n\tif (f2py_success) {'],
+    'cleanupfrompyobj':'\t}  /*if (f2py_success) of #varname# frompyobj*/',
+    'need':['#ctype#_from_pyobj'],
+    '_check':l_and(iscomplex, isintent_nothide),
+    '_depend':''
+    }, { # Hidden
+    'decl':{isintent_out:'\tPyObject *#varname#_capi = Py_None;'},
+    '_check':l_and(iscomplex, isintent_hide)
+    }, {
+    'frompyobj': {hasinitvalue:'\t#varname#.r = #init.r#, #varname#.i = #init.i#;'},
+    '_check':l_and(iscomplex, isintent_hide),
+    '_depend':''
+    }, { # Common
+    'pyobjfrom':{isintent_out:'\t#varname#_capi = pyobj_from_#ctype#1(#varname#);'},
+    'need':['pyobj_from_#ctype#1'],
+    '_check':iscomplex
+    }, {
+    'frompyobj':{debugcapi:'\tfprintf(stderr,"#vardebugshowvalue#\\n",#varname#.r,#varname#.i);'},
+    '_check':iscomplex,
+    '_depend':''
+    },
+# String
+    { # Common
+    'decl':['\t#ctype# #varname# = NULL;',
+            '\tint slen(#varname#);',
+            '\tPyObject *#varname#_capi = Py_None;'],
+    'callfortran':'#varname#,',
+    'callfortranappend':'slen(#varname#),',
+    'pyobjfrom':{debugcapi:'\tfprintf(stderr,"#vardebugshowvalue#\\n",slen(#varname#),#varname#);'},
+#    'freemem':'\tSTRINGFREE(#varname#);',
+    'return':{isintent_out:',#varname#'},
+    'need':['len..'],#'STRINGFREE'],
+    '_check':isstring
+    }, { # Common
+    'frompyobj':"""\
+\tslen(#varname#) = #length#;
+\tf2py_success = #ctype#_from_pyobj(&#varname#,&slen(#varname#),#init#,#varname#_capi,\"#ctype#_from_pyobj failed in converting #nth# `#varname#\' of #pyname# to C #ctype#\");
+\tif (f2py_success) {""",
+    'cleanupfrompyobj':"""\
+\t\tSTRINGFREE(#varname#);
+\t}  /*if (f2py_success) of #varname#*/""",
+    'need':['#ctype#_from_pyobj', 'len..', 'STRINGFREE'],
+    '_check':isstring,
+    '_depend':''
+    }, { # Not hidden
+    'argformat':{isrequired:'O'},
+    'keyformat':{isoptional:'O'},
+    'args_capi':{isrequired:',&#varname#_capi'},
+    'keys_capi':{isoptional:',&#varname#_capi'},
+    'pyobjfrom':{isintent_inout:'''\
+\tf2py_success = try_pyarr_from_#ctype#(#varname#_capi,#varname#);
+\tif (f2py_success) {'''},
+    'closepyobjfrom':{isintent_inout:'\t} /*if (f2py_success) of #varname# pyobjfrom*/'},
+    'need':{isintent_inout:'try_pyarr_from_#ctype#'},
+    '_check':l_and(isstring, isintent_nothide)
+    }, { # Hidden
+    '_check':l_and(isstring, isintent_hide)
+    }, {
+    'frompyobj':{debugcapi:'\tfprintf(stderr,"#vardebugshowvalue#\\n",slen(#varname#),#varname#);'},
+    '_check':isstring,
+    '_depend':''
+    },
+# Array
+    { # Common
+    'decl':['\t#ctype# *#varname# = NULL;',
+            '\tnpy_intp #varname#_Dims[#rank#] = {#rank*[-1]#};',
+            '\tconst int #varname#_Rank = #rank#;',
+            '\tPyArrayObject *capi_#varname#_tmp = NULL;',
+            '\tint capi_#varname#_intent = 0;',
+            ],
+    'callfortran':'#varname#,',
+    'return':{isintent_out:',capi_#varname#_tmp'},
+    'need':'len..',
+    '_check':isarray
+    }, { # intent(overwrite) array
+    'decl': '\tint capi_overwrite_#varname# = 1;',
+    'kwlistxa': '"overwrite_#varname#",',
+    'xaformat': 'i',
+    'keys_xa': ',&capi_overwrite_#varname#',
+    'docsignxa': 'overwrite_#varname#=1,',
+    'docsignxashort': 'overwrite_#varname#,',
+    'docstropt': 'overwrite_#varname# : input int, optional\\n    Default: 1',
+    '_check': l_and(isarray, isintent_overwrite),
+    }, {
+    'frompyobj': '\tcapi_#varname#_intent |= (capi_overwrite_#varname#?0:F2PY_INTENT_COPY);',
+    '_check': l_and(isarray, isintent_overwrite),
+    '_depend': '',
+    },
+    { # intent(copy) array
+    'decl': '\tint capi_overwrite_#varname# = 0;',
+     'kwlistxa': '"overwrite_#varname#",',
+     'xaformat': 'i',
+     'keys_xa': ',&capi_overwrite_#varname#',
+     'docsignxa': 'overwrite_#varname#=0,',
+     'docsignxashort': 'overwrite_#varname#,',
+     'docstropt': 'overwrite_#varname# : input int, optional\\n    Default: 0',
+     '_check': l_and(isarray, isintent_copy),
+     }, {
+     'frompyobj': '\tcapi_#varname#_intent |= (capi_overwrite_#varname#?0:F2PY_INTENT_COPY);',
+     '_check': l_and(isarray, isintent_copy),
+     '_depend': '',
+    }, {
+    'need':[{hasinitvalue:'forcomb'}, {hasinitvalue:'CFUNCSMESS'}],
+    '_check':isarray,
+    '_depend':''
+    }, { # Not hidden
+    'decl':'\tPyObject *#varname#_capi = Py_None;',
+    'argformat':{isrequired:'O'},
+    'keyformat':{isoptional:'O'},
+    'args_capi':{isrequired:',&#varname#_capi'},
+    'keys_capi':{isoptional:',&#varname#_capi'},
+#     'pyobjfrom':{isintent_inout:"""\
+# /* Partly because of the following hack, intent(inout) is depreciated,
+#    Use intent(in,out) instead.
+
+# \tif ((#varname#_capi != Py_None) && PyArray_Check(#varname#_capi) \\
+# \t\t&& (#varname#_capi != (PyObject *)capi_#varname#_tmp)) {
+# \t\tif (((PyArrayObject *)#varname#_capi)->nd != capi_#varname#_tmp->nd) {
+# \t\t\tif (#varname#_capi != capi_#varname#_tmp->base)
+# \t\t\t\tcopy_ND_array((PyArrayObject *)capi_#varname#_tmp->base,(PyArrayObject *)#varname#_capi);
+# \t\t} else
+# \t\t\tcopy_ND_array(capi_#varname#_tmp,(PyArrayObject *)#varname#_capi);
+# \t}
+# */
+# """},
+#     'need':{isintent_inout:'copy_ND_array'},
+    '_check':l_and(isarray, isintent_nothide)
+    }, {
+    'frompyobj':['\t#setdims#;',
+                 '\tcapi_#varname#_intent |= #intent#;',
+                 {isintent_hide:'\tcapi_#varname#_tmp = array_from_pyobj(#atype#,#varname#_Dims,#varname#_Rank,capi_#varname#_intent,Py_None);'},
+                 {isintent_nothide:'\tcapi_#varname#_tmp = array_from_pyobj(#atype#,#varname#_Dims,#varname#_Rank,capi_#varname#_intent,#varname#_capi);'},
+                 """\
+\tif (capi_#varname#_tmp == NULL) {
+\t\tif (!PyErr_Occurred())
+\t\t\tPyErr_SetString(#modulename#_error,\"failed in converting #nth# `#varname#\' of #pyname# to C/Fortran array\" );
+\t} else {
+\t\t#varname# = (#ctype# *)(capi_#varname#_tmp->data);
+""",
+{hasinitvalue:[
+    {isintent_nothide:'\tif (#varname#_capi == Py_None) {'},
+    {isintent_hide:'\t{'},
+    {iscomplexarray:'\t\t#ctype# capi_c;'},
+    """\
+\t\tint *_i,capi_i=0;
+\t\tCFUNCSMESS(\"#name#: Initializing #varname#=#init#\\n\");
+\t\tif (initforcomb(capi_#varname#_tmp->dimensions,capi_#varname#_tmp->nd,1)) {
+\t\t\twhile ((_i = nextforcomb()))
+\t\t\t\t#varname#[capi_i++] = #init#; /* fortran way */
+\t\t} else {
+\t\t\tif (!PyErr_Occurred())
+\t\t\t\tPyErr_SetString(#modulename#_error,\"Initialization of #nth# #varname# failed (initforcomb).\");
+\t\t\tf2py_success = 0;
+\t\t}
+\t}
+\tif (f2py_success) {"""]},
+                 ],
+    'cleanupfrompyobj':[ # note that this list will be reversed
+    '\t}  /*if (capi_#varname#_tmp == NULL) ... else of #varname#*/',
+    {l_not(l_or(isintent_out, isintent_hide)):"""\
+\tif((PyObject *)capi_#varname#_tmp!=#varname#_capi) {
+\t\tPy_XDECREF(capi_#varname#_tmp); }"""},
+    {l_and(isintent_hide, l_not(isintent_out)):"""\t\tPy_XDECREF(capi_#varname#_tmp);"""},
+    {hasinitvalue:'\t}  /*if (f2py_success) of #varname# init*/'},
+    ],
+    '_check':isarray,
+    '_depend':''
+    },
+#    { # Hidden
+#    'freemem':{l_not(isintent_out):'\tPy_XDECREF(capi_#varname#_tmp);'},
+#    '_check':l_and(isarray,isintent_hide)
+#    },
+# Scalararray
+    { # Common
+    '_check':l_and(isarray, l_not(iscomplexarray))
+    }, { # Not hidden
+    '_check':l_and(isarray, l_not(iscomplexarray), isintent_nothide)
+    },
+# Integer*1 array
+    {'need':'#ctype#',
+     '_check':isint1array,
+     '_depend':''
+     },
+# Integer*-1 array
+    {'need':'#ctype#',
+     '_check':isunsigned_chararray,
+     '_depend':''
+     },
+# Integer*-2 array
+    {'need':'#ctype#',
+     '_check':isunsigned_shortarray,
+     '_depend':''
+     },
+# Integer*-8 array
+    {'need':'#ctype#',
+     '_check':isunsigned_long_longarray,
+     '_depend':''
+     },
+# Complexarray
+    {'need':'#ctype#',
+     '_check':iscomplexarray,
+     '_depend':''
+     },
+# Stringarray
+     {
+     'callfortranappend':{isarrayofstrings:'flen(#varname#),'},
+     'need':'string',
+     '_check':isstringarray
+     }
+    ]
+
+################# Rules for checking ###############
+
+check_rules=[
+    {
+    'frompyobj':{debugcapi:'\tfprintf(stderr,\"debug-capi:Checking `#check#\'\\n\");'},
+    'need':'len..'
+    }, {
+    'frompyobj':'\tCHECKSCALAR(#check#,\"#check#\",\"#nth# #varname#\",\"#varshowvalue#\",#varname#) {',
+    'cleanupfrompyobj':'\t} /*CHECKSCALAR(#check#)*/',
+    'need':'CHECKSCALAR',
+    '_check':l_and(isscalar, l_not(iscomplex)),
+    '_break':''
+    }, {
+    'frompyobj':'\tCHECKSTRING(#check#,\"#check#\",\"#nth# #varname#\",\"#varshowvalue#\",#varname#) {',
+    'cleanupfrompyobj':'\t} /*CHECKSTRING(#check#)*/',
+    'need':'CHECKSTRING',
+    '_check':isstring,
+    '_break':''
+    }, {
+    'need':'CHECKARRAY',
+    'frompyobj':'\tCHECKARRAY(#check#,\"#check#\",\"#nth# #varname#\") {',
+    'cleanupfrompyobj':'\t} /*CHECKARRAY(#check#)*/',
+    '_check':isarray,
+    '_break':''
+    }, {
+    'need': 'CHECKGENERIC',
+    'frompyobj': '\tCHECKGENERIC(#check#,\"#check#\",\"#nth# #varname#\") {',
+    'cleanupfrompyobj': '\t} /*CHECKGENERIC(#check#)*/',
+    }
+]
+
+########## Applying the rules. No need to modify what follows #############
+
+#################### Build C/API module #######################
+
+def buildmodule(m, um):
+    """
+    Return
+    """
+    global f2py_version, options
+    outmess('\tBuilding module "%s"...\n'%(m['name']))
+    ret = {}
+    mod_rules=defmod_rules[:]
+    vrd=modsign2map(m)
+    rd=dictappend({'f2py_version':f2py_version}, vrd)
+    funcwrappers = []
+    funcwrappers2 = [] # F90 codes
+    for n in m['interfaced']:
+        nb=None
+        for bi in m['body']:
+            if not bi['block']=='interface':
+                errmess('buildmodule: Expected interface block. Skipping.\n')
+                continue
+            for b in bi['body']:
+                if b['name']==n: nb=b;break
+
+        if not nb:
+            errmess('buildmodule: Could not found the body of interfaced routine "%s". Skipping.\n'%(n))
+            continue
+        nb_list = [nb]
+        if 'entry' in nb:
+            for k, a in nb['entry'].items():
+                nb1 = copy.deepcopy(nb)
+                del nb1['entry']
+                nb1['name'] = k
+                nb1['args'] = a
+                nb_list.append(nb1)
+        for nb in nb_list:
+            api, wrap=buildapi(nb)
+            if wrap:
+                if ismoduleroutine(nb):
+                    funcwrappers2.append(wrap)
+                else:
+                    funcwrappers.append(wrap)
+            ar=applyrules(api, vrd)
+            rd=dictappend(rd, ar)
+
+    # Construct COMMON block support
+    cr, wrap = common_rules.buildhooks(m)
+    if wrap:
+        funcwrappers.append(wrap)
+    ar=applyrules(cr, vrd)
+    rd=dictappend(rd, ar)
+
+    # Construct F90 module support
+    mr, wrap = f90mod_rules.buildhooks(m)
+    if wrap:
+        funcwrappers2.append(wrap)
+    ar=applyrules(mr, vrd)
+    rd=dictappend(rd, ar)
+
+    for u in um:
+        ar=use_rules.buildusevars(u, m['use'][u['name']])
+        rd=dictappend(rd, ar)
+
+    needs=cfuncs.get_needs()
+    code={}
+    for n in needs.keys():
+        code[n]=[]
+        for k in needs[n]:
+            c=''
+            if k in cfuncs.includes0:
+                c=cfuncs.includes0[k]
+            elif k in cfuncs.includes:
+                c=cfuncs.includes[k]
+            elif k in cfuncs.userincludes:
+                c=cfuncs.userincludes[k]
+            elif k in cfuncs.typedefs:
+                c=cfuncs.typedefs[k]
+            elif k in cfuncs.typedefs_generated:
+                c=cfuncs.typedefs_generated[k]
+            elif k in cfuncs.cppmacros:
+                c=cfuncs.cppmacros[k]
+            elif k in cfuncs.cfuncs:
+                c=cfuncs.cfuncs[k]
+            elif k in cfuncs.callbacks:
+                c=cfuncs.callbacks[k]
+            elif k in cfuncs.f90modhooks:
+                c=cfuncs.f90modhooks[k]
+            elif k in cfuncs.commonhooks:
+                c=cfuncs.commonhooks[k]
+            else:
+                errmess('buildmodule: unknown need %s.\n'%(repr(k)));continue
+            code[n].append(c)
+    mod_rules.append(code)
+    for r in mod_rules:
+        if ('_check' in r and r['_check'](m)) or ('_check' not in r):
+            ar=applyrules(r, vrd, m)
+            rd=dictappend(rd, ar)
+    ar=applyrules(module_rules, rd)
+
+    fn = os.path.join(options['buildpath'], vrd['coutput'])
+    ret['csrc'] = fn
+    f=open(fn, 'w')
+    f.write(ar['modulebody'].replace('\t', 2*' '))
+    f.close()
+    outmess('\tWrote C/API module "%s" to file "%s"\n'%(m['name'], fn))
+
+    if options['dorestdoc']:
+        fn = os.path.join(options['buildpath'], vrd['modulename']+'module.rest')
+        f=open(fn, 'w')
+        f.write('.. -*- rest -*-\n')
+        f.write('\n'.join(ar['restdoc']))
+        f.close()
+        outmess('\tReST Documentation is saved to file "%s/%smodule.rest"\n'%(options['buildpath'], vrd['modulename']))
+    if options['dolatexdoc']:
+        fn = os.path.join(options['buildpath'], vrd['modulename']+'module.tex')
+        ret['ltx'] = fn
+        f=open(fn, 'w')
+        f.write('%% This file is auto-generated with f2py (version:%s)\n'%(f2py_version))
+        if 'shortlatex' not in options:
+            f.write('\\documentclass{article}\n\\usepackage{a4wide}\n\\begin{document}\n\\tableofcontents\n\n')
+        f.write('\n'.join(ar['latexdoc']))
+        if 'shortlatex' not in options:
+            f.write('\\end{document}')
+        f.close()
+        outmess('\tDocumentation is saved to file "%s/%smodule.tex"\n'%(options['buildpath'], vrd['modulename']))
+    if funcwrappers:
+        wn = os.path.join(options['buildpath'], vrd['f2py_wrapper_output'])
+        ret['fsrc'] = wn
+        f=open(wn, 'w')
+        f.write('C     -*- fortran -*-\n')
+        f.write('C     This file is autogenerated with f2py (version:%s)\n'%(f2py_version))
+        f.write('C     It contains Fortran 77 wrappers to fortran functions.\n')
+        lines = []
+        for l in ('\n\n'.join(funcwrappers)+'\n').split('\n'):
+            if l and l[0]==' ':
+                while len(l)>=66:
+                    lines.append(l[:66]+'\n     &')
+                    l = l[66:]
+                lines.append(l+'\n')
+            else: lines.append(l+'\n')
+        lines = ''.join(lines).replace('\n     &\n', '\n')
+        f.write(lines)
+        f.close()
+        outmess('\tFortran 77 wrappers are saved to "%s"\n'%(wn))
+    if funcwrappers2:
+        wn = os.path.join(options['buildpath'], '%s-f2pywrappers2.f90'%(vrd['modulename']))
+        ret['fsrc'] = wn
+        f=open(wn, 'w')
+        f.write('!     -*- f90 -*-\n')
+        f.write('!     This file is autogenerated with f2py (version:%s)\n'%(f2py_version))
+        f.write('!     It contains Fortran 90 wrappers to fortran functions.\n')
+        lines = []
+        for l in ('\n\n'.join(funcwrappers2)+'\n').split('\n'):
+            if len(l)>72 and l[0]==' ':
+                lines.append(l[:72]+'&\n     &')
+                l = l[72:]
+                while len(l)>66:
+                    lines.append(l[:66]+'&\n     &')
+                    l = l[66:]
+                lines.append(l+'\n')
+            else: lines.append(l+'\n')
+        lines = ''.join(lines).replace('\n     &\n', '\n')
+        f.write(lines)
+        f.close()
+        outmess('\tFortran 90 wrappers are saved to "%s"\n'%(wn))
+    return ret
+
+################## Build C/API function #############
+
+stnd={1:'st',2:'nd',3:'rd',4:'th',5:'th',6:'th',7:'th',8:'th',9:'th',0:'th'}
+
+def buildapi(rout):
+    rout, wrap = func2subr.assubr(rout)
+    args, depargs=getargs2(rout)
+    capi_maps.depargs=depargs
+    var=rout['vars']
+    auxvars = [a for a in var.keys() if isintent_aux(var[a])]
+
+    if ismoduleroutine(rout):
+        outmess('\t\t\tConstructing wrapper function "%s.%s"...\n'%(rout['modulename'], rout['name']))
+    else:
+        outmess('\t\tConstructing wrapper function "%s"...\n'%(rout['name']))
+    # Routine
+    vrd=routsign2map(rout)
+    rd=dictappend({}, vrd)
+    for r in rout_rules:
+        if ('_check' in r and r['_check'](rout)) or ('_check' not in r):
+            ar=applyrules(r, vrd, rout)
+            rd=dictappend(rd, ar)
+
+    # Args
+    nth, nthk=0, 0
+    savevrd={}
+    for a in args:
+        vrd=sign2map(a, var[a])
+        if isintent_aux(var[a]):
+            _rules = aux_rules
+        else:
+            _rules = arg_rules
+            if not isintent_hide(var[a]):
+                if not isoptional(var[a]):
+                    nth=nth+1
+                    vrd['nth']=repr(nth)+stnd[nth%10]+' argument'
+                else:
+                    nthk=nthk+1
+                    vrd['nth']=repr(nthk)+stnd[nthk%10]+' keyword'
+            else: vrd['nth']='hidden'
+        savevrd[a]=vrd
+        for r in _rules:
+            if '_depend' in r:
+                continue
+            if ('_check' in r and r['_check'](var[a])) or ('_check' not in r):
+                ar=applyrules(r, vrd, var[a])
+                rd=dictappend(rd, ar)
+                if '_break' in r:
+                    break
+    for a in depargs:
+        if isintent_aux(var[a]):
+            _rules = aux_rules
+        else:
+            _rules = arg_rules
+        vrd=savevrd[a]
+        for r in _rules:
+            if '_depend' not in r:
+                continue
+            if ('_check' in r and r['_check'](var[a])) or ('_check' not in r):
+                ar=applyrules(r, vrd, var[a])
+                rd=dictappend(rd, ar)
+                if '_break' in r:
+                    break
+        if 'check' in var[a]:
+            for c in var[a]['check']:
+                vrd['check']=c
+                ar=applyrules(check_rules, vrd, var[a])
+                rd=dictappend(rd, ar)
+    if isinstance(rd['cleanupfrompyobj'], list):
+        rd['cleanupfrompyobj'].reverse()
+    if isinstance(rd['closepyobjfrom'], list):
+        rd['closepyobjfrom'].reverse()
+    rd['docsignature']=stripcomma(replace('#docsign##docsignopt##docsignxa#',
+                                          {'docsign':rd['docsign'],
+                                           'docsignopt':rd['docsignopt'],
+                                           'docsignxa':rd['docsignxa']}))
+    optargs=stripcomma(replace('#docsignopt##docsignxa#',
+                               {'docsignxa':rd['docsignxashort'],
+                                'docsignopt':rd['docsignoptshort']}
+                               ))
+    if optargs=='':
+        rd['docsignatureshort']=stripcomma(replace('#docsign#', {'docsign':rd['docsign']}))
+    else:
+        rd['docsignatureshort']=replace('#docsign#[#docsignopt#]',
+                                        {'docsign': rd['docsign'],
+                                         'docsignopt': optargs,
+                                         })
+    rd['latexdocsignatureshort']=rd['docsignatureshort'].replace('_', '\\_')
+    rd['latexdocsignatureshort']=rd['latexdocsignatureshort'].replace(',', ', ')
+    cfs=stripcomma(replace('#callfortran##callfortranappend#', {'callfortran':rd['callfortran'],'callfortranappend':rd['callfortranappend']}))
+    if len(rd['callfortranappend'])>1:
+        rd['callcompaqfortran']=stripcomma(replace('#callfortran# 0,#callfortranappend#', {'callfortran':rd['callfortran'],'callfortranappend':rd['callfortranappend']}))
+    else:
+        rd['callcompaqfortran']=cfs
+    rd['callfortran']=cfs
+    if isinstance(rd['docreturn'], list):
+        rd['docreturn']=stripcomma(replace('#docreturn#', {'docreturn':rd['docreturn']}))+' = '
+    rd['docstrsigns']=[]
+    rd['latexdocstrsigns']=[]
+    for k in ['docstrreq', 'docstropt', 'docstrout', 'docstrcbs']:
+        if k in rd and isinstance(rd[k], list):
+            rd['docstrsigns']=rd['docstrsigns']+rd[k]
+        k='latex'+k
+        if k in rd and isinstance(rd[k], list):
+            rd['latexdocstrsigns']=rd['latexdocstrsigns']+rd[k][0:1]+\
+                                    ['\\begin{description}']+rd[k][1:]+\
+                                    ['\\end{description}']
+
+    # Workaround for Python 2.6, 2.6.1 bug: http://bugs.python.org/issue4720
+    if rd['keyformat'] or rd['xaformat']:
+        argformat = rd['argformat']
+        if isinstance(argformat, list):
+            argformat.append('|')
+        else:
+            assert isinstance(argformat, str), repr((argformat, type(argformat)))
+            rd['argformat'] += '|'
+
+    ar=applyrules(routine_rules, rd)
+    if ismoduleroutine(rout):
+        outmess('\t\t\t  %s\n'%(ar['docshort']))
+    else:
+        outmess('\t\t  %s\n'%(ar['docshort']))
+    return ar, wrap
+
+
+#################### EOF rules.py #######################