Mercurial > hg > vamp-build-and-test
diff DEPENDENCIES/mingw32/Python27/Lib/site-packages/numpy/f2py/rules.py @ 87:2a2c65a20a8b
Add Python libs and headers
| author | Chris Cannam |
|---|---|
| date | Wed, 25 Feb 2015 14:05:22 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/DEPENDENCIES/mingw32/Python27/Lib/site-packages/numpy/f2py/rules.py Wed Feb 25 14:05:22 2015 +0000 @@ -0,0 +1,1448 @@ +#!/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 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 <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*/', + '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 #######################