text: #!/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 <pearu@ioc.ee>
  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 os
  import time
  import copy
  
  from .auxfuncs import (
      applyrules, debugcapi, dictappend, errmess, gentitle, getargs2,
      hascallstatement, hasexternals, hasinitvalue, hasnote, hasresultnote,
      isarray, isarrayofstrings, iscomplex, iscomplexarray,
      iscomplexfunction, iscomplexfunction_warn, isdummyroutine, isexternal,
      isfunction, isfunction_wrap, isint1array, isintent_aux, isintent_c,
      isintent_callback, isintent_copy, isintent_hide, isintent_inout,
      isintent_nothide, isintent_out, isintent_overwrite, islogical,
      islong_complex, islong_double, islong_doublefunction, islong_long,
      islong_longfunction, ismoduleroutine, isoptional, isrequired, isscalar,
      issigned_long_longarray, isstring, isstringarray, isstringfunction,
      issubroutine, issubroutine_wrap, isthreadsafe, isunsigned,
      isunsigned_char, isunsigned_chararray, isunsigned_long_long,
      isunsigned_long_longarray, isunsigned_short, isunsigned_shortarray,
      l_and, l_not, l_or, outmess, replace, stripcomma,
  )
  
  from . import capi_maps
  from . import cfuncs
  from . import common_rules
  from . import use_rules
  from . import f90mod_rules
  from . import func2subr
  
  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 <pearu@cens.ioc.ee>.
   * 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*/',
          # this list will be reversed
          'cleanupfrompyobj': ['/*end of cleanupfrompyobj*/'],
          'pyobjfrom': '/*pyobjfrom*/',
          # this list will be reversed
          'closepyobjfrom': ['/*end of closepyobjfrom*/'],
          '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#),(f2py_init_func)#apiname#,doc_#apiname#},',
                          l_and(l_not(ismoduleroutine), isintent_c):
                          '\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;
    }
  }
  """},
              """\
  \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)),
      }, {  # 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
          '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,"#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#);'},
          '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'},
          '_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# *)(PyArray_DATA(capi_#varname#_tmp));
  """,
                        {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(PyArray_DIMS(capi_#varname#_tmp),PyArray_NDIM(capi_#varname#_tmp),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': ''
      },
      # 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 = capi_maps.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']
  
      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 = capi_maps.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 = capi_maps.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 #######################
  